1、 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）的强制转型。
2、 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 以外的新风格强制转型来消除常量性，你的代码将无法编译。
------------------------------------------------------------------------------------------------------------------------
以上为网上的教科书式概念，现在从一些具体用法上解释几者的区别。
1、dynamic_cast主要用于继承体系，而且是用于多态。将一个派生类的指针转化为基类的指针。其实这时是可以直接进行赋值的，不需要用此运算符。不过加上此运算符后，变的更加直接明了，便于检查。例如：
class A
{
public:
virtual ~A(){}
};
class B:public A
{
};
int main()
{
B* p = new B();
A* q = dynamic_cast<A*>(p); //其实也可以直接写成 A*q = p;
//如果反向的话，b的值为NULL。即使当两个类没有继承关系，进行dynamic转换时，也不会编译错误，但返回值会是NULL值。
A* a =new A();
B* b = dynamic_cast<B*>(a);
}
注意：如果将类A中的virtual去掉，使其没有虚函数，那么此时dynamic_cast就会产生编译错误，dynamic_cast的使用是要借助于虚表的。而虚表是虚类产生的。
2、static_cast用于大部分的类型转换。如：
1)数据类型的转换，如int转换为char，float转换为double型等等.
2)类层次结构中基类和子类之间指针或引用的转换。
A、进行上行转换（把子类的指针或引用转换成基类表示）是安全的；
B、进行下行转换（把基类指针或引用转换成子类表示）时，由于没有动态类型检查，所以是不安全的。（dynamic_cast进行下行转换时返回指针为空）。
3)当两个毫不相关的类的指针进行转换时，static_cast转换会发生编译失败。
3、const_cast用于去掉对象的常量性质，这是在c++里的唯一方法。例如:
char a = ‘a’;
const char* p = &a;
char* q = const_cast<char*>(p);
/* char *q = p; 这会发生编译错误的，因为如果这样成功的话，就可以对*q进行操作，那么就间接操作了*p，而此时*p是const型的，不能修改。所以只能通过const_cast进行强制取消常量性质。*/
*q = ‘b’;
//此时便可以对*q进行修改，同时也修改了*p，因为q和p指向的同一个地方。但是如果写成*p = ‘b’还是不允许的。
注意：
const int a =5；
int b = a;
这样写是允许，不需要用const_cast进行转换，因为b又是一个对象，对b的操作并不会影响a。如果出现了指针则要注意一下，要看const修饰的是指针，还是修饰的是指针所指的对象。例如
char* const p = &a;
char* q = p;
这样就是合法的，因为const修饰的是p指针。表示指针不会变换。char*q = p;是分配了一个新的指针q，对指针q或*q的操作并不会影响到p。
4、reinterpret_cast运算符主要是用于指针类型的转换，以及整型与指针的转换。转化的时候在底层只是简单的将内容按比特完全复制过去，然后按另一种方式进行解析。和static_cast不一样，例如static_cast将int转换为double时会将在内存中的值进行改变的，一开始是int的表示方式，后来就变成double类型在内存中的表示方式。所以如果用reinterpret_cast将int转换为double时，只是简单的位复制，然后按double型解释，那么解释出来的值完全和原值不一样了。这样是没什么意义的，也是不安全的。所以如果要进行内置变量转换，多用static_const。但是对于指针类型转换，用reinterpret_cast是合适的，因为指针在内存里面都是占四个字节，表示某个内存的地址。在指针类型转换时，并不需要指针的值进行变换（保持指向某块内存），只需让指针解释的方式发生改变即可。
举例：
int a = 83;
int* s = &a;
char* p = reinterpret_cast<char*>(s); //将整型指针转化为字符指针
int b = reinterpret_cast<int>(s); //将指针型转换为整型
float p = reinterpret_cast<float&>(a);//如果要进行内置数据类型的转换，则必须加上&符号，不知道为什么？
补充：（摘抄于参考文献3）
1、 static_cast和reinterpret_cast 的区别：
两者都可以用于指针、引用类型的转换，但static_cast主要用于“有关系（如继承关系）”的指针或引用之间的转换，多半是继承关系，而没有关系的指针之间的转换会发生编译错误。但如果是“有关系”的指针、引用类型进行转换时，我们又多采用dynamic_cast进行转换（可以进行安全性检查）。而reinterpret_cast可以用于任何指针之间的转换。前述三者都是不能取消对象的const属性，只能通过const_cast。
所以总结如下：
dynamic_cast用于有继承关系的指针或引用之间的转换。
static_cast用于基本数据类型或对象之间的转换。
reinterpret_cast用户没有关系的指针或引用之间的转换
const_cast用于去掉对象的const属性。
2、 对static_const不要望文生义，认为和const_cast是取消const一样，取消static属性。
3、 举一个例子：
#include <iostream>
using namespace std;
unsigned short Hash( void *p ) {
unsigned long val = reinterpret_cast<unsigned long>( p );
return ( unsigned short )( val ^ (val >> 16));
}
class Something
{
/* Some codes here */
};
class Otherthing
{
/* Some codes here */
};
int main() {
typedef unsigned short (*FuncPointer)( void *) ;
FuncPointer fp = Hash; //right, this is what we want
int a[10];
const int* ch = a; //right, array is just like pointer
char chArray[4] = {'a','b','c','d'};
fp = reinterpret_cast<FuncPointer> (ch); //no error, but does not make sense
ch = reinterpret_cast<int*> (chArray); //no error
cout <<hex<< *ch; //output: 64636261 //it really reinterpret the pointer
Something * st = new Something();
Otherthing * ot = reinterpret_cast<Otherthing*> (st); //cast between objects with on relationship
}
而以上转换，都是static_cast所不能完成的任务，也就是说把上边程序里所有的reinterpret_cast换成static_cast的话，就会立即得到编译错误，因为目标指针和原始指针之间不存在"关系"
从上边的程序，也就一下子看出来了reinterpret_cast和static_cast之间最本质的区别。
而以上转换，都是static_cast所不能完成的任务，也就是说把上边程序里所有的reinterpret_cast换成static_cast的话，就会立即得到编译错误，因为目标指针和原始指针之间不存在"关系"
从上边的程序，也就一下子看出来了reinterpret_cast和static_cast之间最本质的区别。
对于static_cast所需要的关系，"继承"绝对是其中之一，所以static_cast支持指向基类的指针和指向子类的指针之间的互相转换：
class Parents
{
public:
virtual ~Parents(){}
/*codes here*/
};
class Children : public Parents
{
/*codes here*/
};
int main()
{
Children * daughter = new Children();
Parents * mother = static_cast<Parents*> (daughter); //right, cast with polymorphism
Parents * father = new Parents();
Children * son = static_cast<Children*> (father); //no error, but not safe
}
但是从基类到子类的转换，用static_cast并不是安全的，具体的问题会在dynamic_cast一篇阐述。
在指针和引用方便，似乎也只有继承关系是可以被static_cast接受的，其他情况的指针和引用转换都会被static_cast直接扔出编译错误，而这层关系上的转换又几乎都可以被dynamic_cast所代替。这样看起来static_cast运算符的作用就太小了。
实际上static_cast真正用处并不在指针和引用上，而在基础类型和对象的转换上 。 而基于基础类型和对象的转换都是其他三个转换运算符所办不到的。
【参考】
1. http://www.cnblogs.com/ider/archive/2011/07/22/cpp_cast_operator_part2.html C++标准转换运算符const_cast
2. http://www.cnblogs.com/ider/archive/2011/07/30/cpp_cast_operator_part3.html C++标准转换运算符reinterpret_cast
3. http://www.cnblogs.com/ider/archive/2011/07/31/cpp_cast_operator_part4.html C++标准转换运算符static_cast
4. http://www.cnblogs.com/ider/archive/2011/08/01/cpp_cast_operator_part5.html C++标准转换运算符dynamic_cast
5. http://blog.csdn.net/wingfiring/article/details/633033 dynamic_cast详解
扫一扫
265
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
