The default storage class for all “local” variables.

{
   int mount;
   auto int month;
}

The above two variables are of the same auto storage class. ‘auto’ can only be used within functions, i.e., local variables.

It is used to define ‘local’ variables that should be stored in a register instead of RAM. This means that the variable has a maxumim size equal to the register size (usually one word) and can’t have the unary ‘&’ operator applied to it as it does not have a memory location.

{
   register int  miles;
}

The register should only be used for variables that require quick access such as counters. It should also be noted that defining ‘register’ does not mean that the variable will be stored in a register. It means that it MIGHT be stored in a register depending on hardware and implementation restrictions.

The static storage class instructs the compiler to keep a ‘local’ variable in existence during the life-time of the program instead of creating and destroying it each time it comes into and goes out of scope. Therefore, making ‘local’ variables static allows them to maintain their values between function calls.

The static modifier may also be applied to global variables. When this is done, it causes that variables’s scope to be restricted to the file in which it is declared.

In C programming (OOP?), when static is used on a global variable, it causes only one copy of that member to be shared by all the objects of its class.

#include <stdio.h>
 
/* function declaration */
void func(void);
 
static int count = 5; /* global variable */
 
main() {

   while(count--) {
      func();
   }
	
   return 0;
}

/* function definition */
void func( void ) {

   static int i = 5; /* local static variable */
   i++;

   printf("i is %d and count is %d\n", i, count);
}

When tha above is executed, it produces the following result –

i is 6 and count is 4
i is 7 and count is 3
i is 8 and count is 2
i is 9 and count is 1
i is 10 and count is 0

The extern storage class is used to give a reference of a global variable that is visible to ALL the program files. When you use ‘extern’, the variable cannot be initialized however, it points the variable name at a storage location that has been previously defined.

Just for understanding, extern is used to declare a global variable or function in another file.

First File: main.c

#include <stdio.h>
 
int count ;
extern void write_extern();
 
void main() {
   count = 5;
   write_extern();
}

Second File: support.c

#include <stdio.h>
 
extern int count;
 
void write_extern(void) {
   printf("count is %d\n", count);
}

Now compile these two files using ‘gcc main.c support.c’, it will produce the executable a.out. When this program is executed, it produces the following result –

count is 5

The general form of a function definition in C programming language is as follows −

return_type function_name( parameter list ) {
   body of the function
}

Function Declarations

A function declaration tells the compiler about a function name and how to call the function. The actual body of the function can be defined separately. E.g. –

int max(int num1, int num2);

Function declaration is required when you define a function in one source file and you call that function in another file. In such case, you should declare the function at the top of the file calling the function.