Every variable has a type associated with it which decides the values that can be assigned to it and the operations that can be performed on it. In addition, we can specify a storage class for a variable which decides the following:

1. The type of storage to be used (either memory or CPU registers)

2. The scope or the part of the program from which that variable can be accessed

3. The lifetime, i. e., how long the variable will continue to live or exist

4. The default initial value, i. e., the value assigned to the variable if it is not explicitly initialized.

The C language provides four storage classes, namely, automatic, register, static and external. The keywords for these storage classes are auto, register, static and extern, respectively. The characteristics of the storage classes are summarized in Table

A storage class is specified for a variable using the general format shown below.

storage_class data_type varl, var2, …;

The order of the storage class and data type can be altered and the int data type can be omitted. Consider the example given below.

auto int a, b;

register int i, j;

static float p, q;

extern char x, y;

This example declares a and b as automatic variables of type int, i and j as register variables of type int, p and q as static variables of type float and x and y as external variables of type char.

Note that if we do not specify the storage class for a variable, the defaults are applicable. Thus, a variable defined within a block without any storage class is an automatic variable and a variable defined outside any function without any storage class is an external variable. We can use any storage class while defining a variable within a block. However, for the variables defined outside any function, the storage class can be static or be omitted. The compiler will give an error if we use auto or register class for such variables defined outside any function.

Automatic Storage Class

As mentioned earlier, if we do not specify a storage class while defining a variable inside a block, the automatic storage class is assumed. However, we can use the auto keyword to explicitly specify the automatic storage class for such variables.

As we know, automatic variables are not initialized to any specific value by default. Thus, if we do not initialize an automatic variable when it is defined, it will have a garbage value, i. e., a random, unpredictable value which is likely to change each time the program is executed. Automatic variables are stored in memory. Their scope is local to the block in which they are defined, from the point of definition to the end of that block. Thus, once a variable is defined, it can be used in any subsequent part of that block including the blocks nested within it. However, it cannot be used outside that block.

An automatic variable is created every time control enters the block in which it is defined and it lives until control remains in that block. It is destroyed when control leaves that block. Note that irrespective of the storage class used, the variable names must be unique within a block. Thus, we cannot redefine a variable within the same block with a different type and/or storage class. However, it is possible to reuse that variable name for other variables of any data type and/or storage class defined within other blocks including the contained blocks. When we access such a variable from within a block, the local variables (i. e., the variables defined in that block) are given preference. However, if the accessed variable is not defined in that block, variable access refers to the definition in the nearest outer block in which this block is contained. To understand this concept clearly, study the example given below.

int main()

{

    int x = 1;

    clrscr();

    printf(“%d “, x);               /* prints 1 */

     {

         printf(“%d “, x);          /* prints 1 */

           {

                int x = 2;            /* variable name x reused */        

                printf(“%d “, x);  /* prints 2 */

           }

           printf(“%d “, x);       /* prints 1 */

      }

       printf(“%d “, x);          /* prints 1 */

       return 0;

}

The comments after the printf statements specify the values printed by these statements. The code is easy to understand and its output is given below.

1 1 2 1 1

Now consider another example given below

void show_result(int marks)

{

       char result[10];

       if (marks >= 40)

       {

          char result[] = “Pass”;

       }

       else {

                    char result[] = “Fail”;

                    printf(“Result: %s”, result);

             }

             printf(“Result: %s”, result);

}

In this function, the variable result is first declared as a char array. Then this variable is reused to define and initialize two char arrays (with values “Pass” and “Fail”)within the if block and else block of an if-else statement. Depending on the outcome of the condition in the if statement, one of these arrays will be created. However, it will be destroyed as soon as control leaves that block. Thus, the printf statement will print the value of the result array defined in the beginning of this function. As this is an automatic array, its elements are not initialized with any specific value and thus have garbage values. When this function was called in Code::Blocks (with value of marks as 50), the output was displayed as shown below.

Register Storage Class

