C++ Primer Plus

Third, it provides better protection against type conversion errors, a topic we’ll return to near the end of this chapter.

Why, you may ask with good reason, does the language need more alternatives? As odd as it may seem, the reason is to make using C++ easier for the novice. In the past, C++ has used different forms of initialization for different types, and the form used to initialize class variables was different from the form used for ordinary structures—and that, in turn, was different from the form usually used for simple variables such as we have been using. C++ added the parentheses form of initialization to make initializing ordinary variables more like initializing class variables. C++11 makes it possible to use the braces syntax (with or without the =) with all types—a universal initialization syntax. In the future, texts may introduce you to initialization using the brace forms and mention the other forms as historical oddities retained for backward compatibility.

Unsigned Types

Each of the four integer types you just learned about comes in an unsigned variety that can’t hold negative values. This has the advantage of increasing the largest value the variable can hold. For example, if short represents the range –32,768 to +32,767, the unsigned version can represent the range 0 to 65,535. Of course, you should use unsigned types only for quantities that are never negative, such as populations, bean counts, and happy face manifestations. To create unsigned versions of the basic integer types, you just use the keyword unsigned to modify the declarations:

unsigned short change;          // unsigned short type

unsigned int rovert;            // unsigned int type

unsigned quarterback;           // also unsigned int

unsigned long gone;             // unsigned long type

unsigned long long lang_lang;   // unsigned long long type

Note that unsigned by itself is short for unsigned int.

Listing 3.2 illustrates the use of unsigned types. It also shows what might happen if your program tries to go beyond the limits for integer types. Finally, it gives you one last look at the preprocessor #define statement.

Listing 3.2. exceed.cpp

// exceed.cpp -- exceeding some integer limits

#include

#define ZERO 0      // makes ZERO symbol for 0 value

#include   // defines INT_MAX as largest int value

int main()

{

    using namespace std;

    short sam = SHRT_MAX;     // initialize a variable to max value

    unsigned short sue = sam;// okay if variable sam already defined

    cout << "Sam has " << sam << " dollars and Sue has " << sue;

    cout << " dollars deposited." << endl

         << "Add $1 to each account." << endl << "Now ";

    sam = sam + 1;

    sue = sue + 1;

    cout << "Sam has " << sam << " dollars and Sue has " << sue;

    cout << " dollars deposited.\nPoor Sam!" << endl;

    sam = ZERO;

    sue = ZERO;

    cout << "Sam has " << sam << " dollars and Sue has " << sue;

    cout << " dollars deposited." << endl;

    cout << "Take $1 from each account." << endl << "Now ";

    sam = sam - 1;

    sue = sue - 1;

    cout << "Sam has " << sam << " dollars and Sue has " << sue;

    cout << " dollars deposited." << endl << "Lucky Sue!" << endl;

    return 0;

}

Here’s the output from the program in Listing 3.2:

Sam has 32767 dollars and Sue has 32767 dollars deposited.

Add $1 to each account.

Now Sam has -32768 dollars and Sue has 32768 dollars deposited.

Poor Sam!

Sam has 0 dollars and Sue has 0 dollars deposited.

Take $1 from each account.

Now Sam has -1 dollars and Sue has 65535 dollars deposited.

Lucky Sue!

The program sets a short variable (sam) and an unsigned short variable (sue) to the largest short value, which is 32,767 on our system. Then it adds 1 to each value. This causes no problems for sue because the new value is still much less than the maximum value for an unsigned integer. But sam goes from 32,767 to –32,768! Similarly, subtracting 1 from 0 creates no problems for sam, but it makes the unsigned variable sue go from 0 to 65,535. As you can see, these integers behave much like an odometer. If you go past the limit, the values just start over at the other end of the range (see Figure 3.1). C++ guarantees that unsigned types behave in this fashion. However, C++ doesn’t guarantee that signed integer types can exceed their limits (overflow and underflow) without complaint, but that is the most common behavior on current implementations.

Figure 3.1. Typical overflow behavior for integers.

Choosing an Integer Type

With the richness of C++ integer types, which should you use? Generally, int is set to the most “natural” integer size for the target computer. Natural size refers to the integer form that the computer handles most efficiently. If there is no compelling reason to choose another type, you should use int.