6.2.2. Functions and Variable Scope

Every block (code appearing between a { and } ) defines a new scope - the region in a program where a name, often a variable name, is visible and accessible. Although blocks can be nested arbitrarily deep, there are only three primary or named levels of scope:

1. Local: inside a function
2. Class: inside a class (i.e., an attribute or a member variable)
3. Global: outside all functions and classes

Programmers often classify variables by their scope: they define global variables in global scope, local variables in local scope, and class variables in class scope. We defer our discussion of class scope and class variables until chapter 9.

Local Variables

Local variables, including the function's parameters, are defined in a function. Programs initialize parameters with the values passed in as a part of the function call. Programmers may explicitly initialize the remaining local variables with an assignment that is part of the variable definition, but doing this is not required.

int read()
{
	int	count = 0;

	while (there are lines in the file)
	{
		read a line;
		count++;
	}

	return count;
}

The stack relies on a simple algorithm to manage its memory: A function call pushes a data structure called a stack frame onto the runtime stack. The stack frame corresponds to a single stack element (i.e., one colored box in the stack animations). The stack frame stores the return address (i.e., the address where execution resumes when the function ends) and provides the memory for all the function's local variables. The program pops and discards the stack frame when the function ends and returns.

void function(int u, int v) { int x; int y; int z; . . . }
(a)	(b)

Function Scope: Call Vs. Definition

In a previous section, we learned that function arguments, the data passed into a function, are expressions. Expressions can contain sub-expressions formed by variables and operators, and some of those operators can change the values stored in the variables. Discerning a variable's scope is essential in understanding the behavior of function calls containing argument-modifying operations.

int a = 5
int b = 10;

function(a++, b++);
 

int a = 5
int b = 10;
function(a, b);
a++;
b++;

void function(int x, int y)
{
	...
}
 

static Variables

Automatic and static variables lie at opposite ends of the memory allocation spectrum. The static keyword does not alter a variable's scope, but it does alter its behavior in two important ways:

1. Programs only initialize static variables once when the operating system loads them into memory (not on each function call like automatic variables)
2. Local static variables retain their saved values between function calls, which functions can use when called again.

These features are pivotal in the following C++ function's operation.

double random()
{
	static  double	x = 0;

	x = x * (x + 1) % 2147483648L;

	return  x;
}

Memory Allocation and Initialization Summary

Two features distinguish auto and static variables: when the variable's memory is allocated and deallocated and when an explicit initialization takes place.

int minimum = 100;

static int maximum = 100;

Global Variables

Programs define global variables outside any function or class. If the programmer does not explicitly initialize global variables, the compiler automatically initializes them to their zero equivalent. Zero-equivalent values are 0 for integers, 0.0 for floating-point types, false for Booleans, and nullptr for pointers.

The initialization operation for explicitly initialized global variables only occurs once when the operating system loads the program into memory for execution.

Global Variables: Use and Pitfalls

Global variables are always visible from the point of their definition to the end of the defining file. Programmers typically use global variables in three situations:

1. Whenever two or more functions must share data. Classes reduce the need for global data by allowing member functions to share class-scope data.
2. When a function creates or uses a large amount of discrete data (individual variables) that are not easily passed to or returned from the function. Arrays and objects (instances of structures and class) make it easier for programs to move large data blocks.
3. When data is exchanged (passed to or returned from) between functions separated by many intervening function calls and where the intervening functions do not use the data. The following figure illustrates this situation.

functionA()
{
	// data defined here as a local variable

	functionB(data)
}

functionB(data)
{
	functionC(data)
}
	.
	.
	.
functionY(data)
{
	functionZ(data)
}

functionZ(data)
{
	//data used here;
}

// data defined here as a global

functionA()
{
	functionB()
}

functionB()
{
	functionC()
}
	.
	.
	.
functionY()
{
	functionZ()
}

functionZ()
{
	//data used here;
}

int var = 10;

void function()
{
	cout << var << endl;
}
 

int var = 10;

void function()
{
	int var = 5;
	cout << var << endl;
}

int var = 10;

void function()
{
	int var = 5;
	cout << ::var << endl;
}

Modules And File Scope

Strictly speaking, variables defined outside of functions or classes only have file scope: they are only visible and accessible from the point of their definition to the end of the defining file. But all that is necessary to expand file scope to global - making the variables visible throughout a program - is an extern declaration in each file desiring access to the variables. To easily make a variable truly global, place the extern declaration in a header file and #include it in the program's source code files.

C programmers limited the scope of "global variables" by creating modules defining file scope variables. An overloaded application of the static keyword allows programmers to limit the scope of otherwise global variables to the defining compilation unit (i.e., file). Functions defined in the same file as the file scope variables are the only ones allowed to access them. Programs attempting to access a file scope variable from another file will cause the linker (or loader) to abort with an "unresolved external symbol" error.

int counter = 100;
static int size = 50;

void increment()
{
	counter++;
}

extern int counter;	// declaration

int report()
{
	return counter;
}
 

Coupled Functions

So, what's the big problem with global variables? Functions that share global data are said to be coupled. Coupling implies that the functions cannot be tested or validated in isolation. Coupled functions must be tested and debugged as a group because a change made to the data by one function can affect another function sharing the data. This requirement makes working with coupled functions more difficult and error-prone.

Furthermore, coupled functions are often very fragile. One function can make a small, innocuous change to the data that causes a catastrophic failure in a coupled function. The opportunities for these conflicts increase with the size of the data and the number of coupled functions until it becomes challenging to maintain the program. Changes to shared data ripple outwards, crossing file boundaries and affecting code not being changed, silently introducing bugs into previously working code.

Function coupling increases the complexity of a program. And that complexity increases at a greater rate than the rate of function addition. That means doubling the number of coupled functions more than doubles the program's complexity. The complexity continues increasing to the point where the system becomes so complex that further growth is impractical.

(a)	(b)	(c)

int a = 5
int b = 10;
a++;
b++;
function(a, b);