C++ 四种显式类型转换
显式类型转换
reinterpret_cast<new_type>(EXPression)显式转换
const_cast<new_type>(EXPression) 显式转换
static_cast<new_type>(EXPression) 显式转换
dynamic_cast<new_type>(EXPression) 显式转换
功能: 将EXPression表达式的值转换为 new_type类型的值。
1 前三种类型的转换是在编译时期 实现转换的,
最后一个是在运行时期 进行类型转换的，而且返回转换成功与否标志，这是传统的类型转换所不具有的功能
double d=3.2;
int i= d; //隐式转换double变量d 为int 变量， i=3
假若使用C++显式类型转换 static_cast(exp)函数作以上一样的事，就可让他人知道这样的double 到 int 类型的转换，是有意这么作的，
并不是疏忽大意所致。
double d=3.2;
int i = static_cast<int>(d);//显式转换
A reinterpret_cast 类型转换函数将一个类型的指针，转换为另外一个类型的指针。这种转换不用改变指针变量值数据存放格式(不改变指针变量值),只需在编译时从新解释指针的类型就能够作到。reinterpret_cast 能够将指针转换为一个整形数(隐式转换),但不能用于非指针类型的转换，即便这样作也不会经过编译
1> 用显式的reinterpret_cast 将基本类型或一个类的指针，转换为另外一个类型或类的指针
//基本类型指针的类型转换
double d=9.3;
double* pd = &d;
int *pi = reinterpret_cast<int* >(pd); //至关于隐式转换 int* pi = (int* )pd;
2>
//不相关的类的指针的类型转换
class A{}; class B{};
A* pa = new A;
B* pb = reinterpret_cast<B* >(pa); // 至关于隐式转换 B* pb = (B*)pa;
3> 指针转换为整数
long j = reinterpret_cast<long>(pi); //至关于隐式转换 long j = (long)pi;
4> 尝试将int 类型的变量转换为double 类型，因为并不是指针类型转换，所以转换不成功.
//企图转换非指针变量
int i=8;
double dl = reinterpret_cast<double>(i); //不能编译经过
//企图转换 const 指针为 void * 指针
const int* pci - 0;
void* pv = reinterpret_cast<void* >(pci); //不能编译经过
B const_cast 类型转换函数用于去除指针变量的常量属性，将它转换为一个对应指针类型的普通变量。反过来，也能够将一个很是量的指针变量转换为一个常指针变量。这种转换是在编译期间作出的类型更改。
1> 将int 类型的常指针便利pci 转换为int 指针变量，将类A的常指针便利pca 转换为类A的普通指针变量,将类A的常指针变量pca转换为类A的普通指针变量
const int* pci = 0;
int *pj = const_cast<int* >(pci); //至关于隐式转换 int * pj = (int* )pci;
const A* pca = new A;
A *pa = const_cast<A*>(pca); //至关于隐式转换 A* pa = (A*)pca;
2> 基于安全考虑，const_cast 没法将非指针的常变量转换为普通变量
const int i = 0;
const_cast<int>(i); //去除变量i的常属性，不能编译经过
3>将普通指针变量pi 转换为常指针变量，但不能将非指针的普通变量转换为常变量。而隐式转换则容许
int * pi = 0; //至关于隐式转换 const int* pcj = (int*)pi;
const int* pcj = const_cast<const int* >(pi);
int i =0;
const int cj = const_cast<const int>(i); //非指针转换，不能编译经过
const int ck = (const int)i; // 隐式转换， 可经过编译
该运算符用来修改类型的const或volatile属性。除了const 或volatile修饰以外， type_id和expression的类型是同样的。
常量指针被转化成很是量指针，而且仍然指向原来的对象；
常量引用被转换成很是量引用，而且仍然指向原来的对象；常量对象被转换成很是量对象。
volatile和const类型，举例以下所示。
class B
{
public:
int m_iNum;
}
void foo()
{
const B b1;
b1.m_iNum = 100; //comile error
B b2 = const_cast<B>(b1);
b2. m_iNum = 200; //fine
}
上面的代码编译时会报错，由于b1是一个常量对象，不能对它进行改变；
使用const_cast把它转换成一个很是量对象，就能够对它的数据成员任意改变。注意：b1和b2是两个不一样的对象。
C static_cast 主要用于基本类型之间 和具备继承关系的类型之间的转换，这种转换通常会更改变量的内部表示方式，所以static_cast应用于指针类型转换，没有太大意义，即便容许指针类型转换，也不及reinterpret_cast解释效率高
static_cast类型转换用于相关类型之间的转换，诸如：在同一个类的继承层次关系中，向上或向下转换；枚举类型与整数类型之间的转换；浮点类型与指数类型之间的转换。在这4中类型转换中，static_cast是最接近C-style的了。html
该运算符把expression转换为type-id类型，但没有运行时类型检查来保证转换的安全性。它主要有以下几种用法：
（1）用于类层次结构中基类和派生类之间指针或引用的转换
进行上行转换（把派生类的指针或引用转换成基类表示）是安全的
进行下行转换（把基类的指针或引用转换为派生类表示），因为没有动态类型检查，因此是不安全的
（2）用于基本数据类型之间的转换，如把int转换成char。这种转换的安全也要开发人员来保证
（3）把空指针转换成目标类型的空指针
（4）把任何类型的表达式转换为void类型
注意：static_cast不能转换掉expression的const、volitale或者__unaligned属性。c++
1> // 基本类型转换
int i=0;
double d = static_cast<double>(i); //至关于隐式转换 double d =(double)i;
int j = static_cast<int>(d); //至关于隐式转换 int j = (int)d;
2> //转换继承类的对象为基类对象
class Base{};
class Derived : public Base{};
Derived d;
Base b = static_cast<Base >(d); //至关于隐式转换 Base b = (Base)d;
3> 以下将继承类与基类的指针进行相互转换，都能编译经过，但基类指针转换为继承类指针，具备必定的危害性.
// 继承类指针 转换为基类指针
Derived* pd = new Derived;
Base* pb = static_cast<Base* >(pd); //至关于隐式转换 Base* pb = (Derived*)pd;
// 基类指针转换为继承类指针
Base* pb = new Base;
Derived* pd = static_cast<Derived* >(pb); //至关于隐式转换 Derived* pd = (Dervived*)pb;
4> 如下代码尝试用static_cast 转换基本数据类型的指针，将继承类对象转换为基类对象或 转换无继承关系的类的指针，都不能编译经过.
class A{};
class B{};
int *pi = 0;
double *pd = static_cast<double* >(pi); //企图int* 转换为 double* , 不能编译经过
//
Base b;
Derived d = static_cast<Derived>(b); //企图继承类对象转换为基类对象，不能编译经过
//
A a;
B b = static_cast<B>(a); //企图转换无继承关系的类， 不能编译经过
A * pa = NULL;
B* pb = static_cast<B*>(pa); // 企图转换无继承关系的类的指针，不能编译经过
D dynamic_cast 与 静态static_cast 相对， 是动态的转换。这种转换是在运行时进行转换分析的，并不是在编译时期进行。
dynamic_cast 只能在继承类对象的指针之间 或 引用之间 进行类型转换。进行转换时，会根据当前运行对象的运行时类型信息(RTTI),判断类型对象之间的转换是否合法。dynamic_cast的指针转换失败，可经过是否为NULL指针检测； 引用转换失败，则抛出一个bad_cast异常。express
用法：dynamic_cast<type_id> (expression)
该运算符把expression转换成type_id类型的对象。type_id必须是类的指针、引用或者void*；
若是type_id是类指针类型，那么expression也必须是一个指针，若是type_id是一个引用，那么expression也必须是一个引用。
dynamic_cast主要用于类层次间的上行转换和下行转换，还能够用于类之间的交叉转换。
在类层次间进行上行转换时，dynamic_cast和static_cast的效果是同样的；
在进行下行转换时，dynamic_cast具备类型检查的功能，比static_cast更安全。安全
1> dynamic_cast 将继承类指针或引用转换为 基类指针或引用， 并对没有继承关系， 但被转换的类具备虚函数的对象指针进行转换，都可编译经过。
class Base{};
class Derived: public Base{};
//继承类指针转换为基类指针
Derived* pd = new Derived();
Base* pb = dynamic_cast<Base* >(pd);
if(!pb)
printf("dynamic_cast 类型转换失败\n");
else
printf("dynamic_cast 类型转换成功\n");
//有继承关系的引用之间转换
Derived d;
Base& b = dynamic_cast<Base& >(d);
//没有继承关系，但被转换的类有虚函数
class A {virtual ~A(){}}; // 有虚函数
class B{};
A* pa = new A;
B* pb = dynamic_cast<B* >(pa); //有虚函数的对象指针，能够转换
if(!pb)
printf("dynamic_cast 类型转换失败\n");
else
printf("dynamic_cast 类型转换成功\n");
2> 以下代码尝试将非指针的继承对象转换为 基类对象， 对无继承关系(且没有虚函数)的对象指针进行转换, 基本类型指针转换 以及基类指针转换为继承类指针，均不能编译经过
class A{}; //没有虚函数
class B{virtual ~B(){}};
//继承类转换为基类对象， 不能编译经过
Derived d;
Base b = dynamic_cast<Base>(d);
//无继承关系，且A 无虚函数， A类对象指针转换， 不能编译经过
A* pa = new A;
B* pb = dynamic_cast<B* >(pa);
// 基本类型之间转换(无继承关系)， 不能经过
int* i=0;
int j = dynamic_cast<int* >(i);
//基类指针转换为继承类指针， 不能编译经过
Base* pb = new Base;
Derived *pd = dynamic_cast<Derived* >(pb);
3> dynamic_cast 不仅是应用于类型转换，一般利用它作运行时对象类型检查的特性，在程序中检测当前内存对象的类型信息。ide
class B
{
public:
int m_iNum;
virtual void foo();
};
class D:public B
{
public:
char *m_szName[100];
};
void func(B *pb)
{
D *pd1 = static_cast<D *>(pb);
D *pd2 = dynamic_cast<D *>(pb);
}
在上面的代码段中，若是pb指向一个D类型的对象，pd1和pd2是同样的，而且对这两个指针执行D类型的任何操做都是安全的；
可是，若是pb指向的是一个B类型的对象，那么pd1将是一个指向该对象的指针，对它进行D类型的操做将是不安全的（如访问m_szName），
而pd2将是一个空指针。
另外要注意：B要有虚函数，不然会编译出错；static_cast则没有这个限制。
这是因为运行时类型检查须要运行时类型信息，而这个信息存储在类的虚函数表（
关于虚函数表的概念，详细可见<Inside c++ object model>）中，只有定义了虚函数的类才有虚函数表，
没有定义虚函数的类是没有虚函数表的。函数
另外，dynamic_cast还支持交叉转换，以下所示。
class A
{
public:
int m_iNum;
virtual void f(){}
};
class B:public A
{
};
class D:public A
{
};
void foo()
{
B *pb = new B;
pb->m_iNum = 100;
D *pd1 = static_cast<D *>(pb); //compile error
D *pd2 = dynamic_cast<D *>(pb); //pd2 is NULL
delete pb;
}
在函数foo中，使用static_cast进行转换是不被容许的，将在编译时出错，而使用dynamic_cast转换则是容许的，结果是空指针。
zongjiegoogle
在写代码中常常会有不少的隐式类型转换或显式类型转换。spa
对于隐式的类型转换主要是放生在赋值的时候，讲变量赋值给不一样类型的变量的时候就会发生类型转换，若是是宽化转换（即从占字节少的类型向占字节多的 类型转换），这个时候是不会出现丢失数据的。若是是窄化转换（从占字节多的类型向占字节少的类型转换），这个时候就颇有可能会出现丢失数据，或者数据错误 （如从有符号向无符号转换，就可能会出现各类没法想象的问题）。。。因此这种状况应该尽可能避免。.net
对于C风格显式转换，就是强制转换，可能会形成数据解释错误，也是很不安全的。指针
在C++中有四种类型转换：
static_cast <new_type> (expression) 静态转换
静态转换相似于C风格显式转换，可是会判断转换类型之间的关系，若是转换类型之间没有任何关系，则不可转换，编译器会报错。（不相关类型之间不能够发生转换）.
dynamic_cast <new_type> (expression) 动态转换
动态转换有两个约束条件：其一是要求new_type为指针或引用，其二是下行转换时要求基类是多态的（基类中包含至少一个虚函数）。
动态转换支持上行转换和下行转换，可是对于不安全的下行转换，会返回NULL，提升安全性（上行转换：子类转化为父类，下行转换：父类转化为子类）。
reinterpret_cast <new_type> (expression) 重解释转换
重解释转换则是任何两个类型之间均可以转换，是最不安全的一种类型转换，尽可能不要用。
const_cast <new_type> (expression) 常量向很是量转换
将常量转换为很是量，这个转换并不转换原常量自己，只是它返回的结果为很是量了
http://blog.csdn.net/coding_hello/article/details/2211466
http://www.xuebuyuan.com/1554696.html
http://www.2cto.com/kf/201411/353737.html
http://blog.csdn.net/thesys/article/details/5651713https://www.google.com.hk/search?q=ttp://blog.csdn.net/pongba/archive/2004/09/01/90642.aspx&ie=utf-8&oe=utf-8&gws_rd=cr&ei=tWTLVM7UJMTU8gXN5IGwBAhttp://blog.csdn.net/pongba/article/details/90642http://blog.csdn.net/pongba/article/details/2544894http://blog.csdn.net/pongba/article/list/2http://blog.csdn.net/pongba/article/list/2http://blog.csdn.net/pongba/article/list/2
- 1. [c++基础] 四种类型转换和隐式类型转换
- 2. C++中四种类型转换方式
- 3. C++四种强制类型转换
- 4. C++四种类型之间的转换
- 5. c++的四种强制类型转换
- 6. C++---四种强制类型转换
- 7. C++中四种强制类型转换
- 8. C++的四种新式显示转换和一种旧式显示转换
- 9. C++类型转换：隐式类型转换、类类型转换、显示类型转换
- 10. C++ 类型转换 ：C语言的类型转换、C++的四种强制类型转换、explicit
- 更多相关文章...
- • C# 类型转换 - C#教程
- • Swift 类型转换 - Swift 教程
- • Kotlin学习（二）基本类型
- • C# 中 foreach 遍历的用法
-
每一个你不满意的现在，都有一个你没有努力的曾经。