Type Qualifiers

const

Means the variable will not be changed by the program.

 const int z = 10;

Volatile

Volatile means that the variable will change its value so tells the compiler to suppress various kinds of optimizations e.g: caching.

Only three types if variables should use volatile:

• Memory-mapped peripheral registers.

• Global variables modified by an interrupt service routine.

• Global variables accessed by multiple tasks within a multi-threaded application.

volatile int z; 
volatile int *z;

Storage classes

Storage classes are used to describe the features of a variable / function.

Include the scope, visibility and life-time.

It helps up to trace the existence of a particular variable during the runtime of a program.

The lifetime of a variable is the time period during which variable exist in the memory.

The scope is where the variable can be referenced in a program.

A variables visibility or linkage determines for a multiple-source-file program whether the identifier is known only in the current source or in any source file with proper declarations.

C provides 4 storage classes:

1. auto.

2. register.

3. extern.

4. static.

The 4 classes can be split into 2 storage duration:

1. Automatic storage duration.

2. Static storage duration.

Auto storage class

Created when the block in which they are defined is entered, exits while the block is active, destroyed when the block is exited.

All local variables have auto storage duration by default.

Its better not to use auto as a storage-class specifier in c/c++.

 auto int var;

External variables

Functions contained in separate files can communicate through external variables, an extension to the concept of global variable.

A global var can be accessed and changed by other modules (files).

In the module that wants to access the external variable the data type is preceded with the key word extern in the declaration, tells the compiler that a globally defined variable from another file is to be accessed.

Example:

We have a var called moveNumber to access it in other functions we can define it as a global var outside any function:

 int moveNumber = 0;

To access this var from another file use:

 extern int moveNumber;

Static variables

We might want to define a var that is global but not external.

To do this we use a static variable definition.

If the below declaration is made outside any function it makes the value of the variable accessible from any subsequence pointed in the file in which the definition appears and not functions contained in other files.

 static int moveNumber = 0;

Register

We can store variables of any kind in CPU registers as well which is much faster than RAM.

This should be used only or variables that require quick access.

It is the compilers choice to put it in a register or not.

It might be stored in a register depending on hardware and implementation restrictions.

The max variable size is equal to the register size.

The variable life-time is within the block.

We cant obtain the address of a register variable using a pointer, there is no memory address

 register int x;