CSCI 201 Study Aid: Variable Scope

What is ``Scope''

• The Scope of a variable is simply the section of the program in which you can use that variable.
• Briefly, here are the different categories of scope:
  • Global Scope. An identifier declared outside of any function will be known by each function in the file. Generally speaking, global variables should be avoided.
  • Function Scope. An identifier with function scope is known only inside the body of the function. Most variables should not be known outside their functions, lest a different part of the program change values of the variables to the detriment of the function. Function scope begins when a variable is declared in a function, and ends when the function ends. A variable with function scope is said to be local to that function.
  • Block Scope. Blocks of code are identified by left and right braces: { }. Block scope begins when a variable is declared, and ends at the right brace which terminates the block. A variable with block scope is said to be local to that block. Function scope is really the same thing as block scope in that a function is a kind of block.
  • Function-prototype Scope. Remember that in function prototypes the compiler ignores the variable names, only focussing on the type of the variables. What this means is that the variables can be re-used anywhere in the program without being affected by the function prototype's use of the variable name.
• In C++ we must consider whether variables are global or local, and also be aware of possible naming conflicts between variables, constants, and parameters.

Resolving naming conflicts

• Illegal combinations: you cannot have:
  • Global variables and global constants of the same name
  • Subroutine parameters and local variables of the same name

• Legal combinations: you can have:
  • Global variables and local variables of the same name
  • Global constants and local variables of the same name
  • Global variables and parameters of the same name
  • Global constants and parameters of the same name

• Resolving conflicts: when multiple identifiers have overlapping scopes:
  • First look for local variables of the specified name
  • If none are found then look for parameters of the given name
  • If none are found then look for global variables/constants of the given name
  • If none are found then there is an error

An Example

Examine the program below and determine the scope of its identifiers. These scoping principals are designed to make sure that the different functions do not inadvertently change variables in the other's memory space simply because the variables are accidentally or even purposefully given the same name. An added benefit is that a programmer can work on a particular function and make changes without having to worry about how those changes will affect the variables in other functions.

 
// Complete program to calculate population doubling time
#include <iostream.h>
float doublingTime(float bacterialGrowthRate);  // Prototype - notice,
                                                //it is defined before main
int main ()
{
        float twiceTime, rateEColi;             // variable declaration
        rateEColi = 0.84;       // Unit is bacteria per hour. Rates vary
                                // with the environment.
        twiceTime = doublingTime(rateEColi);    // Calling statement
                                                // rateEColi is known as an
                                                // actual arugment
        cout << "Doubling time for Escherichia coli is: "
             <<  twiceTime  << endl;
        return 0;
}

float doublingTime(float bacterialGrowthRate)   // Function definition -
                                                 // bacterialGrowthRate is
                                                 // known as a
                                                 // formal parameter
{
        float natLogOf2 = 0.6931, time2Double;  // Data declarations for
                                                   // doublingTime function
        time2Double = natLogOf2 / bacterialGrowthRate;
        return time2Double;
}

Note that the calling statement

   twiceTime = doublingTime(rateEColi)

Exercises

1. Is this program valid, and if so what does it do?

      #include 
      const   int x = 3;
      float y;
   
      int  foo(float &x) 
      {
         int y;
         y = int(x - (int(x) % 2));
         x = 13;
         return y;
      }
   
      int main()
      {
         int y = 3;
         float x = 3.14;
         y = y + foo(x);
         cout << x << " " << y << "\n";
      }
   

   solution

2. What does this program print?

   #include 
   
   void a(void);   // function prototype
   void c(void);   // function prototype
   
   int x = 1;      // global variable
   
   main()
   {
      int x = 5;   // local variable to main
   
      cout << "local x in outer scope of main is " << x << endl;
   
      {            // start new scope
         int x = 7;
   
         cout << "local x in inner scope of main is " << x << endl;
      }            // end new scope
   
      cout << "local x in outer scope of main is " << x << endl;
   
      a();         // a has local x
      c();         // c uses global x
      a();         // a reinitializes local x
      c();         // global x also retains its value
   
      cout << "local x in main is " << x << endl;
   
      return 0;
   }
   
   void a(void)
   {
      int x = 25;  // initialized each time a is called
   
      cout << endl << "local x in a is " << x 
           << " after entering a" << endl;
      ++x;
      cout << "local x in a is " << x 
           << " before exiting a" << endl;
   }
   
   void c(void)
   {
      cout << endl << "global x is " << x 
           << " on entering c" << endl;
      x *= 10;
      cout << "global x is " << x << " on exiting c" << endl;
   }
   

   solution