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)

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

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.

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

A variable name begins to be known after its definition 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 (Java disallows the definition of variables with the same name in an inner scope. So, this C++'s scoping rule may confuse some Java users...) The variables defined in the inner scope CANNOT be accessed (i.e., are NOT visible) in the outer scope

•    {     starts a new scope
•    }     ends the scope

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

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

Java shows a similar behavior

• C++ Prog file: click here
• Java Prog file: click here

int main(int argc, char *argv[]) { int x; x = 1; // (1) int x is accessible after its definition cout << "x = " << x << "\n"; // prints 1 { x = 9999; // Uses x at (1) cout << "x = " << x << "\n"; // prints 9999 float x; // (2) <----- variable with SAME name !! x = 3.14; // Uses x at (2) !!! cout << "x = " << x << "\n"; // prints 3.14 } cout << "x = " << x << "\n"; // prints 9999 !!! // (x at (1) is unchanged by x=3.14 !) }

Note that there are two different variables x in the inner scope:

int x; // defined at line (1) float x; // defined at line (2)

(Java disallows this construct !!!)

Before the definiton of "float x", the name (symbol) x in the inner scope refers to the variable defined at (1) After the definiton of "float x", the name (symbol) x inside the inner scope refers to the variable defined at (2) (We say that the variable x in the outer scope is "overshadowed" by the variable x in the inner scope)

• C/C++ Prog file: click here
• Java Prog file: click here

int main(int argc, char *argv[]) { { int x; <-------------- x = 3; // No error cout << "x = " << x << "\n"; // No error } x = 1111; // x undefined ! cout << "x = " << x << "\n"; // x undefined... }

Java has the same scoping effect

• C++ Prog file: click here
• Java Prog file: click here

The life time rules in C++ is the same as in Java

Local variables:

A local variables begins to exist at the place of its definition A local variables ceases to exist at the end of the scope that contains its definition

Parameter variables:: behaves like local variables defined at the beginning of the function

A parameter variables begins to exist at the start of the function A local variables ceases to exist at the end of the function

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

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

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

Global variables can be accessed inside every function Unless the global variable is overshadowed by another variable (with the same name) defined in the function

Example:

int x; // (1) int main(int argc, char **argv) { double x; // Global variable x (at (1)) is no longer accessible... .... } float f(float x) { // Global variable x (at (1)) is accessible ! .... }

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"...