---

---

---

What are storage classes?

Storage class determines the scope, lifetime, storage location and initial value of a variable. There are four storage classes in C such as Automatic, Static, Register, External

What are storage class specifiers?

A variable of each storage class can be declared by writing a storage specifier in front of the variable. At most one storage specifier can be written in front of a variable. The storage specifiers for each storage class is as follows:

• auto storage class specifiers are used before automatic storage class variables declarations. For example auto int i; will declare a variable of int datatype and automatic storage class.
• static storage class specifiers are used before static storage class variables declarations. For example static double i; will declare a variable of double datatype and static storage class.
• register storage class specifiers are used before register storage class variables declarations. For example register int i; will declare a variable of int datatype and register storage class.
• extern storage class specifiers are used before external storage class variables declarations. For example extern int i; will declare a variable of int datatype and external storage class.

Automatic storage class

Variables with automatic storage class are defined inside a function and are also called local variables. Auto/local variables have the following rules.

• The scope of a local variable is limited to the function or block in which it is defined.
• You must initialize a local variable. Uninitialized local variables can contain random values and can lead to undefined behavior.
• By default a variable declared within a function will be considered as auto/local.

A variable declared outside all the functions is called a global variable. Global variables have the following rules.

• A global variable is generally declared at the top of the program
• The scope of a global variable is all the functions in the file in which it is defined.
• You must initialize a global variable. Uninitialized global variables are automatically initilized to 0 by the compiler.
• A global variable can be re-initialized inside a function.

To demonstrate the auto/local, global variable features, let's write a program as shown below.

#include <stdio.h>
int autoFunc(int );
int glbvar = 10;
int glbvar1;
int main() {
  printf("glbvar:%d,glbvar1:%d\n", glbvar, glbvar1);
  int autovar = 20;
  int res;
  printf("res is:%d\n", res);
  res = autoFunc(autovar);
  printf("res is:%d\n", res);
  return 0;
}
int autoFunc(int autovar)
{
  printf("0th block:%d\n", autovar);
  {
    auto int autovar = 30;
    printf("Ist block:%d\n", autovar);
    {
      auto int autovar = 40;
      printf("2nd block:%d\n", autovar);
    }
  }
  glbvar += autovar;
  return glbvar;
}

    Above program will produce the following output.

$ gcc Listing1.c
$ ./a.out
glbvar:10,glbvar1:0
res is:0
0th block:20
Ist block:30
2nd block:40
res is:30
$

Let's analyze the above program. The following are the points to observe from the above program.

• Variable autovar is declared once inside the main function, two times inside the autoFunc function. We have printed all instances and they are having different values. So autovar has function or block scope.
• variable glbvar is a global variable defined outside all the function and could be accessed inside both main and autoFunc function.
• glbvar1 is a global variable but it is uninitilized. But compiler automatically initialized it to 0. So when we printed it inside main function, it printed as 0.
• res is a variable decalared within main function without having any storage class specifier. So it is by default considered as an auto or local variable.

Static storage class

A static variable remains in memory while the program is running in contrast to a normal or auto variable which is destroyed when a function call where the variable was declared is over. Following are the features of a static variable:

• Static variables are allocated memory in data segment, not stack segment.
• Static variables are unavailable to functions defined in other files, even if these functions attempt to use the extern storage class keyword to access them.
• Static functions are unavailable to other files, even if these files attempt to use the extern storage class keyword to access them.
• Like global variables static variables are initialized as 0 if not initialized explicitly.
• Life time of a static variable is equal to the life time of the c program file where it is declared.

Let's write a program to demonstrate the use of static variables

#include <stdio.h>
static int p;
int f(void) {
  static int x = 0;
  x++;
  return x;
}
int y(void) {
  int x = 0;
  x++;
  return x;
}
int main() 
{
  int j;
  printf("Static variable x:%d\n", p);
  for (j = 0; j < 5; j++) {
    printf("Value of f(): %d\n", f());
  }
  for (j = 0; j < 5; j++) {
    printf("Value of y(): %d\n", y());
  }
  return 0;
}

   Above program will produce the following output.

$ gcc prog1.c
$ ./a.out
Static variable x:0
Value of f(): 1
Value of f(): 2
Value of f(): 3
Value of f(): 4
Value of f(): 5
Value of y(): 1
Value of y(): 1
Value of y(): 1
Value of y(): 1
Value of y(): 1
pi@raspberrypi:~/try $

