c++ –> c++中四种类型转换方式

c++中四种类型转换方式c风格转换的格式很简单（TYPE）EXPRESSION，但是c风格的类型转换有不少缺点，1)它可以在任意类型之间转换，比如你可以把一个指向const对象的指针转换成指向非const对象的指针，把一个指向基类对象的指针转换成指向一个派生类对象的指针，这两种转换之间的差别是巨大的，但是传统的c语言风格的类型转换没有区分这些。2)c风格的转换不容易查找，它由一个括号加上一个标识符组成，而这样的东西在c++程序里一大堆。所以c++为了克服这些缺点，引进了新的类型转换操作符，分别是static_cast、const_cast、dynamic_cast、reinterpret_cast。从功能强弱上排个序，从强到弱应该是：reinterpret_cast，旧式转换，static_cast，dynamic_cast。一、static_cast

用法：static_cast < type-id > ( exdivssion )

该运算符把exdivssion转换为type-id类型，但没有运行时类型检查来保证转换的安全性。它主要有如下几种用法：1）用于类层次结构中基类和子类之间指针或引用的转换。a. 进行上行转换（把子类的指针或引用转换成基类表示）是安全的；b. 进行下行转换（把基类指针或引用转换成子类表示）时，由于没有动态类型检查，所以是不安全的。2）用于基本数据类型之间的转换，如把int转换成char，把int转换成enum。这种转换的安全性也要开发人员来保证。3）把空指针转换成目标类型的空指针。4）把任何类型的表达式转换成void类型。注意：static_cast不能转换掉exdivssion的const、volitale、或者__unaligned属性。二、 dynamic_cast

用法：dynamic_cast < type-id > ( exdivssion )

该运算符把exdivssion转换成type-id类型的对象。Type-id必须是类的指针、类的引用或者void *；1) 如果type-id是类指针类型，那么exdivssion也必须是一个指针，如果type-id是一个引用，那么exdivssion也必须是一个引用。2) dynamic_cast主要用于类层次间的上行转换和下行转换，还可以用于类之间的交叉转换。3）在类层次间进行上行转换时，dynamic_cast和static_cast的效果是一样的；4）在进行下行转换时，dynamic_cast具有类型检查的功能，比static_cast更安全。

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(pb);
　　D *pd2 = dynamic_cast(pb);
}

在上面的代码段中，如果pb指向一个D类型的对象，pd1和pd2是一样的，并且对这两个指针执行D类型的任何操作都是安全的；但如果pb指向的是一个B类型的对象，那么pd1将是一个指向该对象的指针，对它进行D类型的操作将是不安全的（如访问m_szName），而pd2将是一个空指针。另外要注意：B要有虚函数，否则会编译出错；static_cast则没有这个限制。这是由于运行时类型检查需要运行时类型信息，而这个信息存储在类的虚函数表（关于虚函数表的概念，详细可见）中，只有定义了虚函数的类才有虚函数表，没有定义虚函数的类是没有虚函数表的。另外，dynamic_cast还支持交叉转换（cross 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(pb); //compile error
　　D *pd2 = dynamic_cast(pb); //pd2 is NULL
　　delete pb;
}

在函数foo中，使用static_cast进行转换是不被允许的，将在编译时出错；而使用 dynamic_cast的转换则是允许的，结果是空指针。三、reinterpret_cast

用法：reinterpret_cast < type-id > ( exdivssion )

reinterpret_cast主要是将数据从一种类型的转换为另一种类型。所谓“通常为操作数的位模式提供较低层的重新解释”也就是说将数据以二进制存在形式的重新解释。1) type-id必须是一个指针、引用、算术类型、函数指针或者成员指针。2) 它可以把一个指针转换成一个整数，也可以把一个整数转换成一个指针。

int i;
char *p = "This is a example.";
i = reinterpret_cast<int>(p);

此时结果，i与p的值是完全相同的。reinterpret_cast的作用是说将指针p的值以二进制（位模式）的方式被解释为整型，并赋给i，一个明显的现象是在转换前后没有数位损失。
四、const_cast

用法：const_cast < type-id > ( exdivssion )

该运算符用来修改类型的const或volatile属性。简单的说，其作用就是将一个类的const、volatile以及__unaligned属性去掉。除了const 或volatile修饰之外， type_id和exdivssion的类型是一样的。1）常量指针被转化成非常量指针，并且仍然指向原来的对象；2）常量引用被转换成非常量引用，并且仍然指向原来的对象；3）常量对象被转换成非常量对象。Voiatile和const类试。举如下一例：

