C++ Primer Plus

As Chapter 15 discusses further, Stroustrup felt that the traditional C-style type cast is dangerously unlimited in its possibilities. The static_cast<> operator is more restrictive than the traditional type cast.

Listing 3.14 briefly illustrates both the basic type cast (two forms) and static_cast<>. Imagine that the first section of this listing is part of a powerful ecological modeling program that does floating-point calculations that are converted to integral numbers of birds and animals. The results you get depend on when you convert. The calculation for auks first adds the floating-point values and then converts the sum to int upon assignment. But the calculations for bats and coots first use type casts to convert the floating-point values to int and then sum the values. The final part of the program shows how you can use a type cast to display the ASCII code for a type char value.

Listing 3.14. typecast.cpp

// typecast.cpp -- forcing type changes

#include

int main()

{

    using namespace std;

    int auks, bats, coots;

    // the following statement adds the values as double,

    // then converts the result to int

    auks = 19.99 + 11.99;

    // these statements add values as int

    bats = (int) 19.99 + (int) 11.99;   // old C syntax

    coots = int (19.99) + int (11.99);  // new C++ syntax

    cout << "auks = " << auks << ", bats = " << bats;

    cout << ", coots = " << coots << endl;

    char ch = 'Z';

    cout << "The code for " << ch << " is ";    // print as char

    cout << int(ch) << endl;                    // print as int

    cout << "Yes, the code is ";

    cout << static_cast(ch) << endl;       // using static_cast

    return 0;

}

Here is the result of the program in Listing 3.14:

auks = 31, bats = 30, coots = 30

The code for Z is 90

Yes, the code is 90

First, adding 19.99 to 11.99 yields 31.98. When this value is assigned to the int variable auks, it’s truncated to 31. But using type casts truncates the same two values to 19 and 11 before addition, making 30 the result for both bats and coots. Then two cout statements use type casts to convert a type char value to int before they display the result. These conversions cause cout to print the value as an integer rather than as a character.

This program illustrates two reasons to use type casting. First, you might have values that are stored as type double but are used to calculate a type int value. For example, you might be fitting a position to a grid or modeling integer values, such as populations, with floating-point numbers. You might want the calculations to treat the values as int. Type casting enables you to do so directly. Notice that you get a different result, at least for these values, when you convert to int and add than you do when you add first and then convert to int.

The second part of the program shows the most common reason to use a type cast: the capability to compel data in one form to meet a different expectation. In Listing 3.14, for example, the char variable ch holds the code for the letter Z. Using cout with ch displays the character Z because cout zeros in on the fact that ch is type char. But by type casting ch to type int, you get cout to shift to int mode and print the ASCII code stored in ch.

auto Declarations in C++11

C++11 introduces a facility that allows the compiler to deduce a type from the type of an initialization value. For this purpose it redefines the meaning of auto, a keyword dating back to C, but one hardly ever used. (Chapter 9 discusses the previous meaning of auto.) Just use auto instead of the type name in an initializing declaration, and the compiler assigns the variable the same type as that of the initializer:

auto n = 100;     // n is int

auto x = 1.5;     // x is double

auto y = 1.3e12L; // y is long double

However, this automatic type deduction isn’t really intended for such simple cases. Indeed, you might even go astray. For example, suppose x, y, and z are all intended to be type double. Consider the following code:

auto x = 0.0;   // ok, x is double because 0.0 is double

double y = 0;   // ok, 0 automatically converted to 0.0

auto z = 0;     // oops, z is int because 0 is int

Using 0 instead of 0.0 doesn’t cause problems with explicit typing, but it does with automatic type conversion.

Automatic type deduction becomes much more useful when dealing with complicated types, such as those in the STL (Standard Template Library). For example, C++98 code might have this:

std::vector scores;

std::vector::iterator pv = scores.begin();

C++11 allows you to write this instead:

std::vector scores;

auto pv = scores.begin();

We’ll mention this new meaning of auto again later when it becomes more relevant to the topics at hand.

Summary