C++ Primer Plus

Which of these type casts are safe? Depending on the class declarations, all of them could be safe, but the only ones guaranteed to be safe are the ones in which the pointer is the same type as the object or else a direct or indirect base type for the object. For example, Type Cast #1 is safe because it sets a type Magnificent pointer to point to a type Magnificent object. Type Cast #2 is not safe because it assigns the address of a base-class object (Grand) to a derived-class (Magnificent) pointer. Thus, the program would expect the base-class object to have derived-class properties, and that, in general, is false. A Magnificent object, for example, might have data members that a Grand object would lack. Type Cast #3, however, is safe because it assigns the address of a derived-class object to a base-class pointer. That is, public derivation promises that a Magnificent object also is a Superb object (direct base) and a Grand object (indirect base). Thus, it’s safe to assign its address to pointers of all three types. Virtual functions ensure that using pointers of any of the three types to a Magnificent object will invoke Magnificent methods.

Note that the question of whether a type conversion is safe is both more general and more useful than the question of what kind of object is pointed to. The usual reason for wanting to know the type is so that you can know if it’s safe to invoke a particular method. You don’t necessarily need an exact type match to invoke a method. The type can be a base type for which a virtual version of the method is defined. The next example illustrates this point.

First, however, let’s look at the dynamic_cast syntax. The operator is used like this, where pg points to an object:

Superb * pm = dynamic_cast(pg);

This code asks whether the pointer pg can be type cast safely (as described previously) to the type Superb *. If it can, the operator returns the address of the object. Otherwise it returns 0, the null pointer.

Note

In general, the following expression converts the pointer pt to a pointer of type Type * if the pointed-to object (*pt) is of type Type or else derived directly or indirectly from type Type:

dynamic_cast(pt)

Otherwise, the expression evaluates to 0, the null pointer.

Listing 15.17 illustrates the process. First it defines three classes, coincidentally named Grand, Superb, and Magnificent. The Grand class defines a virtual Speak() function, which each of the other classes redefines. The Superb class defines a virtual Say() function, which Magnificent redefines (see Figure 15.4). The program defines a GetOne() function that randomly creates and initializes an object of one of these three types and then returns the address as a type Grand * pointer. (The GetOne() function simulates an interactive user making decisions.) A loop assigns this pointer to a type Grand * variable called pg and then uses pg to invoke the Speak() function. Because this function is virtual, the code correctly invokes the Speak() version that is appropriate to the pointed-to object:

for (int i = 0; i < 5; i++)

{

    pg = GetOne();

    pg->Speak();

    ...

}

Figure 15.4. The Grand family of classes.

You can’t use this exact approach (using a pointer-to-Grand) to invoke the Say() function; it’s not defined for the Grand class. However, you can use the dynamic_cast operator to see if pg can be type cast to a pointer to Superb. This will be true if the object is either type Superb or Magnificent. In either case, you can invoke the Say() function safely:

if (ps = dynamic_cast(pg))

    ps->Say();

Recall that the value of an assignment expression is the value of its left-hand side. Thus, the value of the if condition is ps. If the type cast succeeds, ps is nonzero, or true. If the type cast fails, which it will if pg points to a Grand object, ps is zero, or false. Listing 15.17 shows the full code. (By the way, some compilers, noting that programmers usually use the == operator in an if statement condition, may issue a warning about unintended assignment.)

Listing 15.17. rtti1.cpp

// rtti1.cpp -- using the RTTI dynamic_cast operator

#include

#include

#include

using std::cout;

class Grand

{

private:

    int hold;

public:

    Grand(int h = 0) : hold(h) {}

    virtual void Speak() const { cout << "I am a grand class!\n";}

    virtual int Value() const { return hold; }

};

class Superb : public Grand

{

public:

    Superb(int h = 0) : Grand(h) {}

    void Speak() const {cout << "I am a superb class!!\n"; }

    virtual void Say() const

        { cout << "I hold the superb value of " << Value() << "!\n";}

};

class Magnificent : public Superb

{

private:

    char ch;

public:

    Magnificent(int h = 0, char c = 'A') : Superb(h), ch(c) {}

    void Speak() const {cout << "I am a magnificent class!!!\n";}

    void Say() const {cout << "I hold the character " << ch <<

               " and the integer "  << Value() << "!\n"; }

};

Grand * GetOne();

int main()

{

    std::srand(std::time(0));

    Grand * pg;

    Superb * ps;

    for (int i = 0; i < 5; i++)

    {

        pg = GetOne();

        pg->Speak();