CPU registers are much faster than memory. Thus, if we store frequently used variables in CPU registers, the program will run faster. We can request the C compiler to store one or more variables in CPU registers by specifying the register storage class when these variables are defined. However, note that a CPU has a limited number of registers. Hence, it may not be possible for the compiler to honor all requests for allocation of CPU registers. If the compiler is not in a position to allocate a CPU register for a requested variable, that variable is stored in memory and is treated as an automatic variable.

Apart from the storage location, register variables are similar to automatic variables. Thus, they have scope local to the block in which they are defined, they are destroyed when control leaves that block and the compiler does not initialize them with any specific values (they have garbage values), if we do not explicitly initialize them.

The register storage class should be used for frequently used variables, e. g., control variables in loops. Consider the example given below.

int sum(int n)

{

    register int i, sum;

    sum = 0;

    for(i = 1; i <= n; i++)

        sum += i·;

        return sum;

}

This code segment defines variables i as well as sum as register variables in an attempt to speed up program execution.

Note that whether a variable will be stored in a CPU register or not depends, besides the availability of a CPU register, on the possibility of accommodating that variable in the CPU register. As modem CPUs have 64 bit registers, it is possible to allocate CPU registers for variables of basic data types (char, int, float and double) as well as pointer variables. Remember that we should not request a register storage class for bigger data objects such as arrays or large structures. However, if we do so, the compiler will ignore the request and treat those variables as automatic variables, as mentioned earlier:

Static Storage Class

Like automatic variables, static variables are also stored in memory and have local scope. However, they differ in two respects, lifetime and default initial values.

Static variables come into existence when the execution of the block in which they are defined begins for the first time and they are not destroyed when control leaves that block. Thus, they live till the end of program execution. Note that the values assigned to these variables are available the next time that block is executed. Thus, static variables can be used to remember data values in a function across function calls.

If we do not explicitly initialize a static variable when it is defined, the compiler initializes it with the default initial value, which is zero for arithmetic types and NULL for pointers. This initialization is done only once, the first time control reaches that block. Initialization is not done in subsequent executions of that block.

To further understand the concept of static variables, consider the program given below.

#include <stdio.h>

void func(void)

int main ()

{

   func () ;

   func ();

   func ();

   return 0;

}

void func (void)

{

    static int x = 100;

    printf(“%d “, x++);

}

In this example, the function func is called three times from the main function. This function defines a static variable x with initial value 100. This value is printed and then incremented in a printf statement.

The first time the function func is called, variable x is initialized to 100. The printf statement prints this value and increments it to l 01. When control leaves function func,x isnot destroyed as it is a static variable and its value is preserved for use in subsequent calls to the function.

When the function func is called a second time, x is not initialized again. Thus, the printf statement prints the value of x (101) and increments it to 102. Finally, the third call to function func prints the value 102 (and increments it to 103). The output of the program is given below.

101 102 103

What would program output be if we declare variable x in function func as shown below?

static int x;

External Storage Class

External variables, as the name indicates, are defined outside any function. These variables are similar to static variables in terms of storage location, lifetime and default initial values.

External variables are stored in memory. They come to existence when program execution begins and live till the end of program execution. Also, the compiler initializes them with default initial values (0 for arithmetic types and NULL for pointers), if they are not explicitly initialized.

However, unlike all other variables (automatic, register and static which have local scope), external variables have global scope. Hence, these variables are also called global variables. They can be accessed in all parts of the program including all the functions in the same program file as well as other program files in a multi-file C program. Thus, they provide an easy mechanism to share data between different functions without explicitly passing them around. This is particularly useful if a large number of variables are shared by multiple functions. It is a convention to define the external variables at the beginning of a program file, as illustrated below.

#include <stdio.h>

int x = 10;

int y;

void func(void);

int main()

{

    printf(“%d %d “, x, y);

    x = 100, y = 200;

    func ();

    printf(“%d %d “, x, y);

    return 0;

}

void func(void)

