Kinds of variables in C

Kinds of variables in C

Facts about storing information:

Programming languages provide variables to store information
Some information is used only within one function
Some information is used by multiple functions

Recall that Java has 4 different kinds of variables:

Class variables (long term information storage)
Instance variables (long term information storage)
Local variables (short term information storage)
Parameter variables (short term information storage)

C has five (5) kinds of variables - divided into 2 categories:

"Long term" variables: (a.k.a.: compile-time (allocated) variables)

Global variables --- accessible everywhere
Static global variables --- accessible within the same C program file
Static local variables --- accessible within the same C function

Common property:

The memory space used for these kinds of variables are allocated (reserved) using language constructs that is similar to ds (define storage) in M68000

Short term variables: (a.k.a.: run-time variables)

Local variables
Parameter variables

Common property:

The memory space used for these kinds of variables are allocated (reserved) during the execution (running) of the program
They are created on the system stack (just like what you learned in assembler programming !!!)

How to define the different kinds of variables

Just like Java, the location (place) of the variable definition in the (C) program determines the kind of variable that will be defined:

Parameter variables are defined inside the braces ( ... ) of the function header

Example:

int main( int argc, char *argv[] ) { ^^^^^^^^^^^^^^^^^^^^^^^^ parameter variables ... ... }

(Just like Java)

Local variables are defined inside the body of a function (i.e., between the braces { ... } of the function body)

Example:

int main( int argc, char *argv[] ) { int a; double b; ^^^^^^^^^^^^ local variables ... if ( .... ) { int x; ^^^^^^^^^^ local variable } ... }

(Just like Java)

Global variables are defined outside a function without using the keyword static:

int a; // Global variable int b; // Global variable int main ( int argc, char *argv[] ) { ... ... } double c; // Global variable void f( .... ) { ... ... }

(The 2 different kinds of global variables are distinguished by the static keyword.)

Static global variables are defined outside a function using the keyword static:

static int a; // Static global variable static int b; // Static global variable int main ( int argc, char *argv[] ) { ... ... } double c; // Global variable void f( .... ) { ... ... }

(The 2 different kinds of global variables are distinguished by the static keyword.)

Static (local) variables are defined inside a function using the keyword static:

int main ( int argc, char *argv[] ) { static double d; // Static variable double f; // Normal local variable ! ... ... } double c; // Global variable void f( .... ) { ... ... }

Summary:

Experiment

Compile this program with all 5 kinds of variables:

int a; // global static int b; // static global int func( int e ) // param { int d; // local static int c; // static local a = 1; b = 2; c = 3; d = 4; e = 5; }

Compile with: gcc -S kinds-vars.c and take a look at the output kinds-vars.s:

.file "kinds-vars.c" .comm a,4,4 // allocate global a .local b // make name "b" localized ! .comm b,4,4 // allocate 4 bytes for variable b .text // Start of instructions .globl func .type func, @function func: .LFB0: .cfi_startproc pushq %rbp .cfi_def_cfa_offset 16 movq %rsp, %rbp .cfi_offset 6, -16 .cfi_def_cfa_register 6 movl %edi, -20(%rbp) movl $1, a(%rip) // global var accessed through a label movl $2, b(%rip) // static global var also movl $3, c.1619(%rip) // static local var also movl $4, -4(%rbp) // local variable is in the stack movl $5, -8(%rbp) // parameter var is in the stack // %rbp is the base pointer register // Point to the base of the stack frame ! leave .cfi_def_cfa 7, 8 ret .cfi_endproc .LFE0: .size func, .-func .local c.1619 // Make name "c" localized .comm c.1619,4,4 // Allocate static local variable c .ident "GCC: (Ubuntu/Linaro 4.5.2-8ubuntu4) 4.5.2" .section .note.GNU-stack,"",@progbits

Notice that:

The variables:

a (global) b (static global) c (static local)

are created using the command

.comm ... 4 // works like ds.b 4

that reserve 4 bytes of memory (just like ds.l 1 in M68000):

The variables:

d (local variable) e (parameter variable)

are located on the stack because they are accessed using the frame (base) pointer %rbp register:

movl $4, -4(%rbp) // d = 4 movl $5, -8(%rbp) // e = 5

Review: variable initialization

Fact:

Consequence:

Local variables and parameter variables:

are initialized each time a function is called
(Because Local variables and parameter variables are created each time a function is called !!!)

Global variables, static global variables and static local variables:

are initialized only once
(Because global variables, static global variables and static local variables are created once only at the start of the program execution !!!)

Warning: the kind of variable has significant impact of program behavior

Try this:

void f( ) { int i = 1234; // Normal local (created when f() is called) static int j = 2345; // Static local (created using ds, ONCE !) i++; j++; printf( "i = %d, j = %d\n", i, j ); } int main( int argc, char* argv[] ) { f(); f(); f(); f(); f(); }

Output:

i = 1235, j = 2346 // i does not change i = 1235, j = 2347 // j changes !!! i = 1235, j = 2348 i = 1235, j = 2349 i = 1235, j = 2350

Example Program: (Demo above code)
- Prog file: click here
How to run the program:
In order to understand the difference in behavior, you need information on the lifetime of the different kinds of variables.
(Which will be discussed next)