Search This Blog

Saturday, May 26, 2012

Introduction of C


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.
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.
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.
  1. char : it can store one ASCII character(i.e. one byte only )
  2. 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
  3. float : Single precision number with decimal value. Its size is generally equal to 4 bytes.
  4. 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 ?
  1. char : by  %c
  2. int : by  %d(decimal) , %i (integer) , %x(hex) , %o (octal)
  3. float : by %f
  4. 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.
  1. Variable name should begin with a alphabetic character. But  underscore character ‘_’ is also legal character as beginning character for variable name.
  2. Variable name should contain only letters ,digits and underscore characters. No other characters are allowed for name.
  3. Variable name should be unambiguous within its first eight characters since first eight characters are treated as significant characters by many compilers.
  4. Uppercase and lowercase  are significant. i.e. name, Name,NAME or nAme all are different variables.
  5. The C key word can not be a variable name.
  6. 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.
  1. 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)

ab
 c

 
                                                                                a*b/c



 3x2+2x-1                                                             3*x*x +2*x – 1

+
 
  x           c
  y

Note: There is no any operator in C for exponentiation.











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