{

             printf (“%d %d “, x, y);      /* global x and y */

            {

                 int x = 5, y = 2;

                 printf(“%d %d “, x , y); /*local x and y */

            }

                 x = 50, y = 60;

}

In this program, the variables x and y are external variables initialized to 10 and 0 (default value), respectively. These variables are global and are accessible in both the functions, main and func. The main function first prints their values and assigns new values to them (100 and 200). The func function is then called which first prints these values. A block in the func function reuses these variable names to define local variables x and y with values 5 and 2, respectively, and prints them. As local variables get preference over global variables, the values are printed as 5 and 2. The func function then assigns new values (50 and 60) to variables x and y (global variables) outside the block. Finally, control returns to the main function where the values of x and y (global variables) are printed again as 50 and 60. The program output is given below.

10 0 100 200 5 2 50 60

You have probably noticed that the extern keyword was not used in the previous program.  This keyword declares that a variable is external, i. e., its definition is provided in some other part of the program. By default, an external variable is accessible from the point of its definition till the end of that file. However, if we wish to access an external variable in a file before it is declared, we need to use the extern declaration, as illustrated below.

#include <stdio.h>

void func(void);

int main()

{

      extern int x;             /* declaration */

      printf(“%d “, x);

      x = 20;

      func ();

      printf(“%d “, x);

      return 0;

}

      int x = 10;      /* definition */

      void func(void)

      {

               printf(“%d “, x);

               x = 30;

       }

In this example, variable x is defined as an external variable with value 10 after the main function. Thus, it is not accessible in the main function and an extern declaration is required to enable this. However, x is accessible from function func as it is defined before that function. Thus, explicit declaration of variable x is not required in function func. When this program is executed, the external variable x is first initialized to 10. The main function prints its value and assigns a new value (20) to it. Then it calls function func where this value of x is printed; new value (30) is then assigned. Control then returns to the main function where this value of x is printed again. Thus, the output of the program is

10 20 30

Note that the extern declaration of a variable should match with its definition with regard to data type, type modifier and storage class; otherwise, the compiler will report an error. The extern declaration does not create variable and it can be specified any number of times, even within the same scope.

Finally note that the C language allows a program to be split into multiple program files (. c files) and header files (. h files). To access an external variable defined in another file, we need to declare that variable using an extern declaration in files where that variable is to be accessed. Consider the program given below.

main. c file:                                                      func. c file:

#include <stdio.h>                                           #include <stdio.h>

                                                                             extern int x;

int x = 10;                                                         void funcl (void)

int y = 20;                                                       {

                                                                               printf(“%d “, x};

int main ()                                                              x = 100;

{                                                                         }

   funcl();                                                           void func2 (void)

   func2 ();                                                         {

   printf(“%d %d ” ,x,y);                                          extern int x, y;

   return 0;                                                                  printf(“%d %d “,x,y);                               

}                                                                                     x = 200, y = 300;

                                                                             }

The main. c file defines two external variables, x and y, with initial values 10 and 20, respectively. The main function in this file calls two functions, funcl and func2, which are defined in another file, func. c and then prints the values of x and y.

The func. c file declares x as an external variable at the beginning. Thus, x in this file refers to variable x defined in the main. c file. The function func 1 prints the value of x (10) and assigns it a new value (100). The function func2 declares x and y as external variables. Thus, these variables refer to variables x and y defined in the main. c file. The function func2 then prints the values of x (100) and y (20) and then assigns them new values (200 and 300, respectively). These modified values are printed by the printf statement in the main function. The program output is given below.

10 100 20 200 300

Note that variable x is declared twice in the func. c file. An external variable can be declared any number of times. However, it can be defined only once.

Sometimes we may want that a function should not modify the value of a parameter passed to it, either directly within that function or indirectly in some other function called form it. This can be achieved using const parameters. Consider, for example, the function given below to calculate the sum of the first n integer numbers. [Read more…] about const Parameters in C

We know that the C language uses the call by value mechanism to pass parameters and that a function parameter is a copy of the argument specified in the function call.

