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;or also
double d;
i = (int) d;
i = int (d);This is quite good for basic types that have standard defined conversions, however this operators can also be indiscriminately applied on classes and pointers to classes. So, it is perfectly valid to write things like:
// 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 code with not much sense since we use function result, that is a member of CAddition, without having declared an 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:
Where new_type is the destination type to which expression has to be casted. To make an easily understandable parallelism with traditional type-casting operators these expression mean:reinterpret_cast <new_type> (expression) dynamic_cast <new_type> (expression) static_cast <new_type> (expression) const_cast <new_type> (expression)
(new_type) expressionbut with their own special characteristics.
new_type (expression)
This operator can cast pointers between non-related classed. The operation results is a simple binary copy of the value from one 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 large enough to fully contain it can be casted back to a valid pointer.
class A {};reinterpret_cast treats all pointers exactly as traditional type-casting operators do.
class B {};
A * a = new A;
B * b = reinterpret_cast<B*>(a);
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 it 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 {};static_cast, aside from manipulating pointers to classes, can also be used to perform conversions explicitly defined in classes, as well as to perform standard conversions between fundamental types:
class Derived: public Base {};
Base * a = new Base;
Derived * b = static_cast<Derived*>(a);
double d=3.14159265;
int i = static_cast<int>(d);
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
class C {};Neither of the other three new cast operators can modify the constness of an object.
const C * a = new C;
C * b = const_cast<C*> (a);
typeid (expression)this operator returns a refernece to a constant object of type type_info that is defined in the standard header file <typeinfo>. This returned value can be compared with another using operators == and != or can serve to obtain a string of characters representing the data type or class name by using its name() method.
// 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; } |
a and b are of different types: a is: class CDummy * b is: class CDummy |
![]() |
© The C++ Resources Network, 2000-2003 - All rights reserved |
![]() 5-3. Exception handling. |
![]() index |
![]() 5-5. Preprocessor directives. |