class B{
public:
　　int m_iNum;
}
void foo(){
　　const B b1;
　　b1.m_iNum = 100; //comile error
　　B b2 = const_cast(b1);
　　b2. m_iNum = 200; //fine
}

上面的代码编译时会报错，因为b1是一个常量对象，不能对它进行改变；使用const_cast把它转换成一个常量对象，就可以对它的数据成员任意改变。注意：b1和b2是两个不同的对象。五、类型比较static_cast：强制类型转换cast。因此，当然可以用于有继承关系的类之间的cast，细分有三类：upcast：Just same as dynamic_cast. 由于不用做runtime类型检查，效率比dynamic_cast高；downcast：不安全，不建议使用。crosscast：不能用，带来编译错误。dynamic_cast：有继承关系的类之间的cast。非常安全，但是由于需要做runtime类型检查，并且需要virtual table的支持，效率低些。细分三类：upcast：ok。static_cast就完全够了。downcast：必须用它。这样，当做不正确的downcast时才能得到NULL指针，而不会像static_cast那样得到一个可以用的其实是没有用的非空指针。crosscast：只能用它才能实现。

六、dynamic_cast举例

1）如果type-id是expression的直接或间接基类指针，结果将是指向该expression实体的type-id类型指针。这称作"upcast"。比如：

class B {...}; 
class C : public B {...}; 
class D : public C {...}; 

void f (D *pD) 
{ 
　　C* pc = dynamic_cast<C*>(pD); // ok 
　　B* pb = dynamic_cast<B*>(pD); // ok 
}

2）如果type-id是void *，那么运行时将检查expression的实际类型。其结果是指向expression完整实体的一个指针。如：

class A { ... };
class B { ... };

void f() 
{ 
　　A* pa = new A; 
　　B* pb = new B; 
　　void* pv = dynamic_cast<void*>(pa); 
　　// pv指向A一个对象 
　　... 
　　pv = dynamic_cast<void*>(pb); 
　　// pv 指向 B的一个对象 
}

3）如果type-id不是void *，将在运行时检查expression对象是否可以被转型为type-id。

a.如果expression是type-id的一个基类，那么将在运行时检查expression是否指向type-id一个完整对象。如果是，结果就是该对象的指针;否则出错。如：

class B {...}; 
class D : public B {...}; 
void f() 
{ 
　　B *pB = new D; 
　　B *pB2 = new B; 

　　D *pD = dynamic_cast<D*> (pB); // ok. 
　　D *pD2 = dynamic_cast<D*> (pB2) // error. 
}

上面称作"downcast"

*b.*如果是多重继承，比如：

class A {...}; 
class B : public A {...}; // B继承自A 
class C : public A {...}; // C继承自A 
class D : public B, public C {...}; // D继承自B, C 
//此时指向D的指针可以安全的cast为B或者C(见上)，不过如果将其cast到A该怎么办呢？这样吗？ 
D *pD = new D; 
A *pA = dynamic_cast <A*> (pD); //error.不知道指向哪个A. 
//这时我们可以先转型为B(或C)，然后间接批向A。如下
B *pB = dynamic_cast <B*> (pD); 
A *pA = dynamic_cast <A*> (pB); // ok

*c.*虚拟继承的情况

class A {...} // 以后就直接简写作class name了 
class B : vitual public A; 
class C : public B; 
class D : public B; 
class E : publc C, public D;

如果E的实体或者A的子对象想要转型为B将会是失败的(原因见上)，这时你需要先转型为一个完整的E对象，然后逐层进行明确的转型操作。d.

class A; 
class B : public A; 
class C : public A; 
class D; 
class E : public B, public C, publc D;

假如E的一个对象和D子对象的一个指针，想要从D的子对象中得到A的子对象，需要三个转换。先将D类型的指针转型为E型的一个指针，然后再逐层转型到A。如 :

void f (D *pD) 
{ 
E *pE = dynamic_cast <E*> (pD); 
B *pB = dynamic_cast <B*> (pE); 
// 或者 B *pB = pe; 
A *pA = dynamic_cast <A*> (pB); 
// or A *pA = pB; 
}

*e.* (十字)交叉转换(cross cast)。如上例中从B(或子类)与D(或子类)的互相转型。
原文链接: https://www.cnblogs.com/jeakeven/p/5365550.html

欢迎关注

微信关注下方公众号，第一时间获取干货硬货；公众号内回复【pdf】免费获取数百本计算机经典书籍