Recall that each variable in modern programming languages has:

• a name: symbolic name used to identify the variable

• an address: the location in memory where variable is stored

• a type: see discussion about data type ( click here )

• In addition to the above properties, each variable also has:
  • a scope
  • a lifetime

  ---

• The scope of a variable is the locations/places/range in the program where the variable is accessible/visible

• The lifetime of a variable is the location (i.e., place) (not a Typo !) where the variable exists

  (Recall that variables are being created and destroyed while the program is running)

• Motivation for scoping:
  • Scoping restricts the access of a variable

  • A large program is very complex and difficult to make it error-free

    ---

  • A commonly used techique to manage complexity is localize possible problems as much as you can.

  • Localizing a problem can be achieved with scoping:

    Variables are used to store data (information) If a variable is updated by only ONE function, the errors involving erroneous updates of that variable can be easily tracked down and fixed However, if a variable is updated by MANY different functions, errors are very hard to track down and fix Example: Local variables pertain to ONE function which cannot be accessed by other function (unless the variable is passed to another function as a parameter)

  ---

• Motivation for lifetime
  • Variables are used to store information

  • When you need to store some new information, you need to create new variables to hold the information.

  • Also, Information can become irrelevant and no longer needed

    So space used to stored the variable need to be reclaimed (variable is then destroyed)

  • Thus, programming languages will need to allow the program to create new variables when they are needed; and also dispose them when they are no longer necessary

    Therefore, a variable has a lifetime

  ---

  ---

• We will next discuss the "lifetime" and "scoping" rules for variables.

  Lifetime has to do with when a variable is created and destroyed

  Scoping has to do with when a variable is accessible and used.

• Scope of a variable refers to the visibility of a variable.

  In other words, which parts of your program can see or use the variable.

• We can also look at scope from the program perspective:

  At every point (statement) in the program, there are certain variables that are visible (= accessible).

  The collection of all variables that are visible/accessing at a given point is called the program scope

  ---

• Scopes in a program are always concentric:
  

• An scope can be defined inside another scope

• We call the first scope the outer scope and the second scope the inner scope

  ---

• In general:

  Every variable NAME that is defined in the outer scope, will be visible (i.e.: known) in the inner scope

  We will learn the precise scoping rule shortly.

  ---

• You can repeat this forever:

  And you can define an "inner inner scope" inside the inner scopex, and so on (scoping levels can go on indefinitely)

• Scoping Rules in C++:

  The inner scope will inherit all variables that are accessible in the outer (enclosing) scope You may define new variables in the inner scope If you define a new variables that has the same name X, as a variable in the outer scope, then the variable name X will refer to the new variable in the inner scope The variables defined in the inner scope CANNOT be accessed (i.e., are NOT visible) in the outer scope

• The way to denote the boundary of a new scope in C/C++ is to use braces:
  •    {     starts a new scope
  •    }     ends the scope

  ---

• Example:

  ..... { (Outer scope) .... .... { (Begin of inner scope) (Inner scope) .... .... } (End of inner scope) .... .... }

• Example: shows the fact that the inner scope inherits variables from outer scope

  int main(int argc, char *argv[]) { int x; x = 1; // int x is accessible after its definition cout << "x = " << x << "\n"; // prints 1 { x = 3.14; // int x is ALSO inside new scope cout << "x = " << x << "\n"; // prints 3 } cout << "x = " << x << "\n"; // prints 3 }

  • Example Program: (Demo above code) --- click here                        

  ---

• Example: shows the effect of a new variable of same name in inner scope

  int main(int argc, char *argv[]) { int x; x = 1; // int x is accessible after its definition cout << "x = " << x << "\n"; // prints 1 { float x; <-------------- change x = 3.14; // int x is ALSO inside new scope cout << "x = " << x << "\n"; // prints ??? } cout << "x = " << x << "\n"; // prints ??? }

• NOTE:

  We say that: The variable x in the outer scope is overshadowed by the variable x in the inner scope

  • Example Program: (Demo above code) --- click here                        

  ---

• Example: shows the fact that a variable in the inner scope cannot be accessed in the outer scope

  int main(int argc, char *argv[]) { { float x; <-------------- x = 3.14; // int x is ALSO inside new scope cout << "x = " << x << "\n"; // prints 3.14 } cout << "x = " << x << "\n"; // prints ??? }

  • Example Program: (Demo above code) --- click here                        

• Recall that the lifetime is the location (i.e., place) (not a Typo !) where the variable exists

  ---

• Lifetime Rules in C++:

  A variable begins to exist when the variable is defined A variable stops to exist at the end of the scope in which the variable is defined

• In other words:

  A variable exits only locally inside the scope in which it is defined For this reason, variables defined inside a scope are called local variables Furthermore, a local variable can be accessed only after its definition

  ---

• Examples:

  int main(int argc, char *argv[]) { ... CANNOT access any variable int var1; <--------- var1 starts to exist .. var1 accessible { .. var1 accessible float var2; <--- var2 starts to exist var1 and var2 are accessible } <--- var2 ends to exist .. only var1 accessible... } <--------- var1 ends to exist float f(float x) { ... CANNOT access any variable int var3; <--------- var3 starts to exist .. var3 accessible { .. var3 accessible float var4; <--- var4 starts to exist var3 and var4 are accessible } <--- var4 ends to exist .. only var3 accessible... } <--------- var3 ends to exist

• In C/C++, you can define variables outside any function

  ---

• Example:

  int x; int main(int argc, char **argv) { .... } float f(float x) { .... }

  ---

• Variables defined outside any function are called global variables

  ---

• The scoping and lifetime of global variables can be understood by putting all functions inside a all compassion scope:

  { int x; int main(int argc, char **argv) { .... } float f(float x) { .... } }

  ---

• Lifetime of Global variables:

  Global variables begins to exist when the program starts Global variables stops to exist when the program exits

  ---

• Scope of Global variables:

  Global variables can be accessed inside every function Unless the global variable is overshadowed by another variable defined in the function

• Scoping rules may differ in different programming languages

• In C/C++: a variable with the same name in an inner scope will prevent a variable with that name in an outer scope to be accessed - this is called: shadowing

• In Java: Java does NOT allow shadowing ...

  Java will forbid the user to define another variable with the same name in an inner scope

  Java adopts a "careful" approach, and tries to prevent the programmer from "confusing oneself"... put it bluntly: Java assumes that you don't know what you're doing...

  Java is made for beginning programmers who do not know what they are doing.... But if you know what you're doing, you will like C++ better.