• Like
What is storage class
Upcoming SlideShare
Loading in...5
×

Thanks for flagging this SlideShare!

Oops! An error has occurred.

What is storage class

  • 76 views
Published

 

Published in Technology
  • Full Name Full Name Comment goes here.
    Are you sure you want to
    Your message goes here
    Be the first to comment
    Be the first to like this
No Downloads

Views

Total Views
76
On SlideShare
0
From Embeds
0
Number of Embeds
0

Actions

Shares
Downloads
5
Comments
0
Likes
0

Embeds 0

No embeds

Report content

Flagged as inappropriate Flag as inappropriate
Flag as inappropriate

Select your reason for flagging this presentation as inappropriate.

Cancel
    No notes for slide

Transcript

  • 1. What is Storage Class? Storage class defined for a variable determines the accessibility and longevity of the variable. The accessibility of the variable relates to the portion of the program that has access to the variable. The longevity of the variable refers to the length of time the variable exists within the program. Types of Storage Class Variables in C++: • Automatic • External • Static • Register Automatic: Variables defined within the function body are called automatic variables. Auto is the keyword used to declare automatic variables. By default and without the use of a keyword, the variables defined inside a function are automatic variables. For instance: void exforsys( ) { auto int x; auto float y; ……… ………… } is same as void exforsys( ) { int x; float y; ……… ………… } //Automatic Variables In the above function, the variable x and y are created only when the function exforsys( ) is called. An automatic variable is created only when the function is called. When the function exforsys( ) is called, the variable x and y is allocated memory automatically. When the function exforsys( ) is finished and exits the control transfers to the calling program, the memory allocated for x and y is automatically
  • 2. destroyed. The term automatic variable is used to define the process of memory being allocated and automatically destroyed when a function is called and returned. The scope of the automatic variables is only within the function block within which it is defined. Automatic variable are also called local variables. External: External variables are also called global variables. External variables are defined outside any function, memory is set aside once it has been declared and remains until the end of the program. These variables are accessible by any function. This is mainly utilized when a programmer wants to make use of a variable and access the variable among different function calls. Static: The static automatic variables, as with local variables, are accessible only within the function in which it is defined. Static automatic variables exist until the program ends in the same manner as external variables. In order to maintain value between function calls, the static variable takes its presence. For example: #include <iostream.h> int exforsys(int); void main( ) { int in,out; while(in!=0) { cout<<”Enter input value:”; cin>>in; out=exforsys(in); cout<”nResult:”<<out; } cout<”n End of Program”<<out; } int exforsys(int x) { static int a=0; static int b=0; a++; b=b+x; return(b/a); }
  • 3. In the above program, the static variables a and b are initialized only once in the beginning of the program. Then the value of the variables is maintained between function calls. When the program begins, the value of static variable a and b is initialized to zero. The value of the input in is 5 (which is not equal to zero) and is then passed to the function in variable x. The variable a is incremented thus making a as equal to 1. Variable b becomes equal to 5 and thus, the return of value from function exforsys( ) for the first time is 5, which is printed in the called function. The second time the value of the input in is 7 (which is not equal to zero) and is passed to the function in variable x. The variable a (which is declared as static) has the previous value of 1. This is incremented and the value of a is equal to 2. The value of b is maintained from the previous statement as 5 and new value of b now is b=5+7 = 12 and thus, the return value from the function is 12/2=6 which is printed in the called function. Storage Classes. C has a concept of 'Storage classes' which are used to define the scope (visibility) and life time of variables and/or functions. So what Storage Classes are available? auto register static extern typedef Auto - storage class Auto is the default storage class for local variables. { int Count; auto int Month; } The example above defines two variables with the same storage class. auto can only be used within functions, i.e. local variables. Register - Storage Class Register is used to define local variables that should be stored in a register instead of RAM. This means that the variable has a maximum size equal to the register size (usually one word) and cant have the unary '&' operator applied to it (as it does not have a memory location). { register int Miles; }
  • 4. Register should only be used for variables that require quick access - such as counters. It should also be noted that defining 'register' goes not mean that the variable will be stored in a register. It means that it MIGHT be stored in a register - depending on hardware and implementation restrictions. Static - Storage Class Static is the default storage class for global variables. The two variables below (count and road) both have a static storage class. static int Count; int Road; main() { printf("%dn", Count); printf("%dn", Road); } 'Static' can also be defined within a function. If this is done, the variable is initialized at compilation time and retains its value between calls. Because it is initialsed at compilation time, the initialization value must be a constant. This is serious stuff - tread with care. void Func(void) { static Count=1; } Here is an example There is one very important use for 'static'. Consider this bit of code. char *Func(void); main() { char *Text1; Text1 = Func(); } char *Func(void) { char Text2[10]="martin"; return(Text2); }
  • 5. 'Func' returns a pointer to the memory location where 'Text2' starts BUT Text2 has a storage class of auto and will disappear when we exit the function and could be overwritten by something else. The answer is to specify: static char Text[10]="martin"; The storage assigned to 'Text2' will remain reserved for the duration if the program. Extern - storage Class extern defines a global variable that is visable to ALL object modules. When you use 'extern' the variable cannot be initalized as all it does is point the variable name at a storage location that has been previously defined. Source 1 -------extern int count; write() { printf("count is %dn", count); } Source 2 -------int count=5; main() { write(); } Count in 'source 1' will have a value of 5. If source 1 changes the value of count - source 2 will see the new value.
  • 6. 'Func' returns a pointer to the memory location where 'Text2' starts BUT Text2 has a storage class of auto and will disappear when we exit the function and could be overwritten by something else. The answer is to specify: static char Text[10]="martin"; The storage assigned to 'Text2' will remain reserved for the duration if the program. Extern - storage Class extern defines a global variable that is visable to ALL object modules. When you use 'extern' the variable cannot be initalized as all it does is point the variable name at a storage location that has been previously defined. Source 1 -------extern int count; write() { printf("count is %dn", count); } Source 2 -------int count=5; main() { write(); } Count in 'source 1' will have a value of 5. If source 1 changes the value of count - source 2 will see the new value.