1. Scope Rules and Storage Types
Professor Hugh C. Lauer CS-2303, System Programming Concepts
(Slides include materials from The C Programming Language, 2nd edition, by Kernighan and Ritchie, Absolute C++, by Walter Savitch, The C++ Programming Language, Special Edition, by Bjarne Stroustrup, and from C: How to Program, 5th and 6th editions, by Deitel and Deitel)
CS-2303, A-Term 2012
Scope Rules and Storage Types

2. Scope Rules and Storage Types
Data Storage in Memory
Variables may be automatic or static
Automatic variables are only declared within functions and compound statements (blocks)
Storage allocated when function or block is entered
Storage is released when function returns or block exits
Parameters and result are (somewhat) like automatic variables
Storage is allocated and initialized by caller of function
Storage is released after function returns to caller.
Definitions
CS-2303, A-Term 2012
Scope Rules and Storage Types

3. Scope Rules and Storage Types
Definitions
Static data — data whose memory is allocated at compile time
Actual memory location is set by Linker and Loader
Values are retained across function calls
Automatic data — data whose memory is allocated at run time on “The Stack”
Each time function is called or block is entered
Deleted when function or block exits!
Values are not preserved from one call to next
More about “The Stack” later
CS-2303, A-Term 2012
Scope Rules and Storage Types

4. Scope of Automatic Variables
Identifiers declared within a function or compound statement are visible only from the point of declaration to the end of that function or compound statement.
Like Java
CS-2303, A-Term 2012
Scope Rules and Storage Types

5. Scope Rules and Storage Types
Example
int fcn (float a, int b) {
int i;
double g; for (i = 0; i < b; i++) { double h = i*g;
loop body – may access a, b, i, g, h } // for(i…)
fcn body – may access a, b, i, g
} // int fcn( … )
i is visible from this point to end of fcn
g is visible from this point to end of fcn
h is only visible from this point to end of loop!
None of these are visible outside the function
CS-2303, A-Term 2012
Scope Rules and Storage Types

6. Scope Rules and Storage Types
Idiosyncrasies
In traditional C (& Visual Studio)
All variables must be declared at beginning of function or compound statement (i.e., before first statement); visible from that point on
In gcc
Variables may be declared anywhere in function or compound statement; visible from that point on
In C99 & C++
Loop variables may be declared in for statement; visible only within loop body, but not beyond
CS-2303, A-Term 2012
Scope Rules and Storage Types

7. Static Data – Very different
Variables may be declared within or outside of functions
Storage allocated when program is initialized
Storage is released when program exits
Variables outside of functions are usually visible to linker
Unless you specify otherwise
Compiler sets aside storage for all static variables at compiler or link time
Values retained across function calls
Initializations must evaluate to compile-time constants
CS-2303, A-Term 2012
Scope Rules and Storage Types

8. Confusion in terminology
Reserved word static in C & C++ programs does two things:–
It makes the data static
According to previous definition
Even if it already was static
It hides it from the linker!
Variables declared outside of any function are called global
They are static variables without the word “static”!
CS-2303, A-Term 2012
Scope Rules and Storage Types

9. Static Variable Examples
int j; //global, visible to linker & all functions in this program static float f; // not visible to linker, visible to // to all functions in this program int fcn (float a, int b) { // nothing inside of {} is visible to linker int i = b; //automatic double g; //automatic static double h; //static, not visible to // linker; value retained from call to call body – may access j, f, a, b, i, g, h } // int fcn( … )
CS-2303, A-Term 2012
Scope Rules and Storage Types

10. Static Variable Examples
int j; //global, visible to linker & all functions in this program static float f; // not visible to linker, visible to // to all functions in this program int fcn (float a, int b) { // nothing inside of {} is visible to linker int i = b; //automatic double g; //automatic static double h; //static, not visible to // linker; value retained from call to call body – may access j, f, a, b, i, g, h } // int fcn( … )
Note: value of h is retained from one call to next
Value of h is also retained across recursions
CS-2303, A-Term 2012
Scope Rules and Storage Types

11. Scope Rules and Storage Types
Extern Variables
int j; //static, visible to linker & all functs static float f; // not visible to linker, visible to // to all functions in this program extern float p; // global, defined in another program and visible to linker int fcn (float a, int b) { // nothing inside of {} is visible to linker int i = b; //automatic double g; //automatic static double h; //static, not visible to // linker; value retained from call to call body – may access j, f, a, b, i, g, h , p } // int fcn( … )
extern :– connected by linker to global of another program
CS-2303, A-Term 2012
Scope Rules and Storage Types

12. Extern Variables (continued)
Examples:–
stdin, stdout, stderr are extern variables that point to standard input, output, and error streams.
extern variables:–
Frequently occur in .h files.
Each must be actually declared outside any function in exactly one .c file
CS-2303, A-Term 2012
Scope Rules and Storage Types

13. Scope Rules and Storage Types
Questions?
Next Topic
CS-2303, A-Term 2012
Scope Rules and Storage Types