Storage class in C

Topics
Automatic variables
External variables
Static variables
Register variables
Scopes and longevity of above types of variables.
 Few terms
2

1. Scope: the scope of a variable determines over what

part(s) of the program a variable is actually available for
use(active).
2. Longevity: it refers to the period during which a variables
retains a given value during execution of a
program(alive)
3. Local(internal) variables: are those which are declared
within a particular function.

4. Global(external) variables: are those which are declared

outside any function.
 Automatic variables
3

Are declare inside a function in which they are to be

utilized.
Are declared using a keyword auto.
eg. auto int number;
Are created when the function is called and destroyed
automatically when the function is exited.

This variable are therefore private(local) to the function in

which they are declared.

Variables declared inside a function without storage class

specification is, by default, an automatic variable.
 Example program
4
int main()
{ int m=1000;
function2();
printf(%d\n,m);
}
function1()
{
int m = 10;
printf(%d\n,m);
}
function2()
{ int m = 100;
function1(); Output
printf(%d\n,m);
} 10
100
1000
 Few observation abt auto variables
5

Any variable local to main will normally live throughout the

whole program, although it is active only in main.

During recursion, the nested variables are unique auto

variables.

Automatic variables can also be defined within blocks. In

that case they are meaningful only inside the blocks where
they are declared.

If automatic variables are not initialized they will contain

garbage.
 External Variables
These variables are declared outside
6 any function.

These variables are active and alive throughout the entire program.

Also known as global variables and default value is zero.

Unlike local variables they are accessed by any function in the program.

In case local variable and global variable have the same name, the local
variable will have precedence over the global one.

Sometimes the keyword extern used to declare these variable.

It is visible only from the point of declaration to the end of the program.
 External variable (examples)
7
int number; int count;
float length=7.5; main()
main() {count=10;
{ . . . . . .
. . . . . .
} }
funtion1() funtion()
{. . . {int count=0;
. . . . . .
} . . .
funtion1() count=count+1;
{. . . }
. . .
} When the function references the
variable count, it will be referencing
The variable number and length only its local variable, not the global
are available for use in all three one.
function
 Global variable example
int x; 8
int fun3()
int main() {
{ x=x+10;
x=10; return(x);
printf(x=%d\n,x); }
printf(x=%d\n,fun1());
printf(x=%d\n,fun2());
printf(x=%d\n,fun3());
} Once a variable has been declared
int fun1() global any function can use it and
{ x=x+10; change its value. The subsequent
return(x); functions can then reference only that
} new value.
int fun2()
{ int x Output
x=1;
return(x); x=10
} x=20
x=1
x=30
 External declaration
9
int main()
{ As far as main is concerned, y is not
defined. So compiler will issue an error
y=5; message.
. . . There are two way out at this point
. . . 1. Define y before main.
} 2. Declare y with the storage class extern
int y; in main before using it.

func1()
{
y=y+1
}
 External declaration(examples)
10
int main()
{
extern int y;
. . .
. . . Note that extern declaration
}
does not allocate storage
func1()
space for variables
{
extern int y;
. . .
. . .
}
int y;
 Multifile Programs and extern variables
file1.c 11 file2.c

int main() int m;

{ function2()
extern int m; {
int i int i
. . . . . .
. . . . . .
} }
function1() function3()
{ {
int j; int count;
. . . . . .
. . . . . .
} }
 Multifile Programs and extern variables
file1.c 12 file2.c

int m; extern int m;

int main() function2()
{ {
int i; int i
. . . . . .
. . . . . .
} }
function1() function3()
{ {
int j; int count;
. . . . . .
. . . . . .
} }
 Static Variables
13

The value of static variables persists until the end of the

program.

It is declared using the keyword static like

static int x;
static float y;

It may be of external or internal type depending on the

place of there declaration.

Static variables are initialized only once, when the program

is compiled.
 Internal static variable
14

Are those which are declared inside a function.

Scope of Internal static variables extend upto the end of the

program in which they are defined.

Internal static variables are almost same as auto variable

except they remain in existence (alive) throughout the
remainder of the program.

Internal static variables can be used to retain values

between function calls.
 Examples (internal static)
15

Internal static variable can be used to count the number of calls made
to function. eg.

int main()
{
int I;
for(i =1; i<=3; i++)
stat();
}
void stat() Output
{ x=1
static int x=0;
x = x+1; x=2
printf(x = %d\n,x); x=3
}
 External static variables
16

An external static variable is declared outside of all

functions and is available to all the functions in the
program.

An external static variable seems similar simple external

variable but their difference is that static external variable
is available only within the file where it is defined while
simple external variable can be accessed by other files.
 Static function
17

Static declaration can also be used to control the scope of a

function.
If you want a particular function to be accessible only to the
functions in the file in which it is defined and not to any function
in other files, declare the function to be static. eg.

static int power(int x inty)

{
. . .
. . .
}
 Register Variable
18

These variables are stored in one of the machines register and

are declared using register keyword.
eg. register int count;
Since register access are much faster than a memory access
keeping frequently accessed variables in the register lead to
faster execution of program.

Since only few variable can be placed in the register, it is

important to carefully select the variables for this purpose.
However, C will automatically convert register variables into
nonregister variables once the limit is reached.

Dont try to declare a global variable as register. Because the

register will be occupied during the lifetime of the program.
 19

Keywords : Auto

Storage : Memory

Default intial value : Garbage value

Scope : Local to the block in which the variable is

defined

Life :till the control remains within the block in which

the variable is defined
 20

Keywords : Register

Storage : CPU Register

Default intial value : Garbage value

Scope : Local to the block in which the variable is

defined

Life :till the control remains within the block in which

the variable is defined
 21

Keywords : Static

Storage : Memory

Default intial value : Zero

Scope : Local to the block in which the variable is

defined

Life :value of the variable persists between different

function calls
 22

Keywords : Extern

Storage : Memory

Default intial value : Zero

Scope : Global

Life :as long as the program execution does not

come to end