Thus, a function parameter can be modified without affecting the corresponding argument in the calling function. This fact can often be used effectively to save some memory. Consider function fact given below to determine the factorial of an integer number.

#include <stdio.h>

#include <conio.h>

void main ()

{

           int a;

           long f,fact();

           clrscr();

           printf (“\n Enter a Number : “);

           scanf (“%d”,&a);

           f=fact(a);

           printf (“\n The Factorial of %d is : %ld”,a,f);

           getch();

}

       long int fact(int n)

{

     int i;

     int fact = 1;

     for (i = n; i > 1; i–)

     fact *= i;

     return fact;

}

The Tower of Hanoi problem consists of three poles, left, middle, and right. One of the poles (say, the left) contains n disks of different sizes placed on each other, as shown in Fig. The objective of the problem is to transfer all the disks from the left pole to right pole such that only one disk can be moved at a time (to any pole) and a larger  disk cannot be placed on top of a smaller disk. [Read more…] about C Program Tower of Hanoi

Before a function is called in a program, the system should know where to look for the function definition. In case of functions belonging to C standard library we include the relevant header files in which the function is defined. This is done above the main() function. In case of user-defined functions, a function may be defined above or below the main function, because, a function cannot be defined inside another function. If a function is defined above the main function, there is no need of a separate declaration of function. However, if the function is defined below the main function, it is a good programming practice to declare the functions being used above the main. A function declaration may be done by the function header or by its prototype.

If a function call precedes its definition in a program, we should declare the function before the call. A function declaration takes the following general form:

ret_ type func_ name ( param_type_list ) ;

For example, the prototypes of the three functions Area_rect, Area_ circle and Display may be written as.

  int Area_rect(int, int);

  double Area_circle( float);

  void Display ();

where func _name is the name of the function, ret_type is the type of the return value and param_type_list is a comma-separated list of function parameter types. Note that this format is similar to the function definition except that the parameter declaration list is replaced by the parameter type list and the function body is replaced by a semicolon. Also note that formal parameter names may be included in a function declaration and are treated as comments. They may be replaced with other names as well. Thus, to include a function declaration in a program, we can simply copy the first line of the function definition (and insert a semicolon after it).

Function declarations are usually written at the beginning of a program, before the main function. Such declarations outside any function are called global declarations. A function may also be declared within the function from which it is called. The problem with such a local declaration is that its scope is restricted to the function in which it is declared, i. e., it is available only within that function. Thus, if this locally declared function is also called from some other function, we must provide its declaration in that function as well.

Although a program can contain only one definition of a function, there is no restriction on the number of declarations. A function may be declared more than once within the same scope. However, note that each declaration must be consistent with its definition with regard to the number of parameters, their types and the return type.

A function declaration provides valuable information (function name, number and type of parameters and return type) to the compiler. The compiler uses this information to ensure that the function call is consistent with its definition. Thus, the compiler can check that the number of arguments in a function call and the types of arguments are as per the requirements of the function and that the function call is consistent with respect to the type of the value returned by the function. The compiler can report errors or warnings when a function call is not consistent with its definition. Note that if a function definition precedes its calls, the compiler obtains the necessary information from the function definition itself thereby eliminating the need for a function declaration. However, this is not good programming practice.

If the type of an argument in a function call is different from the type of the corresponding parameter in function definition, automatic conversion is applied if possible, to convert the argument to the type of the parameter. If automatic conversion is not possible, the compiler will report an error. Also note that if a function declaration or definition is not available to a compiler before the function call is encountered, the compiler can neither perform such automatic conversions nor it can report any errors if such conversions are not possible. The compiler may, however, give a warning that a function call is encountered without a function prototype. The compiler assumes that this function returns a value of type int. Thus, if the function actually returns a different type of value, the compiler can report an error or warning.

Illustrates the declaration of prototypes

