***Welcome to ashrafedu.blogspot.com * * * This website is maintained by ASHRAF***

Monday, April 26, 2021

Storage Classes

The Storage class of a variable defines the scope and lifetime of variable. Storage class specifiers control two different properties: storage duration/life time (determines how long a variable can exist) and scope (determines which part of the program can access it).

C++ supports four storage classes:

1) auto 2) register 3) extern 4) static.

The general syntax for specifying the storage class of a variable is as fallows

<Storage_Class_Specifier>  <Data_Type>  <Variable_Name> ;

Example:        

auto int x;

static int y;

1. Auto Storage Class:

The auto storage class is the default storage class for all local variables. The scope of an automatic variable has block scope. The Automatic variable is stored in the program's stack. They are also called Automatic variable because they come into life form when scope is entered and automatically go away when the scope ends.

The keyword auto is used, but by default all local variables are auto, so we don't have to explicitly add keyword auto before variable declaration. Default value of such variable is garbage.

Example:        

auto int x;

2. Register Storage class:

The storage is used if you want faster access to the variable. The variable will get stored in the CPU register instead of RAM (memory). The other properties of the register storage are same as of automatic storage, except the location, where the variable is stored. Here we are just requesting the compiler to store register variable in CPU's register but the final decision is up to compiler where it wants to store.

Register variable can be declared in the following way:

register int x;

3) Extern Storage Class:

The extern storage is used when you want to access a global variable/object which is defined in another file. We use “extern class specifier” to specify the compiler that the current object is defined somewhere else in other file and not in current file.

extern variable can be declared in the following way: 

extern int x;

extern variables can't be initialized. But they can be modified.

Example:

Sub.cpp

int test=100; // assigning value to test

void multiply(int n)

{

test=test*n;

}

Main.cpp

#include<iostream.h>

#include<conio.h>

#include "sub.cpp" // includes the content of sub.cpp

extern int test; // declaring test

void main()

{

clrscr();

cout<<"test value before modify="<<test<<"\n"; multiply(5);

cout<<"test value after modify= "<<test<<"\n"; getch();

}

4. Static Storage Class

Auto is the default storage class for all local variables. Static is the default storage class for all global variables.

Static variable has a lifetime (visible) over the entire program. This means that memory for the static variable is allocated when the program begins and freed when the program terminates.

General syntax to declare static variable is

static <Data_type> <Variable_name>;

When a static variable is not initialized by the programmer, then it is automatically initializes to zero (0) when memory is allocated for them.

If variable is a local static variable, the difference between an auto variable and a static variable is that the static variable when defined within a function is not re-initialized when the function is called repeatedly.                                          

It is initializes just once and further calls of the function shows the value of static variable. Hence the static variable inside a function retain its value during various calls.           

 

Storage

Keyword       

Lifetime

Visibility        

Initial Value

Automatic

auto

Function Block

Local

Garbage

External

extern

Whole Program

Global

Zero

Static

static

Whole Program

Local  

Zero

Register

register

Function Block

Local

Garbage

No comments:

Post a Comment