C++ Primer Plus

// file2

static int errors = 5;  // known to file2 only

void froobish()

{

      cout << errors;   // uses errors defined in file2

      ...

This doesn’t violate the one definition rule because the keyword static establishes that the identifier errors has internal linkage, so no attempt is made to bring in an external definition.

Note

In a multifile program, you can define an external variable in one and only one file. All other files using that variable have to declare that variable with the extern keyword.

You can use an external variable to share data among different parts of a multifile program. You can use a static variable with internal linkage to share data among functions found in just one file. (Namespaces offer an alternative method for this.) Also if you make a file-scope variable static, you needn’t worry about its name conflicting with file-scope variables found in other files.

Listings 9.7 and 9.8 show how C++ handles variables with external and internal linkage. Listing 9.7 (twofile1.cpp) defines the external variables tom and dick and the static external variable harry. The main() function in that file displays the addresses of the three variables and then calls the remote_access() function, which is defined in a second file. Listing 9.8 (twofile2.cpp) shows that file. In addition to defining remote_access(), the file uses the extern keyword to share tom with the first file. Next, the file defines a static variable called dick. The static modifier makes this variable local to the file and overrides the global definition. Then the file defines an external variable called harry. It can do so without conflicting with the harry of the first file because the first harry has internal linkage only. Then the remote_access() function displays the addresses of these three variables so that you can compare them with the addresses of the corresponding variables in the first file. Remember that you need to compile both files and link them to get the complete program.

Listing 9.7. twofile1.cpp

// twofile1.cpp -- variables with external and internal linkage

#include      // to be compiled with two file2.cpp

int tom = 3;            // external variable definition

int dick = 30;          // external variable definition

static int harry = 300; // static, internal linkage

// function prototype

void remote_access();

int main()

{

    using namespace std;

    cout << "main() reports the following addresses:\n";

    cout << &tom << " = &tom, " << &dick << " = &dick, ";

    cout << &harry << " = &harry\n";

    remote_access();

    return 0;

}

Listing 9.8. twofile2.cpp

// twofile2.cpp -- variables with internal and external linkage

#include

extern int tom;         // tom defined elsewhere

static int dick = 10;   // overrides external dick

int harry = 200;        // external variable definition,

                        // no conflict with twofile1 harry

void remote_access()

{

    using namespace std;

    cout << "remote_access() reports the following addresses:\n";

    cout << &tom << " = &tom, " << &dick << " = &dick, ";

    cout << &harry << " = &harry\n";

}

Here is the output from the program produced by compiling Listings 9.7 and 9.8 together:

main() reports the following addresses:

0x0041a020 = &tom, 0x0041a024 = &dick, 0x0041a028 = &harry

remote_access() reports the following addresses:

0x0041a020 = &tom, 0x0041a450 = &dick, 0x0041a454 = &harry

As you can see from the addresses, both files use the same tom variable but different dick and harry variables. (The particular address values and formatting may be different on your system, but the tom addresses will match each other, and the dick and harry addresses won’t.)

Static Storage Duration, No Linkage

So far, we’ve looked at a file-scope variable with external linkage and a file-scope variable with internal linkage. Now let’s look at the third member of the static duration family: local variables with no linkage. You create such a variable by applying the static modifier to a variable defined inside a block. When you use it inside a block, static causes a local variable to have static storage duration. This means that even though the variable is known within that block, it exists even while the block is inactive. Thus a static local variable can preserve its value between function calls. (Static variables would be useful for reincarnation—you could use them to pass secret account numbers for a Swiss bank to your next appearance.) Also if you initialize a static local variable, the program initializes the variable once, when the program starts up. Subsequent calls to the function don’t reinitialize the variable the way they do for automatic variables. Listing 9.9 illustrates these points.

Listing 9.9. static.cpp

// static.cpp -- using a static local variable

#include

// constants

const int ArSize = 10;

// function prototype

void strcount(const char * str);

int main()

{

    using namespace std;

    char input[ArSize];

    char next;

    cout << "Enter a line:\n";