Lesson 02: Data Types and Variables

static

static

The static modifier is used to change the lifetime or scope of the variable.

volatile

volatile

The modifier volatile tells the compiler not to optimize the variable, in which their value may be changed in ways not explicitly specified by the program. Consequently, the compiler can make no assumptions about the value of the variable. In particular, the optimizer must be careful to reload the variable every time it's used instead of holding a copy in a register.

A variable should be declared volatile whenever its value could change unexpectedly. And use volatile to avoid compiler to optimize the code away if it seems that no useful operations are contained within it. The variable should be declared volatile in the following situations:

• Memory-mapped peripheral registers
• Accessing global variables in an interrupt service routine (ISR) or signal handler.
• Sharing global variables between multiple tasks within a multi-threaded application
• Software delay loop variables in a highly optimized function
• Variables that should not be optimized out if not used

When a volatile variable is not declared as volatile, the compiler assumes that its value cannot be modified externally to the implementation. Therefore, the compiler might perform unwanted optimizations. This can manifest itself in a number of ways:

• The code might become stuck in a loop while polling hardware.
• A multi-threaded code might exhibit strange behavior.
• Optimization might result in the removal of code that implements deliberate timing delays.

void do_something(int param1);
int global_variable;

vois IRQ_Handle(void)       // Interrupt Service Routine
{
    global_variable = 1;
}

int main()
{
    global_variable = 0;
    while(1) {              // Stay in this loop
        if( global_variable )
             do_something();
    }
}

void do_something(int param1);
volatile int global_variable;

vois IRQ_Handle(void)       // Interrupt Service Routine
{
    global_variable = 1;
}

int main()
{
    global_variable = 0;
    while(1) {              // Stay in this loop
        if( global_variable )
             do_something();
    }
}

int volatile var = 0;

int task1()
{
    while (var == 0) { // do sth }
}
int task2()
{
    var++;
}

// Software Delay
void Delay()
{
    volatile int i;
    volatile int i;

    for (i = 0; i < 10000; i++)
        for (j = 0; j < 500; j++);
}

extern

extern

You can share a variable in multiple C source files by using external variables. It is declared using extern keyword. The extern simply tells the compiler that the variable is defined elsewhere and not within the same block where it is used. The extern modifier is most commonly used when there ate two or more files sharing the same global variables.

// File1.c
int GlobalVar = 0;  // Declaration and Definition of the variable

void IncGlobalVar()
{
    GlobalVar ++;
}

// main.c
#include <stdio.h>

extern int GlobalVar;       // Declaration of the variable
void IncGlobalVar();        // Declaration of the function

int main()
{
    IncGlobalVar();
    printf("GlobalVar = %d \r\n\n", GlobalVar);
    
    system("pause");    // for Windows Console Application
    return 0;
}

The extern modifier only can be used with global variables. An external variable must be defined exactly once in one of the source files of the program. To access the external variables, the external variables must be declared either outside or inside the function that wants to access.

auto

auto

auto tells the compiler that the local variable it precedes us created upon entry into a block and destroyed upon exit from a block. Since all variables defined inside a function or a block are auto by default, the auto keyword is seldom (if ever) used.

register

register

Registers are faster than memory to access, so the variables which are most frequently used in a C program can be put in registers using register keyword. The register modifier could be used only on local variables, and it caused the compiler to attempt to keep that variable in a register of the CPU instead of placing it in memory (RAM). 

• If you use & operator with a register variable, then the compiler may give an error or warning (depending upon the compiler you are using), because when we say a variable is a register, it may be stored in a register instead of memory and accessing the address of a register is invalid.

  #include <stdio.h>
  int main()
  {
      register int n = 20;
      int *ptr;
      ptr = &n;
      printf("address of n : %p \n", ptr);
      return 0;
  }

  When you compile the code, the compiler will show an error message as below:

  line 6: ptr = &n; [Error] address of register variable 'n' requested

• The register modifier can be used with pointer variables. Obviously, a register can have an address of a memory location.

  #include <stdio.h>
  int main()
  {
      int n = 20;
      register int *ptr;
      ptr = &n;
      printf("address of n : %p \n", ptr);
      return 0;
  }

  Build the code and execute it:
  

  address of n : 0x7ffc1320465c

• The register modifier can not be used with a static modifier.

  #include <stdio.h>
  int main()
  {
      register static int n = 20;
      n++;
      printf("address of n : %d \n", n);
      return 0;
  }

  When you compile the code, the compiler will show an error message as below:

  line 4: register static int n = 20; [Error] multiple storage classes in declaration specifiers

• The register can only be used within a block (local), it can not be used in the global scope (outside the function).

  #include <stdio.h>
  
  register int n = 20;
  int main()
  {
      n++;
      printf("address of n : %d \n", n);
      return 0;
  }

  When you compile the code, the compiler will show an error message as below:

  line 3: register int n = 20; [Error] Storage class 'register' is not allowed here

• The register is only a request. The compiler is free to ignore it.