Todo el contenido de este artículo es de http://blog.sina.com.cn/s/blog_4b20940201013ryp.html , gracias a este autor :)
1 reinterpret_cast
'reinterpret_cast' convierte un puntero en otro tipo de puntero. También permite la conversión de un puntero a un tipo entero. viceversa. (Anotación: ¿El valor de dirección específico del puntero es un valor entero?)
Este operador puede convertir entre tipos no relacionados. El resultado de la operación es simplemente una copia binaria del valor de un puntero a otro. El contenido señalado entre tipos no realiza ninguna verificación ni conversión de tipos.
Si la situación es una copia de un puntero a un número entero, la interpretación del contenido depende del sistema, por lo que cualquier implementación no es conveniente. Un puntero convertido a un tipo de entero suficientemente grande para contenerlo se puede volver a convertir en un puntero válido.
Código:
clase A {};
clase B {};
A * a = new A;
B * b = reinterpret_cast <B *> (a);
'reinterpret_cast' trata todas las conversiones de tipo puntero como conversiones de tipo tradicional.
2 transmisión_estática
'static_cast' permite realizar cualquier conversión implícita y acciones de conversión inversa. (Incluso si no está permitido implícitamente)
Aplicado al puntero de la clase, significa que permite convertir el puntero del tipo de subclase en el puntero del tipo padre (esta es una conversión implícita válida) y, al mismo tiempo, también puede realizar la acción opuesta: convertir la clase padre en su hijo clase.
En este último ejemplo, no se comprueba la coherencia de la clase principal convertida con el tipo de destino.
Código:
clase Base {};
clase derivada: base pública {};
Base * a = new Base;
Derived * b = static_cast <Derived *> (a);
Además de manipular punteros de tipo, 'static_cast' también se puede usar para realizar conversiones explícitas definidas por tipo y conversiones estándar entre tipos básicos:
代码:
doble d = 3,14159265;
int i = static_cast <int> (d);
3 difusión_dinámica
'dynamic_cast' solo se usa para punteros y referencias de objetos. Cuando se usa en tipos polimórficos, permite conversiones de tipos implícitas arbitrarias y el proceso inverso. Sin embargo, a diferencia de static_cast, en el último caso (nota: el proceso inverso de conversión implícita), dynamic_cast comprueba si la operación es válida. Es decir, comprueba si la conversión devolverá un objeto completo válido que se solicitó.
La prueba se realiza en tiempo de ejecución. Si el puntero convertido no es un puntero de objeto válido y completo solicitado, el valor de retorno es NULL
Código:
class Base {virtual dummy () {}};
class Derived: public Base {};
Base * b1 = nuevo derivado;
Base * b2 = nueva Base;
Derived* d1 = dynamic_cast<Derived *>(b1); // succeeds
Derived* d2 = dynamic_cast<Derived *>(b2); // fails: returns 'NULL'
如果一个引用类型执行了类型转换并且这个转换是不可能的，一个bad_cast的异常类型被抛出：
代码:
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
4 const_cast
这个转换类型操纵传递对象的const属性，或者是设置或者是移除：
代码:
class C {};
const C *a = new C;
C *b = const_cast<C *>(a);
其它三种操作符是不能修改一个对象的常量性的。
注意：'const_cast'也能改变一个类型的volatile qualifier。
--------------------------------------------------------------------
C++的4种类型转换
一、C 风格（C-style）强制转型如下：
(T) expression // cast expression to be of type T
函数风格（Function-style）强制转型使用这样的语法：
T(expression) // cast expression to be of type T
这两种形式之间没有本质上的不同，它纯粹就是一个把括号放在哪的问题。我把这两种形式称为旧风格（old-style）的强制转型。
二、 C++的四种强制转型形式：
C++ 同时提供了四种新的强制转型形式（通常称为新风格的或 C++ 风格的强制转型）：
const_cast(expression)
dynamic_cast(expression)
reinterpret_cast(expression)
static_cast(expression)
每一种适用于特定的目的：
·dynamic_cast 主要用于执行“安全的向下转型（safe downcasting）”，也就是说，要确定一个对象是否是一个继承体系中的一个特定类型。它是唯一不能用旧风格语法执行的强制转型，也是唯一可能有重大运行时代价的强制转型。
·static_cast 可以被用于强制隐型转换（例如，non-const 对象转型为 const 对象，int 转型为 double，等等），它还可以用于很多这样的转换的反向转换（例如，void* 指针转型为有类型指针，基类指针转型为派生类指针），但是它不能将一个 const 对象转型为 non-const 对象（只有 const_cast 能做到），它最接近于C-style的转换。
·const_cast 一般用于强制消除对象的常量性。它是唯一能做到这一点的 C++ 风格的强制转型。
·reinterpret_cast 是特意用于底层的强制转型，导致实现依赖（implementation-dependent）（就是说，不可移植）的结果，例如，将一个指针转型为一个整数。这样的强制转型在底层代码以外应该极为罕见。
旧风格的强制转型依然合法，但是新的形式更可取。首先，在代码中它们更容易识别（无论是人还是像 grep 这样的工具都是如此），这样就简化了在代码中寻找类型系统被破坏的地方的过程。第二，更精确地指定每一个强制转型的目的，使得编译器诊断使用错误成为可能。例如，如果你试图使用一个 const_cast 以外的新风格强制转型来消除常量性，你的代码将无法编译。