Let's analyze the above program. Here we have two functions f and y. Function f is having a static int variable x where as function y is having a non-static variable x. You can see in the output that though we called both the functions 5 times, output of function f keeps incrementing on successive calls where as the output of function y remains always at 1. This is because the static variable x declared inside function f is not reinitilized to 0 where as in function y variable x is reinitialized to 0 on successive calls.

Also when we printed an uninitialized static variable p, inside main function, compiler automatically initilized to 0. So when we printed it inside main function, it prints as 0.

Let's write another program and compile along with the above program as shown below.

#include <stdio.h>
extern int p;
int function()
{
  printf("printing static var p:%d\n", p);
}

   When prog1.c and prog2.c are compiled together, the complier will give the following error.

pi@raspberrypi:~/try $ gcc prog1.c prog2.c
/tmp/cciYesJG.o: In function `function':
prog2.c:(.text+0x28): undefined reference to `p'
collect2: error: ld returned 1 exit status
pi@raspberrypi:~/try $

If you see the above program output, it shows that the variable p which is declared as static in prog1.c could not be accessed in the prog2.c even though extern keyword is used to access it from prog1.c file. So it confirms that static variable can be accessed only in the file where it is declared.

Now remobve the static storage specifier from variable p in prog1.c. You should be able to compile prog1.c and prog2.c together. Compiler will not give any error

Register storage class

Register variables indicate the compiler to store the variable in CPU register instead of memory. The register storage class specifier is typically specified for frequently used variables, such as a loop control variable, to enhance performance by reducing access time. But compiler is not required to commit this request. Because of the limited size and number of registers available on most systems, only few variables can actually be put in CPU registers. If the compiler does not allocate a CPU register for a register variable, the variable is treated as having the storage class specifier auto.

    The following are the rules of use for register variables:

• A register does not have an address. Therefore, you cannot apply the address operator (&) to a register variable.
• Register variables have automatic storage duration. Once exited the function where declared register variable is unavailable for use.

    The following program shows the errors, declarations for register variables.

#include <stdio.h>
register int r; /* Wrong declaration */
int main() {
  register int var; 
  int *b = &var; /* Not allowed */
  return 0;
}

Extern storage class

An external variable is a variable declared as global in another file and is extracted from that file for using in the current file.

    The following are the rules of use for extern variables:

• Scope of external variable is entire current file.
• An external variable can only be made available inside any function as required. This will not be available to all functions in the file.
• Make a variable external only when all or most of the program's functions need access to the variable. It is good programming practice to declare any external variable inside the function with an extern before its data type to say that this function uses an external variable with such and such type, name and declared elsewhere.
• Declaring the external variable many times not a problem but it can be initialized only in the file where it is defined as global.
• Any global variable can be written as extern to indicate that it is coming from outside the function though it is not necessary as global variables are automatically available inside all functions in the program.

    Let's write a small program to demonstrate the use of external storage class.

/* File ext1.c */
#include <stdio.h>
void call_fun();
int val2 = 90;
int main()
{
  call_fun();
  return 0;
}

/* File ext2.c */
#include <stdio.h>
extern int val2;
void call_fun()
{
  printf("The value of val2 is %d\n",val2);
}

   Above program will produce the following output.

$ gcc ext1.c ext2.c
$ ./a.out
The value of val2 is 90
$

Exercises, Solutions

High	Write a C Program macro to check if a character is alphabetic or not.
Medium	Write a C program to check whether year is leap year or not using conditional/ternary operator.
Low	Write a C program to return the bigger number between 2 integers using conditional/ternary operator.
High	Write a c program function to calculate the sum of all digits of an integer number.
Low	Write a c program function to accept an integer number and return lsb first digit of the number.
Medium	Write a c program function to accept an integer number and return msb last digit of the number.
High	Write a C program function to convert Decimal to Binary number system.
Medium	Write a program to demonstrate the use of static keyword in C programming.
Medium	Write a program to demonstrate the use of auto/local and global variables in C programming
Medium	Write a program with two files ext1.c and ext2.c to demonstrate the use of extern keyword

---

Want to contribute a new article? Write and upload your article information here.