#include<stdio.h> 
 float Volume(float,float,float); //function prototype 
 float Surface_area (float,float,float); //function prototype 
 void main() 
 { 
    float x,y,z, V, S ; 
    clrscr(); 
    printf("Write three dimensions of a cubical object: "); 
    scanf ("%f%f%f",&x, &y, &z); 
    V = Volume(x,y,z); 
    S = Surface_area(x,y,z); 
    printf("Volume = %f,\t Surface area= %f\n", V, S); 
 } 
   float Volume ( float a,float b,float c) /*function definition*/ 
    {return a*b*c;} 
   float Surface_area( float a, float b, float c) //Definition 
 { 
    return 2*( a*b +b*c+c*a); 
 } 
 

The expected output of the above program is written as follows:

It accepts three parameters  x,y, and z, each of type double and returns a value of type double. [Read more…] about C Program function to return the maximum of three numbers

The return statement is used to terminate the execution of a function and transfer program control back to the calling function. In addition, it can specify a value to be returned by the function. A function may contain one or more return statements. The general format of the return statement is given below. [Read more…] about return Statement in C Language

We may often require a horizontal line of a dash, underline or some other character to be printed, particularly when printing results in a tabular format. Consider a situation in which we require a line containing a fixed number of a specific character (e.g., 65 dash characters) to be printed several times.

The function print_65_dash_line does not have any parameter and it does not return any value. The body of the function first declares index variable i. Then it prints a line containing 65 dashes followed by a newline character. Although we could have used a single printf statement to print the desired line of dashes, the for loop allows us to quickly change the line length. However, if we require lines of different lengths to be printed, it is better to pass the line length as a parameter to this function.

We can define a function to print such a line, as shown below:

#include <stdio.h>

void main ()

{

      char i;

      clrscr();

      printf(“Print a Line of a given character:\n”);

      i=print_65_dash_line();

      printf(“%c”,i);

      getch();

}

print_65_dash_line()

{

      int i;

      for (i=0; i < 65; i++)

           putchar ( ‘-‘ ) ;

               putchar (‘\n’) ;

               return 0;

} 

C allows programmers to define their own functions. Such functions are called user defined functions. In fact, the main function that must be present in every C program is a user-defined function. A programmer may define additional functions in the following situations:

1. The required functionality is not available as a library function either in the standard C library or in the additional libraries supplied with the C compiler.

2. Some functionality or code is repeated in a program with little or no modification.

3. An existing function is quite large. It is a good idea to divide such functions, if possible, into smaller ones.

Function Definition

The general format to define a function is as follows:

ret_type func_ name ( param _list )

{

    declarations

    executable_statements

}

where funv_ name is the name of the function being defined, ret_type is the type of value returned by the function (also called function type) and param_list is a comma-separated list of function parameters. For each parameter, we must specify the type of the parameter followed by its name. Thus, the param _list takes the following form:

type1 param1, type2 param2, … , type_n param_n

where type I, type2, … are the types of parameters paraml, param2, … , respectively. Note that the rules for naming these parameters (as well as the function name) are the same as those for a variable name and that the type has to be specified separately for each parameter, even if consecutive formal parameters in param _list are of the same type.

A function may not have any parameters. This is indicated by using the keyword void in place of param _list in the function definition. However, void may also be omitted in such cases.

ret_type is the type of the value returned by a function. A function can return only one value or none at all. If a function does not return a value, it is indicated by writing the keyword void in place of ret_type. Also note that ret_type may be omitted, in which case, the function is assumed to return a value of type int.

The body of a function consists of declarations followed by executable statements enclosed within braces ‘{‘ and ‘}’. The entities declared within the function body, which are usually variables, are local to the function being defined, i. e., they are accessible only within the function body and not outside it. We can declare a local variable (or some other entity) with the same name as that of a function. The formal parameters of a function are treated as local variables declared in the beginning of the function body.

The executable statements in the definition of a function can be one or more valid C statements. When a function is called, these statements are executed until a return statement is encountered or all the executable statements are executed.

Recall that a function call takes the form [Read more…] about Advantages of Functions in C