Section 5.4 Advanced Class Type-casting

Until now, in order to type-cast a simple object to another we have used the traditional type casting operator. For example, to cast a floating point number of type double to an integer of type int we have used:

int i;
double d;
i = (int) d;

i = int (d);

// class type-casting
#include <iostream.h>

class CDummy {
    int i;
};

class CAddition {
	int x,y;
  public:
	CAddition (int a, int b) { x=a; y=b; }
	int result() { return x+y;}
};

int main () {
  CDummy d;
  CAddition * padd;
  padd = (CAddition*) &d;
  cout << padd->result();
  return 0;
}

Although the previous program in sintactically correct in C++ (in fact it will compile with no warnings on most compilers) it is a code with not much sense since we use function result, that is a member of CAddition, without having been declared any object of that class: padd is not an object, it is only a pointer which we have assigned the address of a non related object. When accessing its result member it will produce a run-time error or, at best, just an unexpected result.

In order to control these types of conversions between classes, ANSI-C++ standard has defined four new casting operators: reinterpret_cast, static_cast, dynamic_cast and const_cast. All of them have the same format when used:

reinterpret_cast <new_type> (expression)
    dynamic_cast <new_type> (expression)
     static_cast <new_type> (expression)
      const_cast <new_type> (expression)

(new_type) expression
new_type (expression)

reinterpret_cast

This operator can cast pointers between non-related classed. The operation results is a simple binary copy of the value from a pointer to the other. The content pointed does not pass any kind of check nor transformation between types.

In the case that the copy is performed from a pointer to an integer, the interpretation of its content is system dependent and therefore any implementation is non portable. A pointer casted to an integer enough large to fully contain it can be casted back to a valid pointer.

class A {};
class B {};
A * a = new A;
B * b = reinterpret_cast<B*>(a);

static_cast

Applied to pointers to classes, that is to say that it allows to cast a pointer of a derived class to its base class (this is a valid conversion that can be implicitly performed) and can also perform the inverse: cast a base class to its derivated class.

In this last case the base class that is being casted is not checked to determine wether this is a complete class of the destination type or not.

class Base {};
class Derived: public Base {};
Base * a = new Base;
Derived * b = static_cast<Derived*>(a);

double d=3.14159265;
int i = static_cast<int>(d);

dynamic_cast

Checking is performed during run-time execution. If the pointer being casted is not a pointer to a valid complete object of the requested type, the value returned is a NULL pointer.

class Base { virtual dummy(){}; };
class Derived : public Base { };
 
Base* b1 = new Derived;
Base* b2 = new Base;
Derived* d1 = dynamic_cast<Derived*>(b1);   // succeeds
Derived* d2 = dynamic_cast<Derived*>(b2);   // fails: returns NULL

If the type-casting is performed to a reference type and this casting is not possible an exception of type bad_cast is thrown:

class Base { virtual dummy(){}; };
class Derived : public Base { };
 
Base* b1 = new Derived;
Base* b2 = new Base;
Derived d1 = dynamic_cast<Derived&*>(b1);   // succeeds
Derived d2 = dynamic_cast<Derived&*>(b2);   // fails: exception thrown

const_cast

class C {};
const C * a = new C;
C * b = const_cast<C*> (a);

typeid

typeid (expression)

// typeid, typeinfo
#include <iostream.h>
#include <typeinfo>

class CDummy { };

int main () {
  CDummy* a,b;
  if (typeid(a) != typeid(b))
  {
    cout << "a and b are of different types:\n";
    cout << "a is: " << typeid(a).name() << '\n';
    cout << "b is: " << typeid(b).name() << '\n';
  }
  return 0;
}

© The C++ Resources Network, 2000-2001 - All rights reserved

Previous: 5-3. Exception handling.

index

Next: 5-5. Preprocessor directives.