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(或子类)的互相转型。