History of C
C is a general-purpose computer programming language developed between
1969 and 1973 by Dennis Ritchie at the Bell Telephone Laboratories for use with
the Unix
operating
system. according to Ritchie, the most creative period occurred in 1972. It was
named "C" because its features were derived from an earlier language
called "B", which according to Ken Thompson was a
stripped-down version of the BCPL programming language.
Although
C was designed for implementing system
software, it is also widely used for developing portable application software.
C is
one of the most widely used programming languages of all time and there are
very few computer architectures for which a C compiler
does not exist. C has greatly influenced many other popular programming
languages, most notably C++, which began as an extension to C.
The origin of C is closely tied to the development of the
Unix operating system,
originally implemented in assembly language on a PDP-7 by Ritchie and
Thompson, incorporating several ideas from colleagues. Eventually they decided
to port the operating system to a PDP-11. B's inability to take advantage of some of the
PDP-11's features, notably byte addressability, led to the development of an early
version of C.
The original PDP-11 version of the Unix system was
developed in assembly language. By 1973, with the addition of struct types, the C
language had become powerful enough that most of the Unix kernel was rewritten in C. This was one of the
first operating system kernels implemented in a language other than assembly.
(Earlier instances include the Multics system (written in PL/I), and MCP (Master Control Program) for the Burroughs B5000 written in ALGOL in 1961.)
In 1978, Brian
Kernighan and Dennis Ritchie published the first edition of The C Programming Language.[8]
This book, known to C programmers as "K&R", served for many years
as an informal specification of the language. The version of C
that it describes is commonly referred to as K&R C. The second
edition of the book covers the later ANSI C
standard
The Structure of a C Program
All C programs will consist of at
least one function, but we can write a C programs that have several functions
body . The only function that has to be present is the function main. For
more advanced programs the main function will act as
a controling function calling other functions in their turn to do the dirty
work! The main function is the first function that is called
when your program executes. So main is the starting of execution of program.
preprocessor directives
global declarations of user functions
global variables declarations
main()
{
local variables to function main ;
statements associated with function main ;
}
definitions of functions like
function1()
{
local variables to function 1 ;
statements associated with function 1 ;
}
function2()
{
local variables to function f2 ;
statements associated with function 2 ;
}
.
.
.
etc
Note the use of the bracket set () and {}:
() are used in conjunction with function names whereas {} are used with the C statements that are associated with
that function and used for statements block. A semicolon (;) is used to
terminate C statements. C is a free format language and long statements can be
continued, without truncation, onto the next line. The semicolon informs the C
compiler that the end of the statement has been reached. Free format also means
that you can add as many spaces as you like to improve the look of your
programs.
A very common mistake made by everyone, who is new
to the C programming language, is to miss off the semicolon. The C compiler
will concatenate the various lines of the program together and then tries to
understand them - which it will not be able to do. The error message produced
by the compiler will relate to a line of program which could be some distance
from the initial mistake.
The first C Progam:
1 /* This program prints the Welcome to C Programming. */
2 #include<stdio.h> /* header file */
3 main()
4 {
5 printf(“Welcome to C
programming.\n”);
6 } /*End of program */
Analysis:
Comments: See the lines 1,2,6 of the program
Any things between /* and */ is treated as comments in
C. These are for only programmer references . Comments are escaped by C
compiler during compilation of program.
Preprocessor: See in line 2.
#include<stdio.h>
stdio.h is an input output header file which contains the input/output
and file handling functions which are used in C programs. The required header
file should be included using #include preprocessor directive.
main():
C programs are made of functions. main() is a special function which should be there in each c
program. Each C program starts executing from main() function. As program cannot have many starting points, C
program should have main function once and only once. main() may call other function to perform the given task.
Comments:
Any
things between /* and */ is treated as comments in C. These are for only
programmer references . Comments are escaped by C compiler during compilation
of program.
Preprocessor:
#include<stdio.h>
stdio.h is an input
output header file which contains the input/output and file handling functions
which are used in C programs. The required header file should be included using
#include preprocessor directive.
main():
C
programs are made of functions. main()
is a special function which should be there in each c program. Each C program
starts executing from main()
function. As program cannot have many starting points, C program should have
main function once and only once. main()
may call other function to perform the given task.
printf():
printf is an output function which has been defined
in stdio.h file. What ever is
put inside the function printf
between two double quotes is printed on
the screen
New lines: Note that printf
never puts new line automatically. To put new line we require to put ‘\n’
between double quotes inside ‘ printf’
function. Eg
printf(“Welcome to ”);
printf(“C programming”);
Out put: Welcome to C
programming
Using new line:
printf(“Welcome to\nC programming”);
Prints the line as
Welcome to
C programming.
Statements: C programs are made of functions. Functions contain
statements. Statement performs a specific action and terminated by semicolon
‘;’ . In the above program
printf(“Welcome to C
programming”); is only statement.
You can write printf statement in multiple line . for example. :
The statement:
printf(“ The increasing popularity of C is
probably”
“
Due to its many desirable quantities/.”
“It is a robust language whose
rich set is “);
is a single statement.
The Second program:
1.
/*
program2.c */
2.
/*This
program accepts a character two number and displays them in screen */
3.
#include<stdio.h>
4.
main()
5.
{
6.
char c; int i;
7.
float f;
8.
printf(“\nEnter a character:”);
9.
Scanf(“%c”,&c);
10. printf(“\nEnter an integer;”);
11. scanf(“%d”,&i);
12. printf(“\nEnter a floating pt number:”);
13. scanf(“%f”,&f);
14. printf(“character: %c\n integeris:%d,float:
%f”,c,i,f);
15. } /*end of main() */
Analysis:
Variable and types:
Line number 6 and 7
in program are:
char c; int i; and float f;
In those lines,
c,i, f are variables and int, char, float are data types key words for declaration of variables in C
program.
In C there are four
primitive types of variables.
- char : it can store one ASCII character(i.e. one byte only )
- int: it can store integers( i.e. without decimal precision values). Its size is generally 2 bytes. However it differs from machine to machine. In some machines it is equal to 4 bytes. If it is two bytes it can store numbers from -32768 to +32767
- float : Single precision number with decimal value. Its size is generally equal to 4 bytes.
- double: Double precision number with decimal value. Its size is generally equal to 8 bytes.
How these types are
indicated in printf and scanf functions ?
- char : by %c
- int : by %d(decimal) , %i (integer) , %x(hex) , %o (octal)
- float : by %f
- double : by %f
in C each necessary
variable is declared before its use. If
variable is declared outside the function, it is called global variable and
visible to all the functions in that program. If variable is declared inside
the function it is called local variable and visible only for that particular
function only.
How to give the
variable name ?
There some
restrictions on naming the variables in C.
- Variable name should begin with a alphabetic character. But underscore character ‘_’ is also legal character as beginning character for variable name.
- Variable name should contain only letters ,digits and underscore characters. No other characters are allowed for name.
- Variable name should be unambiguous within its first eight characters since first eight characters are treated as significant characters by many compilers.
- Uppercase and lowercase are significant. i.e. name, Name,NAME or nAme all are different variables.
- The C key word can not be a variable name.
- White spaces are not allowed
Here are some
examples of valid and invalid variable names in C.
Valid variable
names:
Abc, name ,
_name, first_name alpha_1,
alpha99 alp97bc etc
Invalid varieable name:
(Why ?)
123_res, first name, ret?b first-name
ab:xy, % int return
The declaration of variables
is done as:
<data type > <variable name> ;
we can declare more than one
variable of same type with single type declaration as:
char var1,var2,var3,……,varn;
float e,f,g; and so on.
The scanf() function:
Scanf() is an input
function defined in stdio.h header file. Scanf accepts the input from keyboard. As above programs the
syntax of input function scanf is
Scanf(“specifier”,&variablename);
The
specifier may be any one of %d,%c,%f and so on.
The & is an address operator in scanf function . &variablename specifies the memory
address for the variable and the value entered from keyboard is stored in that
specified location.
Recall the line 14 of
program:
printf(“character: %c\n
integer:%d,float: %f”,c,i,f);
if our input is :
c=’A’, i=10,and f=23.45
This produces the
output as:
character: A
integer : 10
float : 23.450000
The specifier
%c,%d,%f etc inside the double quote of the printf
statement displays the actual value of variable listed after the closing of
double quote and comma ‘,’ sequentially. If there are no listing of variables
for those specifier, then the some garbage value is printed.
Using Pression specifiers in the display of
float numbers.
You may have
noticed that the floating point number example
in above program 2 have displayed
with more decimal places in them than
were in original number. You can exercise greater control over how a float
number is displayed using precision specifier to limit the number the number of
decimal places displayed.
For example the variable x contains the number 23.456789
and you only want two of its decimal
places for display the printf statement looks like
Printf(“%5.2f”,x);
which will produce out put as 23.45
Similary you can print the integer numbers with interleaving spaces
using specifiers.
Example: int x=10,y=40,z=30;
If the printf statement in program is :
printf(“%d%d%d”,x,y,z); then the output
is : 104030 which is ambiguous.
You can print it in meaningful
format using formatted printf statement
as:
printf (“%4d%4d%5d”,x,y,z); which gives output as: 10
40 30
The Third Program:
1. /* progm3.c */
2. /*this program illustrates the simple
arithmetic and assignment operators */
3. #include<stdio.h>
4. main()
5. {
6. int
num1,num2,sum,dif,prod, rem;
7. float div;
8. printf(“\nEnter the firsrt number:”);
9. scanf(“%d”,&num1);
10.
printf(“\nEnter the second number: “);
11.
scanf(“%d”,&num2);
12.
sum=num1+num2;
13.
dif=num1-num2;
14.
prod=num1*num2;
15.
div=(float)num1/(float)num2;
16.
printf(“The sum is %d”, sum);
17.
printf(“\nThe difference of %d and %d is %d
“,
num1,num2,dif);
18.
printf(“\n%d x %d = %d “ ,num1,num2,prod);
19.
printf(“\nThe quotient after division is %f”, div);
20.
printf(“\nThe remainder dividing %d with %d
is : %d”,
num1,num2,num1%num2);
21.
}
/*end of program */
Arithmetic
operators in C:
+ for addition
-
for subtraction
* for
multiplication
/ for division
% for remainder ( only for integer division )
Assignment
Operator:
= for assign the value to a variable.
e. g.
int x = 10;
float f = 56.34;
char c = ‘n’; /* character constant is included inside single quote */
short-cut assignment:
+=, -=, *= , /=
eg. x= x+10
equivalent to x+=10
var1 = var1 * var2 equivalent to var1*=var2 ………….and so on
Constants:
Constants are those
that don’t changes during the whole program execution.
Constants are
defined in C by the following two ways.
- using #define directive:
syntax : #define identifier value /* note no
semicolon */
e.g. #define PI 3.14
#define ADULT_AGE 18
#define GREETING “Wishing you Happy Dashain “
2. Using const key word:
syntax: <const> <data type> identifier = value
;
eg. const
float PI = 3.14;
const
char ch = ‘#’;
Expressions:
Expressions are combinations of variables ,constants and operators
arranged as per the grammar of the language. C can handle any complex types of expressions . some
example of mathematical expressions in C are as shown.
Algrabic expression C
expression
ab – c a*b-c
(m+n) (x+y) (m+n)
* (x+y)
|
![]() |
3x2+2x-1 3*x*x
+2*x – 1
|
y
Note: There is no any operator
in C for exponentiation.
Data types Variables and Constants
float total;
double sum;
To assign a numerical value to our floating point and double precision variables we would use the following C statement:
total=0.0;
sum=12.50;
For example:
char c;
C's Character Set
C does not use, nor requires the use of, every character
found on a modern computer keyboard. The only characters required by the C
Programming Language are as follows:
- A - Z
- a -z
- 0 - 9
- space . , : ; ' $ "
- # % & ! _ {} [] () < > | \
- + - / * = ?
The form of a C
Program
All C programs will consist of at
least one function, but we can write a C programs that have several functions
body . The only function that has to be present is the function main.
For more advanced programs the main
function will act as a controling function calling other functions in their
turn to do the dirty work! The main
function is the first function that is called when your program executes. So
main is the starting of execution of program.
The layout of C Programs
The general form of a C program is
as follows :
preprocessor directives
global declarations of user functions
global variables declarations
main()
{
local variables to function main ;
statements associated with function main ;
}
definitions of functions like
function1()
{
local variables to function 1 ;
statements associated with function 1 ;
}
function2()
{
local variables to function f2 ;
statements associated with function 2 ;
}
.
.
.
etc
Note the use of the bracket set () and {}:
() are used in conjunction with function names whereas {} are used with the C statements that are associated with that
function and used for statements block. A semicolon (;) is used to terminate C
statements. C is a free format language and long statements can be continued,
without truncation, onto the next line. The semicolon informs the C compiler
that the end of the statement has been reached. Free format also means that you
can add as many spaces as you like to improve the look of your programs.
A very common mistake made by everyone, who is new
to the C programming language, is to miss off the semicolon. The C compiler
will concatenate the various lines of the program together and then tries to
understand them - which it will not be able to do. The error message produced
by the compiler will relate to a line of program which could be some distance
from the initial mistake.
Data types Variables and Constants
C language supports following data
types;
1. Primary(or fundamental) data types
2. User-defined data types
3. Derived data types
4. empty data sets.
Primary Data types and associated
variables :
There are five basic data types in
C associated with variables:
- int - integer: a whole number.
- float - floating point value: i.e. a number with a fractional part.
- double - a double-precision floating point value.
- char
- a single character.
Variables
A variable is a named data storage
location in the computer's memory. By
using
a variable's name in our program, we are, in effect, referring
to the data
stored there.
Numeric Variable
Types
C provides several different types
of numeric variables. We need different
types of variables because different numeric values have
varying memory storage
requirements and differ in the ease with which certain
mathematical operations
can be performed on them. Small integers (for example, 1,
199, and -8) require
less memory to store, and the computer can perform
mathematical operations
(addition, multiplication, and so on) with such numbers very
quickly. In
contrast, large integers and floating-point values
(123,000,000 or
0.000000871256, for example) require more storage space and
more time for
mathematical operations. By using the appropriate variable
types, we ensure
that our program runs as efficiently as possible.
Following table shows the data types and the byte
required and Renges of values for different variable.
Variable Type Keyword Bytes
Required Range
Character char 1 -128 to 127
Integer int 2 -32768 to 32767
Short integer short 2 -32768 to 32767
Long integer long 4 -2,147,483,648 to 2,147,438,647
Unsigned
character unsigned char 1 0 to 255
Unsigned integer
unsigned int 2 0 to 65535
Unsigned short
integer unsigned short 2 0
to 65535
Unsigned long
integer unsigned long 4 0
to 4,294,967,295
Single-precision
float 4 3.4E-38 to 3.4E+38
floating-point
Double-precision double 8 1.7 E-308 to 1.7E+308
floating-point
Integer Variables
The first type of variable we need
to know about is of class type int
- short for integer. An int
variable can store a value in the range -32768 to +32767. We can think of it as
a largest positive or negative whole number: no fractional part is allowed. To
declare an int you use
the instruction:
int
variable name;
For example:
int
a;
declares that we want to create an int variable called a.
To assign a value
to our integer variable we would use the following C statement:
a=10;
The C
programming language uses the "=" character for assignment. A
statement of the form a=10;
should be interpreted as take the numerical value 10 and store it in a
memory location associated with the integer variable a. The "="
character should not be seen as an equality otherwise writing statements of the
form:
a=a+10;
will get mathematicians blowing
fuses! This statement should be interpreted as take the current value
stored in a memory location associated with the integer variable a; add the
numerical value 10 to it and then replace this value in the memory location
associated with a.
Floating point Number Variables
As described above, an integer
variable has no fractional part. Integer variables tend to be used for
counting, whereas real numbers are used in arithmetic. C uses one
of two keywords to declare a variable that is to be associated with a decimal
number: float and double. They are each offer a
different level of precision as outlined below.
float
A float, or floating point, number
has about seven digits of precision and a range of about 1.2E-38 to 3.4E+38. A
float takes four bytes to store.
double
A double, or double precision,
number has about 13 digits of precision and a range of about 2.2E-308 to
1.8E+308. A double takes eight bytes to store.
For example: float total;
double sum;
To assign a numerical value to our floating point and double precision variables we would use the following C statement:
total=0.0;
sum=12.50;
Character Variables
C only has a concept of
numbers and characters. It very often comes as a surprise to some programmers
who learnt a beginner's language such as BASIC that C has no
understanding of strings but a string is only an array of
characters and C does have a concept of arrays which we shall be meeting
later in this course.
To declare a variable of type character we use the keyword char. - A single character stored in
one byte. For example:
char c;
To assign, or store, a character value in a char data type is easy - a character
variable is just a symbol enclosed by single quotes. For example, if c is a char variable you can store the letter A in it
using the following C statement:
c='A'
Notice that you can only store a single character
in a char variable. Remember
that the value for a char
variable is 'A' and not "A".
A program that displays the size of variable
types.
/* C--Program to tell the size of the C variable */
/* type in bytes */
#include <stdio.h>
main()
{
printf( "\nA char is %d bytes", sizeof( char ));
printf( "\nAn int is %d bytes", sizeof( int ));
printf( "\nA short is %d bytes", sizeof( short ));
printf( "\nA long is %d bytes", sizeof( long ));
printf( "\nAn unsigned char is %d bytes", sizeof( unsigned char ));
printf( "\nAn unsigned int is %d bytes", sizeof( unsigned int ));
printf( "\nAn unsigned short is %d
bytes", sizeof( unsigned short ));
printf( "\nAn unsigned long is %d bytes", sizeof( unsigned long ));
printf( "\nA float is %d bytes", sizeof( float ));
printf( "\nA double is %d bytes\n", sizeof( double ));
return 0;
}
output:
A char is 1 bytes
An int is 2 bytes
A short is 2 bytes
A long is 4 bytes
An unsigned char is 1 bytes
An unsigned int is 2 bytes
An unsigned short is 2 bytes
An unsigned long is 4 bytes
A float is 4 bytes
A double is 8 bytes
User
defined data types:
The data types that are defined by programmer themselves are
called user defined data types. C supports a feature known as “type definition”
that allows user to define an identifier that would represent an existing type.
The user defined type is later used to declare the variables.We can use keyword
typedef
The general form is :
typedef type
identifier;
type refers to the
existing type and identifier refers to the new name given to the type.
Eg. typedef int integer;
typedef
char character;
typedef
int boolean;
The user defined type is then used to declare the variable
as
integer
sum,product;
boolean flag;
character c;
Another user-defined type is
enumerated data type provided by ANSI standard C .it is defined as follows:
enum identifier
{value1,value2…….valuen};
The identifier is a user-defined
enumerated type which can be used to declare variable that can have one of the
values enclosed within braces(known as enumeration constants). After this
definition, we can declare variables to be of new type as
enum identifier var1,var2….varn;
The enumerated variables
var1,var2,….varn can only have one of the values from the enumeration constants
listed within {…}
The assignment can be done as:
var1=value2;
var2=
valuen;
The
Compiler automatically assigns integer digits beginning with 0 to all the
enumeration constants. i.e. value for value1 above is 0 ,value2 is 1 and so on.
But automatic assignments can be changed by assigning values to the enumeration
constants as
enum day { Monday=1,
Tuesday,…….Sunday};
Constants
Like a variable, a constant is a
data storage location used by our program. Unlike a variable, the value stored
in a constant can't be changed during program execution. C has two types of
constants, each with its own specific uses.
The constants in C are illustrated in
figure below:
Integer
Constants
are sequences of digits. There are three types of integers namely decimal
,octal and hexadecimal .
The largest
integer value that can be stored is
machine-dependent. It is 32767 on 16 bit machine and 2,147,483,647 on
32-bit machine. But it is also possible to store larger integer constants on
these machines by appending qualifiers such as U,L and UL to the constants.
e.g.
56789U
or 56789u for unsigned integer
987612347UL or
987612347ul for unsigned long
integer.
9876543L
or 9876543l for long integer.
Real Constants are the numbers
with fractional parts and optional leading + or – symbol.
e.g.
0.9876 , -9.786
+98.765 etc which are in decimal
notation.
0.65e4
, 1.5e+5 -1.2E-1 etc. in scientific notations.
Single Character
constants
contains a single character enclosed within a pair of single quote marks.
Example: ‘c’ ‘%’ ‘&’ ‘7’ etc.
A String
Constant
is a sequence of characters enclosed in double quotes. The characters may be
letters, numbers special characters and blank space.
Example: “Well come”
“a”
“890”
“*&^%$” etc.
In addition C
supports some special backslash character constants that are used in output
functions.
For example:
‘\n’ for newline, ‘\t’ for tab, ‘\b’ for
back space, ‘\”’ for double quote ‘\\’ for \ and so on.
A small program
to illustrate the constants in c .
/* this program
illustrates the constants used in C */
#include<stdio.h>
main()
{
printf(“\nIntegers : ”);
printf(“%d, %d , %d”,32767,32767+1,32767+10);
printf(“\nLong integers: ”);
printf(“%ld, %ld, %ld “, 32767,32767+1,32767+10);
printf(“\nUnsigned integers: ”);
printf(“%u,%u,%u”, 32767,32767+1,32767+10);
printf(“\nReal constants:”);
printf(“%f, %f, %f”,3.4,9.9e3,-1.2e-6);
printf(“\nCharacter :%c “,’A’);
printf(“\nA string :%s “, “C programming”);
return 0;
}
output is
Integers : 32767, -32768 ,
-32759
Long integers : 32767,
32768, 32777
Unsigned integers : 32767,
32768, 32777
Real constants: 3.400000,
9100.000000, -0.000001
Character : A
A String : C programming
All the types of above constants can be
classified in to two main categories.
1.
Literal Constants 2.
Symbolic Constants.
Literal
Constants
A
literal constant is a value that is typed directly into the source code
wherever it is needed. Here are two examples:
int
count = 20;
float
tax_rate = 0.28;
The 20 and the 0.28 are literal
constants. The preceding statements store these values in the variables count
and tax_rate. Note that one of these constants contains a decimal point,
whereas the other does not. The presence or absence of the decimal point
distinguishes floating-point constants from integer constants.
A literal constant written with a
decimal point is a floating-point constant and is represented by the C compiler
as a double-precision number. Floating-point constants can be written in
standard decimal notation, as shown in these examples:
123.456
0.019
100.
Note
that the third constant, 100., is written with a decimal point even though it's
an integer (that is, it has no fractional part). The decimal point causes the C
compiler to treat the constant as a double-precision value. Without the decimal
point, it is treated as an integer constant.
Floating-point constants also can be
written in scientific notation. In C, scientific notation is written as a
decimal number followed immediately by an E or e and the exponent:
1.23E2 is 1.23 times 10 to
the 2nd power, or 123
4.08e6 4.08 times 10 to
the 6th power, or 4,080,000
0.85e-4 0.85 times 10 to
the -4th power, or 0.000085
A
constant written without a decimal point is represented by the compiler as an
integer number. Integer constants can be written in three different notations:
A constant starting with any digit
other than 0 is interpreted as a decimal integer (that is, the standard base-10
number system). Decimal constants can contain the digits 0 through 9 and a
leading minus or plus sign. (Without a leading minus or plus, a constant is
assumed to be positive.)
e.g. 123
-670
8965 etc.
A constant starting with the digit 0
is interpreted as an octal integer (the base-8 number system). Octal constants
can contain the digits 0 through 7 and a leading minus or plus sign.
e.g. 065 034
etc.
A constant starting with 0x or 0X is
interpreted as a hexadecimal constant (the base-16 number system). Hexadecimal
constants can contain the digits 0 through 9, the letters A through F, and a
leading minus or plus sign.
e.g. 0x9F 0X7C
0xAB etc.
Symbolic
Constants
A symbolic constant is a constant that is
represented by a name (symbol) in our program. Like a literal constant, a
symbolic constant can't change. Whenever we need the constant's value in our
program, we use its name as we would use a variable name. The actual value of
the symbolic constant needs to be entered only once, when it is first defined.
Symbolic constants have two significant
advantages over literal constants, as the following example shows. Suppose that
we're writing a program that performs a variety of geometrical calculations.
The program frequently needs the value ,, (3.14159) for its calculations.For
example, to calculate the circumference and area of a circle with a known
radius, we could write
circumference = 3.14159 *
(2 * radius);
area = 3.14159 *
(radius)*(radius);
If,
however, we define a symbolic constant with the name PI and the value 3.14, we
could write
circumference
= PI * (2 * radius);
area
= PI * (radius)*(radius);
The
resulting code is clearer. Rather than puzzling over what the value 3.14 is
for, we can see immediately that the constant PI is being used.
The
second advantage of symbolic constants becomes apparent when we need to change
a constant. Continuing with the preceding example, we might decide that for
greater accuracy our program needs to use a value of PI with more decimal
places: 3.14159 rather than 3.14. If we had used literal constants for PI, we
would have to go through our source code and change each occurrence of the
value from 3.14 to 3.14159. With a symbolic constant, we need to make a change
only in the place where the constant is defined.
C has two methods for defining a symbolic
constant: the #define directive and the const keyword. The #define directive is
one of C's preprocessor directives which is used as follows:
#define CONSTNAME literal
This creates a constant named CONSTNAME with
the value of literal. literal represents a literal constant(i.e.value for
constant). CONSTNAME follows the same rules described for variable names. By convention, the names
of symbolic constants are uppercase. This makes them easy to distinguish from
variable names, which by convention are lowercase. For the previous example,
the required #define directive would be
#define PI 3.14159
Note that #define lines don't end with a
semicolon (;). #defines can be placed anywhere in our source code, but they are
in effect only for the portions of the source code that follow the #define
directive. Most commonly, programmers group all #defines together, near the
beginning of the file and before the start of main().
How
a #define Works
The precise action of the #define
directive is to instruct the compiler as follows: "In the source code,
replace CONSTNAME with literal."
Note that #define doesn't replace instances of its target that occur as
parts of longer names, within double quotes, or as part of a program comment.
For example, in the following code, the instances of PI in the second and third
lines would not get changed:
#define PI 3.14159
/* You have defined a
constant for PI. */
#define PIPETTE 100
Defining
Constants with the const Keyword
The
second way to define a symbolic constant is with the const keyword. const is a modifier that can be applied
to any variable declaration. A variable declared to be const can't be modified during program execution-only initialized
at the time of declaration. Here are some examples:
const int
count = 100;
const float
pi = 3.14159;
const long
debt = 12000000, float tax_rate = 0.21;
const affects all
variables on the declaration line. In the last line, debt and tax_rate are
symbolic constants. If our program tries to modify a const variable, the
compiler generates an error message, as shown here:
const int count = 100;
count = 200; /* Does not compile! Cannot reassign or
alter */
/* the value of a constant.
*/
Now look at this small program that demonstrates the
use of variables and constants.
1: /* Demonstrates variables and constants */
2: #include <stdio.h>
3:
4: /* Define a constant to convert from pounds
to grams */
5: #define GRAMS_PER_POUND 454
6:
7: /* Define a constant for the start of the
next century */
8: const int NEXT _CENTURY
= 2000;
9:
10: /* Declare the needed variables */
11: long weight_in_grams, weight_in_pounds;
12 int year_of_birth, age_in_2000;
13:
14: main()
15: {
16: /*
Input data from user */
17:
18: printf("Enter your weight in
pounds: ");
19: scanf("%d",
&weight_in_pounds);
20: printf("Enter your year of birth:
");
21: scanf("%d",
&year_of_birth);
22:
23: /* Perform conversions */
24:
25: weight_in_grams = weight_in_pounds *
GRAMS_PER_POUND;
26: age_in_2000 = NEXT _CENTURY
- year_of_birth;
27:
28: /* Display results on the screen */
29:
30: printf("\nYour weight in grams =
%ld", weight_in_grams);
31: printf("\nIn 2000 you will be %d
years old\n",
age_in_2000);
32:
33: return 0;
34: }
Enter your weight in
pounds: 175
Enter your year of birth:
1960
Your weight in grams =
79450
In 2000 you will be 40
years old
ANALYSIS: This program
declares the two types of symbolic constants in lines 5 and 8. In line 5, a
constant is used to make the value 454 more understandable. Because it uses
GRAMS_PER_POUND, line 25 is easy to understand. Lines 11 and 12 declare the variables
used in the program. Notice the use of descriptive names such as
weight_in_grams. We can tell what this
variable is used for. Lines 18 and 20 the printf() print prompts on-screen. To allow the user to respond to the prompts,
lines 19 and 21 use another library function, scanf() which gets input
information. Lines 25 and 26 calculate the user's weight in grams and his or
her age in the year 2000. To finish the program, lines 30 and 31 display the
results for the user.
NOTE: DON 'T
try to assign a value to a constant after it has already been initialized.
No comments:
Post a Comment