C++ Primer Plus

But what if you name the variable in the inner block teledeli instead of websight so that you have two variables of the same name, with one in the outer block and one in the inner block? In this case, the program interprets the teledeli name to mean the local block variable while the program executes statements within the block. We say the new definition hides the prior definition. The new definition is in scope, and the old definition is temporarily out of scope. When the program leaves the block, the original definition comes back into scope (see Figure 9.2).

Figure 9.2. Blocks and scope.

Listing 9.4 illustrates how automatic variables are localized to the functions or blocks that contain them.

Listing 9.4. autoscp.cpp

// autoscp.cpp -- illustrating scope of automatic variables

#include

void oil(int x);

int main()

{

    using namespace std;

    int texas = 31;

    int year = 2011;

    cout << "In main(), texas = " << texas << ", &texas = ";

    cout << &texas << endl;

    cout << "In main(), year = " << year << ", &year = ";

    cout << &year << endl;

    oil(texas);

    cout << "In main(), texas = " << texas << ", &texas = ";

    cout << &texas << endl;

    cout << "In main(), year = " << year << ", &year = ";

    cout << &year << endl;

    return 0;

}

void oil(int x)

{

    using namespace std;

    int texas = 5;

    cout << "In oil(), texas = " << texas << ", &texas = ";

    cout << &texas << endl;

    cout << "In oil(), x = " << x << ", &x = ";

    cout << &x << endl;

    {                               // start a block

        int texas = 113;

        cout << "In block, texas = " << texas;

        cout << ", &texas = " << &texas << endl;

                cout << "In block, x = " << x << ", &x = ";

        cout << &x << endl;

    }                               // end a block

    cout << "Post-block texas = " << texas;

    cout << ", &texas = " << &texas << endl;

}

Here is the output from the program in Listing 9.4:

In main(), texas = 31, &texas = 0012FED4

In main(), year = 2011, &year = 0012FEC8

In oil(), texas = 5, &texas = 0012FDE4

In oil(), x = 31, &x = 0012FDF4

In block, texas = 113, &texas = 0012FDD8

In block, x = 31, &x = 0012FDF4

Post-block texas = 5, &texas = 0012FDE4

In main(), texas = 31, &texas = 0012FED4

In main(), year = 2011, &year = 0012FEC8

Notice that each of the three texas variables in Listing 9.4 has its own distinct address and that the program uses only the particular variable in scope at the moment, so assigning the value 113 to the texas in the inner block in oil() has no effect on the other variables of the same name. (As usual, the actual address values and address format will differ from system to system.)

Let’s summarize the sequence of events. When main() starts, the program allocates space for texas and year, and these variables come into scope. When the program calls oil(), these variables remain in memory but pass out of scope. Two new variables, x and texas, are allocated and come into scope. When program execution reaches the inner block in oil(), the new texas passes out of scope (is hidden) because it is superseded by an even newer definition. The variable x, however, stays in scope because the block doesn’t define a new x. When execution exits the block, the memory for the newest texas is freed, and texas #2 comes back into scope. When the oil() function terminates, that texas and x expire, and the original texas and year come back into scope.

Changes to auto in C++11

In C++11, the keyword auto is used for automatic type deduction, as you have seen in Chapters 3, 7, and 8. But in C and in prior versions of C++, auto has an entirely different meaning. It’s used to explicitly identify a variable as having automatic storage:

int froob(int n)

{

     auto float ford;  // ford has automatic storage

     ...

}

Because programmers can use the auto keyword only with variables that are already automatic by default, they rarely bother using it. Its main function is to document that you really wanted to use a local automatic variable.

In C++11, this usage no longer is valid. The people who prepare standards are reluctant to introduce new keywords because doing so might invalidate existing code that already uses that word for other purposes. In this case, it was felt that the old use of auto was rare enough that it was better to repurpose this keyword rather than introduce a new one.

Initialization of Automatic Variables

You can initialize an automatic variable with any expression whose value will be known when the declaration is reached. The following example shows the variables x, big, y, and z being initialized:

int w;          // value of w is indeterminate

int x = 5;      // initialized with a numeric literal

int big = INT_MAX – 1; // initialized with a constant expression

int y = 2 * x;  // use previously determined value of x

cin >> w;

int z = 3 * w;  // use new value of w

Automatic Variables and the Stack