Methods of variable creation

1. Methods of variable creation • Global variable • declared very early stage • available at all times from anywhere • created at the start of the program, and lasts until the end, it is taking up lots of memory • difficult to debug

2. Methods of variable creation (continued) • Local on the fly variables • simply created when they are needed, • only available from within the routine in which they were created • memory requirement is less • easy to debug

3. Methods of variable creation (continued) • Local defined variable • created before they are needed • only available in the routine in which they were created. • Memory requirement is less • easy to debug • the most usually favored method

4. Scope • The scope of an identifier is the portion of the program in which the identifier can be referenced. • Some identifiers can be referenced throughout the program. • Others can be referenced from only portions of a program. • Example: • When we declare a local variable in a block, it can be referenced only in that block or in blocks nested within that block.

5. 1 // This program calculates the number calories in a cheese sandwich 2 #include <iostream.h> 3 const int BREAD = 63; // global constant 4 const int CHEESE = 106; // global constant 5 const int MAYONNAISE = 49; // global constant 6 const int PICKLES = 25; // global constant 7 int main() 8 { 9 int totalCalories; // local variable 10 totalCalories = 2 * BREAD + CHEESE + MAYONNAISE + PICKLES; 11 cout << "There were " << totalCalories; 12 cout << " calories in my lunch yesterday."<< endl; 13 return 0; 14 } A program written in C++

6. Function definition and function prototype • // A programmer-defined square function • #include <iostream> • int square (int); // Function prototype • int main() • { • int x; //local variable • for (x = 1; x <= 10; x++) • cout << square(x) << ‘ ‘; • cout << endl; • return 0; • } • int square (int y) // Function definition • { • return y * y; • } Local variable

7. Storage duration • Period during which an identifier exists in memory. • Some identifiers exists briefly. • Some are repeatedly created and destroyed. • Others exist for the entire execution of a program. • Storage duration can be of two types: • automatic (auto and register) • static

8. Global and Local declarations #include <iostream> void func( float ); const int a = 17; // global constant int b; // global variable int c; // global variable int main() { b = 4; // assignment to global b c = 6; // assignment to global c func(42.8); return 0; } void func( float c) // prevents access to global c { float b; // prevent access to global b b = 2.3; // assignment to local b cout << “ a = “ << a; // output global a (17) cout << “ b = “ << b; // output local b (2.3 cout << “ c = “ << c; // output local c (42.8) } Output: A = 17 b = 2.3 c = 42.8

9. Explanation • In this example, function func accesses global constant a. • However, func declares its own local variable b and parameter c. • Local variable b takes precedence over global variable b, effectively hiding global variable b from the statements in function func. • Function parameter acts like local variable.

10. Life time of a variable • Local variables: variables declared inside a function or variables declared as function parameter. • When you will call the function, memory will be allocated for all local variables defined inside the function. • Finally memory will be deallocated when the function exits. • The period of time a variable will be “alive” while the function is executing is called “lifetime” of this variable.

11. Storage Classes • C++ provides four storage classes: • auto • register • extern • static • An identifier’s storage class helps determine its storage duration and scope.

12. Auto Storage class • Formal parameters and local variables of functions are variables that are automatically allocated on the stack when a function is called and automatically deallocated when the function returns. • They are of storage class auto.

13. Extern • Storage class of names known to the linker. • Example: extern int square (int x); • Means the function will be available to the linker. • It notifies the compiler that such a function exists and that the linker will know where to find it.

14. Register • If you declare a variable of type register, it simply alerts the compiler to the fact that this memory cell will be referenced more often than most. • Register is a special high-speed memory location inside the central processor.

15. Static • Static variable is allocated and initialized one time, prior to program execution. • It remains allocated until the entire program terminates.

16. Namespaces (page 400) • Namespace means scope. • In C++, namespace is a mechanism by which a programmer can create a named scope. • For example, the standard header file cstdlib contains function prototypes for several library functions, one of which is the absolute value function, abs. namespace std { .. int abs (int ); .. }

17. Namespace • Identifiers declared inside the namespace body have namespace scope. • Identifiers defined inside the body can be accessed by three ways. • First method: #include <cstlib> int main() { int alpha; int beta; .. alpha = std::abs(beta); } Scope resolution operator

18. Namespace • Second Method: #include <cstdlib> int main() { int alpha; int beta; using std::abs; … alpha = abs(beta); … }

19. Namespace • Third Method: #include <cstdlib> int main() { int alpha; int beta; using namespace std; … alpha = abs(beta); … }