Notes

Outline

Scope, Lifetime, and More on Functions Identifiers can be declared either inside a block (local variables) or outside a block (function names). C++ has rules governing how a function may access parameters declared outside its own block. A value-returning function returns a single result to the expression from which it was called. We’ll look at writing user-defined value-returning functions.

Scope of Identifiers Listing all of the places from which an identifier can be accessed legally is describing that identifier’s scope. C++ defines several categories of scope for any identifier Class scope. Postpone this until chapter 11. Local scope. The scope of an identifier declared inside a block extends from the point of declaration to the end of that block. Global 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.

Global Variable Example int gamma; // Global variable int main() {     gamma = 3;       .       .       . } void SomeFunc() {     gamma = 5;      .      .      . }

Local Definitions Take Precedence Over Global Ones void SomeFunc(float); const int a = 17;      // A global constant int b, c;      // Two global variables int main() {     b = 4;      // Assignment to global b     c = 6;               // Assignment to global c     SomeFunc(42.8);    return 0; }

Local Definitions Take Precedence Over Global Ones void SomeFunc(float c)   // Prevents access to global c {     float b;           // Prevents 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) }

Scope Rules Explored void Block1(int, char&); void Block2(); int a1;               // One global variable char a2;              // Another global variable int main() {    .    .    . } void Block1(int a1,   // Prevents access to global a1             char& b2) // Has same scope as c1 and d2 {    int c1;          // A variable local to Block1    int d2;          // Another variable local to Block1      .      .      . }

Scope Rules Explored (continued) void Block2() {    int a1;            // Prevents access to global a1    int b2;            // Local to Block2; no conflict                       // with b2 in Block1    while (…)    {                 // Block3       int c1;        // Local to Block3; no conflict                       // with c1 in Block1       int b2;         // Prevents nonlocal access to b2                       // in Block2; no conflict with                       // b2 in Block1         .         .         .    } }

Accessing Identifiers From Other Program Files Individually extern int someInt; Collectively, from a namespace std::abs(beta);   (qualified name) using std::abs;  (using declaration) using namespace std; (using directive)

Lifetime of A Variable Lifetime is the period of time during program execution when an identifier actually has memory allocated to it. Two types of variables Static variables – storage remains allocated for the duration of the entire program Automatic variables – storage is allocated at block entry and deallocated at block exit By default, variables declared within a block are automatics, this can be changed using the reserved word static.

Side Effects Illustrated void CountChars(); int count = 0;    // Supposed to count input lines char ch;          // Hold one input character int main() {    cin.get(ch);    while(cin)    {       count++;       CountChars();       cin.get(ch);    }    cout << count << “ lines of input processed.” << endl;    return 0; }

Side Effects Illustrated (continued) void CountChars() // Counts the number of characters on one input line // and prints the count Note: main() has already // read the first character on a line {    count = 0;    while (ch != ‘\n’)    {       count++;       cin.get(ch);    }    cout << count << “characters on this line.” << endl; }

Another Scope Example void one() {    int a = 10;    cout << " a = " << a << endl; } void two () {    int a = 0;    one( );    cout << " a = " << a << endl; } int main () a = 20 {    int a = 20;    two( ); }

Another Scope Example void one() {    int a = 10;    cout << " a = " << a << endl; } void two () {    int a = 0;    one( );    cout << " a = " << a << endl; } int main () a = 20 {    int a = 20;    two( ); }

Another Scope Example void one() {    int a = 10;    cout << " a = " << a << endl; } void two () {    int a = 0; a = 0    one( );    cout << " a = " << a << endl; } int main () {    int a = 20;    two( ); }

Another Scope Example void one() {    int a = 10;    cout << " a = " << a << endl; } void two () {    int a = 0;    one( ); a = 0    cout << " a = " << a << endl; } int main () {    int a = 20;    two( ); }

Another Scope Example void one() {    int a = 10; a = 10    cout << " a = " << a << endl; } void two () {    int a = 0;    one( );    cout << " a = " << a << endl; } int main () {    int a = 20;    two( ); }

Another Scope Example void one() {    int a = 10;    cout << " a = " << a << endl; a = 10 } void two () {    int a = 0;    one( );    cout << " a = " << a << endl; } int main () {    int a = 20;    two( ); }

Another Scope Example void one() {    int a = 10;    cout << " a = " << a << endl; } void two () {    int a = 0;    one( );    cout << " a = " << a << endl; a = 0 } int main () {    int a = 20;    two( ); }

Another Scope Example void one(void) {    int a = 10;    cout << " a = " << a << endl; } void two (void) {    int a = 0;    one( );    cout << " a = " << a << endl; } int main (void) a = 20 {    int a = 20;    two( ); }