Tomislav Kraljic's Blog

Storage Classes in C

Tomislav Kraljic's photo
Tomislav Kraljic
·

4 min read

In this article, I will go over the four storage classes in C: auto, extern, static and register. I will explain how to use them and the specifics of each storage class.

What is a Storage Class?

A storage class is a way to describe the features of a variable or function.

This includes:

  • Scope, visibility, and life-time.
  • Help us trace the existence of a particular variable during the run time of a program.

What Storage Classes Does C Provide?

C provides 4 storage classes:

  • auto
  • extern
  • static
  • extern

These can be divided into 2 storage duration's:

  • automatic storage duration
  • static storage duration

Auto Storage Class

  • The keyword auto is used to declare variables of automatic storage duration.
  • It means it is a local variable.
  • Every local variable created, is implicitly 'auto'
  • Created when the block in which they are defined is entered.
  • Destroyed when the block is exited.

Why use Auto?

  • Automatic storage is a way of conserving memory. We do not want every variable to be global.
  • We only want to use these variables when absolutely necessary.

Example 1

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

int main(int argc, char * argv[]){
    auto int age = 23; // same as int age = 23;
    printf("%d\n", age);

    return EXIT_SUCCESS;
}

Extern Storage Class

  • The extern storage class simply tells us that a variable is defined somewhere else.
  • We are telling the compiler "Hey, don't freak out. The variable is defined somewhere else and I am gonna use it.
  • The main purpose of using extern variables is that they can be accessed between different source files in a large program.
  • Functions contained in separate files can communicate through extern variables.
  • Functions are implicitly 'extern' as well.

Example 1

main.c 

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

extern int x;
extern int b;
extern void print_x();
extern void print_b();

int main(int argc, char * argv[]){
    print_x(); //32
    print_b(); //8

    x = 50;
    b = 99;

    print_x(); //50
    print_b(); //90

    return EXIT_SUCCESS;
}

extern.h

int x;
int b;
void print_x();
void print_b();

extern.c


int x = 32;
int b = 8;

void print_x() { printf("%d\n", x); };

void print_x() { printf("%d\n", b); };

Static Storage Class

  • The static storage class can be used on local and global variables and functions.
  • When applied to local variables, it instructs the compiler to keep the variable alive during the lifetime of the program (just like a global variable).
  • When applied to global variables, it instructs the global variable to only be able to be used/accessed in that file that it was declared in.
  • When applied to functions, it instructs the function to only be able to be called from the same file where it appeared.

Example 1

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

void print_and_increment();

void print_and_increment_with_static();

int main(int argc, char * argv[]) {
    print_and_increment(); //1
    print_and_increment(); //1

    print_and_increment_with_static(); //1
    print_and_increment_with_static(); //2


}

void print_and_increment(){
    int value_one = 0;
    ++value_one;
    printf("%d\n", value_one);
}

void print_and_increment_with_static(){
   int value_two = 0;
   ++value_two;
   printf("%d\n", value_two);
}
  • Here, we are seeing two different results.
  • The variable value_one only exists within the block of the function print_and_increment. When it leaves the scope, the variable is destroyed. No matter how many times we call it, we will get the same result.
  • The variable value_two is static. Therefore, it exists throughout the entire program. It is not local. Every time we call it, the value changes.

NOTE: Static variables should not be declared inside a struct. The C compiler requires the entire struct element to be placed together.

Register Storage Class

  • A processor register is a local storage space within the CPU that holds instructions, storage addresses, or any kind of data.
  • The register storage class is used to define local variables that should be stored in the register instead of the RAM
  • Makes the use of register variables faster than variables stored in RAM.
  • The keyword 'register' suggests to the compiler to put the variable inside the register.
  • Sometimes the compiler will listen, other times it wont. It is largely dependent on hardware and implementation restrictions.
  • Generally, the compiler will do it by itself regardless if you use this keyword or not.
  • You can not get the address of a register variable.
  • Register variables have the same life-span as an auto variable(local variable).
  • Therefore, register variables can not be declared globally, only locally.

Example 1


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

int main(int argc, char * argv[]) }
    register int age = 23;

    printf("Your age is %d\n", age);
}
C