1 개요 #

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;

or also

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:

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

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:

(new_type) expression
new_type (expression)

but with their own special characteristics.

[edit]

2 reinterpret_cast #

reinterpret_cast은 포인터 타입을 다른 타입의 포인터 타입으로 형변환하는데 사용합니다. 또한 포인터를 int 타입으로 형변환하는거나 그 반대도 가능합니다. 이 명령은 서로 관련이 없는 두 클래스 포인터간의 형변환을 가능하게 합니다. 실행 결과는 한 포인터에서 다른 포인터에 대한 값에 대한 간단한 이진 복사본입니다. 상호 타입간 변환중에는 어떠한 종류의 검사나 변환이 일어나지 않습니다.

포인터에서 int로 변환되는 경우에는, 번역되는 방법은 시스템에 따라 다르며, 그러므로 모든 구현이 이식가능한 것은 아닙니다. int형이 포인터값을 담기에 충분히 큰 바이트수를 가지고 있어야만 나중에 포인터 값으로 다시 형변환하는 것이 가능합니다. (일반적으로, 16비트시스템이나 몇몇 PDA, 실시간운영체계를 제외한 PC나 서버급에서는 안전합니다.)

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

reinterpret_cast은 전통적인 타입 형변환 연산자와 같이 모든 포인터에 대한 형변환을 정확하게 처리합니다.

[edit]

3 static_cast #

static_cast performs any casting that can be implicitly performed as well as the inverse cast (even if this is not allowed implicitly). 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 {};
class Derived: public Base {};
Base * a = new Base;
Derived * b = static_cast<Derived*>(a);

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:

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

[edit]

4 dynamic_cast #

dynamic_cast is exclusively used with pointers and references to objects. It allows any type-casting that can be implicitly performed as well as the inverse one when used with polymorphic classes, however, unlike static_cast, dynamic_cast checks, in this last case, if the operation is valid. That is to say, it checks if the casting is going to return a valid complete object of the requested type. 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

[edit]

5 const_cast #

This type of casting manipulates the const attribute of the passed object, either to be set or removed:

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

Neither of the other three new cast operators can modify the constness of an object.

[edit]

6 typeid #

ANSI-C++ also defines a new operator called typeid that allows checking the type of an expression:

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

ID
Password
Join

Contents

1 개요 #

2 reinterpret_cast #

3 static_cast #

4 dynamic_cast #

5 const_cast #

6 typeid #