CSCI 1110 - C++ Lecture Notes
Chapter 8 - Scope, Lifetime
and More on Functions

Scope of Identifiers

Lifetime of Identifiers

Side Effects

Value Returning Functions

Scope of Identifiers

• The scope of an identifier is the region of the program where it is legal to reference (use) the identifier.
  
  
• C++ has three categories of scope:
  
  
1. Class scope - refers to the data type called a class which will be covered in CSCI 1120.
   
   
2. Local scope - the scope of an identifier declared inside a block extends from the point of declaration to the end of that block.
   
   
3. Global (or file) scope - the scope of an identifier declared outside all functions and classes extends from the point of declaration to the end of the entire file containing the program code.
   
   
• Example of local scope:
  
  
while (alpha > 0)
{
int beta;

cin >> beta;
alpha -= beta;

}

the variable beta is local to the block that is the body of the while statement.



• Example of global scope:
  
  
int gamma;

int main( )
{

. . .
cin >> gamma;
. . .
}

void SomeFunction( )
{

. . .
cout << gamma;
. . .
}

the variable gamma is global to all functions in the example.



• The Rules of Scope determine where in a program an identifier may be accessed, given the point where that identifier is declared:
  
  
1. A function name has global scope. Function difinitions cannot be nested within function definitions.
   
   
2. The scope of a formal parameter is identical to the scope of a local variable declared in the outermost block of the function body.
   
   
3. The scope of a global variable or constant extends from its declaration to the end of the file, except as noted in rule 5.
   
   
4. The scope of a local variable or constant extends from its declaration to the end of the block in which it is declared. This scope inclused any nested blocks, except as noted in rule 5.
   
   
5. The scope of an identifier does not include any nested block that contains a locally declared identifier with the same name. Local identifiers have name precedence.
   
   
• Rules of scope example program:
  
  
// ScopeRules program

#include <iostream.h>

// ---------------------- Prototypes
void Fun(int, char&);

// ------------------------- globals
int a;
int b;

// ---------------------------- main
int main()
{

float b;
. . .
}

// ----------------------------- Fun
void Fun(int b, char &c)
{
    while (. . .)
    {
        int a;
    }
}
 

Scope of the variables named a: Scope of the variables named b and c:
 
•  An external declaration is used to declare an identifier for a C++ program file that is actually defined in another file.
  
  
• In C++, external declarations are made by using the word extern.
  
  
• For example, in our programs we have been using cin and cout which are identifiers  that are not definded in our program. cin and cout are declared, but not defined in iostream.h:
  
  
extern istream cin;
extern ostream cout;
 
This tells the C++ compiler the type of cin and cout and that they are actually defined in some other file.

Lifetime of Identifiers

• The Lifetime of a variable is the period of time during program execution when an identifer has memory allocated to it.
  
  
• The term storage class determines the lifetime of an identifier. C++ has two storage classes - automatic and static.
  
  
• Automatic variable - Memory is allocated when control enters the block in which an automatic variable is declared. When control exits the block, the memory associated with and automatic variable is deallocated.
  
  
• Static variable - Memory is allocated for static variables the first time control enters the block in which it is declared. Memory associated with static variables continues to be allocated as long a the program executes.
  
  
• Variables can be given an initial value when they are declared:
int sum = 0;
 
For automatic variables, this initialization takes place each time the memory for that variable takes place - each time it is automatically allocated by the program.

For static variables, which are allocated only once, the initialization occurs only once - the first time the variable is allocated. 



• Example:
  
  
double Average(int value)
{
static long sum = 0;
static int  count = 0;
double avg;

sum += value;
count++;

avg = double(sum) / double(count);
return avg;

}
 
The function Average can be called repeatedly with a series of integer values. Each time, it will return the average of the values so far as a double.

What would happen if sum and count were not static variables?

Why is avg not a  static variable?

Side Effects

• A function interface is the formal description of the purpose of a function and the mechanism for communicating with it.
  
  
• A side effect is any effect of one function on another or non-local data that is not part of the explicitley defined interface between them.
  
  
• Two things that can cause side effects are the improper use of reference parameters and the use of global variables.
  
  
• Side effect example:
  
  

// Sample program with logic error
#include <iostream.h>

int count;    // Line counter
char ch;      // Holds one input char

// ------------------------------ main
int main()
{

count = 0;
while (cin)
{
count++;
CountChars();
}

cout << count << " lines processed"
     << endl;

}

// ------------------------ CountChars
void CountChars()
{

count = 0;
cin.get(ch);
while (ch != '\n')
{
count++;
cin.get(ch);
}

cout << count
     << " characters on this line"
     << endl;

}

The above example should print the number of characters in each line as they are read. Then after the last line of input, it should print the number of lines processed. Instead, it always prints the number of lines processed as the same number as the number of characters in the last line. Why?




• Global variables should be used with caution. The only time they should be used is for constants values (which cannot be accidentally changed) and for variables which really are global and are needed everywhere in the program. cin and cout which are defined in iostream.h are examples of globals which are properly defined globally.

Value Returning Functions

• Value returning functions are similar to void functions. The only difference is that they return a single value when control is returned to the calling function.
  
  
• Syntax diagram:
  
  

• Example:



int Smallest(int x, int y, int z)
{
int small = x;

if (y < small)

small = y;
if (z < small)
small = z;

return small;

}


• The return statement must contain an expression that evaluates to the same type as the function.
  
  
• Value returning function naming convention: 
  
  Unlike void functions which usually should have a verb as the first part of their names, value returning functions should be named for the value that they compute.
  
  In the previous example, Smallest is a better name that something like ComputeSmallest.
  
  
• Boolean Functions are value returning functions that evaluate to TRUE or FALSE.
  
  
• The use of Boolean functions can simplify the logic of a program and make them much easier to understand.
  
  
• There are a number of Boolean functions which are available from the C++ standard library. The following is a list of some character oriented functions which can be used by #including ctype.h:
  
  

 
 

Function	Function Type	Value
isalpha(ch)	int	Nonzero, if ch is a letter ('A'-'Z', 'a'-'z'); 0 otherwise
isalnum(ch)	int	Nonzero, if ch is a letter or digit ('A'-'Z', 'a'-'z','0'-'9'); 0 otherwise
isdigit(ch)	int	Nonzero, if ch is a numeral ('0'-'9'); 0 otherwise
islower(ch)	int	Nonzero, if ch is a lowercase letter ('a'-'z'); 0 otherwise
isupper(ch)	int	Nonzero, if ch is a uppercase letter ('A'-'Z'); 0 otherwise
isspace(ch)	int	Nonzero, if ch is a whitespace character (blank, newline, tab, caraiage return, form feed); 0 otherwise

 

Copyright 1998 by Thomas C. Irby.