各种cast

隐式转换(implicit conversion)

short a=2000;

int b;

b=a;

short是两字节,int是四字节,由short型转成int型是宽化转换(bit位数增多),编译器没有warning,如下图所示。宽化转换(如char到int,int到long long,int到float,float到double,int到double等)构成隐式转换,编译器允许直接转换。

但若反过来

double a=2000;

short b;

b=a;

此时,是从8字节的double型转成2字节的short型变量,是窄化转换,编译器就会有warning了,如下所示,提醒程序员可能丢失数据。不过需要注意的是,有些隐式转换,编译器可能并不给出warning,比如int到short,但数据溢出却依然会发生。

 

C风格显式转换(C style explicit conversion)

 

要去掉上述waring很简单,熟悉C语言的程序员知道,有两种简单的写法(C风格转换与函数风格转换):

double a=2000.3;

short b;

b = (short) a;    // c-like cast notation

b = short (a);    // functional notation 

如下图所示,此时warning就没了

这种显式转换方式简单直观,但并不安全,举一个父类和子类的例子如下:

复制代码
 1 // class type-casting
 2 #include <iostream>
 3 using namespace std;
 4 
 5 class CDummy {
 6 float i,j;
 7 CDummy():i(100),j(10){}
 8 };
 9 
10 class CAddition:public CDummy
11 {
12     int *x,y;
13   public:
14     CAddition (int a, int b) { x=&a; y=b; }
15     int result() { return *x+y;}
16 };
17 
18 int main () {
19   CDummy d;
20   CAddition * padd;
21   padd = (CAddition*) &d;
22   cout << padd->result();
23   return 0;
24 }
复制代码

编译器不报任何错,但运行结果出错,如下图所示:

究其原因,注意这一句:padd = (CAddition*) &d;

此时父类的指针&d被C风格转换方式强制转成了子类的指针了,后面调用了子类的方法result,需要访问*x,但指针指向的对象本质还是父类的,所以x相当于父类中的i,y相当于父类中的j,*x相当于*i,但i是float型变量(初始化为100),不是地址,所以出错,如果程序员正是鲁莽地对这个地址指向的内存进行写入操作,那将可能会破坏系统程序,导致操作系统崩溃!

这里有一个重要概念,CAddition*是子类的指针,它的变量padd可以调用子类的方法,但是它指向的是父类的对象,也就是说padd指向的内存空间里存放的是父类的成员变量。深入地说,数据在内存中是没有“类型”一说的,比如0x3F可能是字符型,也可能是整型的一部分,还可能是地址的一部分。我们定义的变量类型,其实就是定义了数据应该“被看成什么”的方式。

因此padd类指针实质是定义了取值的方式,如padd->x就是一并取出内存空间里的0号单元至3号单元的值(共4个字节),将其拼成32位并当作指针,padd->y则取出内存空间里的4号单元至7号单元(共4个字节),将其拼成32位并当作int型变量。但实际上padd指向的是父类的对象,也就是前4个字节是float型变量,后4个字节也是float型变量。

从这里可以看出,程序员的这种转换使编译器“理解”出错,把牛当成马了。

从上可见,用C风格的转换其实是不安全的,编译器无法看到转换的不安全。

 

上行转换(up-casting)与下行转换(down-casting)

 

看到这个,读者可能会问,哪些转换不安全?根据前面所举的例子,可以看到,不安全来源于两个方面:其一是类型的窄化转化,会导致数据位数的丢失;其二是在类继承链中,将父类对象的地址(指针)强制转化成子类的地址(指针),这就是所谓的下行转换。“下”表示沿着继承链向下走(向子类的方向走)。

类似地,上行转换的“上”表示沿继承链向上走(向父类的方向走)。

我们给出结论,上行转换一般是安全的,下行转换很可能是不安全的。

为什么呢?因为子类中包含父类,所以上行转换(只能调用父类的方法,引用父类的成员变量)一般是安全的。但父类中却没有子类的任何信息,而下行转换会调用到子类的方法、引用子类的成员变量,这些父类都没有,所以很容易“指鹿为马”或者干脆指向不存在的内存空间。

值得一说的是,不安全的转换不一定会导致程序出错,比如一些窄化转换在很多场合都会被频繁地使用,前提是程序员足够小心以防止数据溢出;下行转换关键看其“本质”是什么,比如一个父类指针指向子类,再将这个父类指针转成子类指针,这种下行转换就不会有问题。

 

针对类指针的问题,C++特别设计了更加细致的转换方法,分别有:

static_cast <new_type> (expression)
dynamic_cast <new_type> (expression)
reinterpret_cast <new_type> (expression)
const_cast <new_type> (expression)

可以提升转换的安全性。

 

static_cast <new_type> (expression) 静态转换

 

静态转换是最接近于C风格转换,很多时候都需要程序员自身去判断转换是否安全。比如:

double d=3.14159265;

int i = static_cast<int>(d);

 

但static_cast已经有安全性的考虑了,比如对于不相关类指针之间的转换。参见下面的例子:

复制代码
 1 // class type-casting
 2 #include <iostream>
 3 using namespace std;
 4 
 5 class CDummy {
 6     float i,j;
 7 };
 8 
 9 class CAddition {
10     int x,y;
11   public:
12     CAddition (int a, int b) { x=a; y=b; }
13     int result() { return x+y;}
14 };
15 
16 int main () {
17   CDummy d;
18   CAddition * padd;
19   padd = (CAddition*) &d;
20   cout << padd->result();
21   return 0;
22 }
复制代码

这个例子与之前举的例子很像,只是CAddition与CDummy类没有任何关系了,但main()中C风格的转换仍是允许的padd = (CAddition*) &d,这样的转换没有安全性可言。

 

如果在main()中使用static_cast,像这样:

复制代码
1  int main () {
2    CDummy d;
3    CAddition * padd;
4    padd = static_cast<CAddition*> (&d);
5    cout << padd->result();
6    return 0;
7 }
复制代码

 

编译器就能看到这种不相关类指针转换的不安全,报出如下图所示的错误:

注意这时不是以warning形式给出的,而直接是不可通过编译的error。从提示信息里可以看到,编译器说如果需要这种强制转换,要使用reinterpret_cast(稍候会说)或者C风格的两种转换。

总结一下:static_cast最接近于C风格转换了,但在无关类的类指针之间转换上,有安全性的提升。

 

dynamic_cast <new_type> (expression) 动态转换

 

动态转换确保类指针的转换是合适完整的,它有两个重要的约束条件,其一是要求new_type为指针或引用,其二是下行转换时要求基类是多态的(基类中包含至少一个虚函数)。

看一下下面的例子:

复制代码
 1 #include <iostream>
 2 using namespace std;
 3 class CBase { };
 4 class CDerived: public CBase { };
 5 
 6 int main()
 7 {
 8 CBase b; CBase* pb;
 9 CDerived d; CDerived* pd;
10 
11 pb = dynamic_cast<CBase*>(&d);     // ok: derived-to-base
12 pd = dynamic_cast<CDerived*>(&b);  // wrong: base-to-derived 
13 }
复制代码

在最后一行代码有问题,编译器给的错误提示如下图所示:

把类的定义改成:

class CBase { virtual void dummy() {} };

class CDerived: public CBase {};

再编译,结果如下图所示:

编译都可以顺利通过了。这里我们在main函数的最后添加两句话:

cout << pb << endl;

cout << pd << endl;

输出pb和pd的指针值,结果如下:

我们看到一个奇怪的现象,将父类经过dynamic_cast转成子类的指针竟然是空指针!这正是dynamic_cast提升安全性的功能,dynamic_cast可以识别出不安全的下行转换,但并不抛出异常,而是将转换的结果设置成null(空指针)。

再举一个例子:

复制代码
 1 #include <iostream>
 2 #include <exception>
 3 using namespace std;
 4 
 5 class CBase { virtual void dummy() {} };
 6 class CDerived: public CBase { int a; };
 7 
 8 int main () {
 9   try {
10     CBase * pba = new CDerived;
11     CBase * pbb = new CBase;
12     CDerived * pd;
13 
14     pd = dynamic_cast<CDerived*>(pba);
15     if (pd==0) cout << "Null pointer on first type-cast" << endl;
16 
17     pd = dynamic_cast<CDerived*>(pbb);
18     if (pd==0) cout << "Null pointer on second type-cast" << endl;
19 
20   } catch (exception& e) {cout << "Exception: " << e.what();}
21   return 0;
22 }
复制代码

输出结果是:Null pointer on second type-cast

两个dynamic_cast都是下行转换,第一个转换是安全的,因为指向对象的本质是子类,转换的结果使子类指针指向子类,天经地义;第二个转换是不安全的,因为指向对象的本质是父类,“指鹿为马”或指向不存在的空间很可能发生!

最后补充一个特殊情况,当待转换指针是void*或者转换目标指针是void*时,dynamic_cast总是认为是安全的,举个例子:

复制代码
 1 #include <iostream>
 2 using namespace std;
 3 class A {virtual void f(){}};
 4 class B {virtual void f(){}};
 5 
 6 int main() {
 7     A* pa = new A;
 8     B* pb = new B;
 9     void* pv = dynamic_cast<void*>(pa);
10     cout << pv << endl;
11     // pv now points to an object of type A
12 
13     pv = dynamic_cast<void*>(pb);
14     cout << pv << endl;
15     // pv now points to an object of type B
16 }
复制代码

运行结果如下:

可见dynamic_cast认为空指针的转换安全的,但这里类A和类B必须是多态的,包含虚函数,若不是,则会编译报错。

 

reinterpret_cast <new_type> (expression) 重解释转换

 

这个转换是最“不安全”的,两个没有任何关系的类指针之间转换都可以用这个转换实现,举个例子:

class A {};

class B {};

A * a = new A;

B * b = reinterpret_cast<B*>(a);//correct!

更厉害的是,reinterpret_cast可以把整型数转换成地址(指针),这种转换在系统底层的操作,有极强的平台依赖性,移植性不好。

它同样要求new_type是指针或引用,下面的例子是通不过编译的:

double a=2000.3;

short b;

b = reinterpret_cast<short> (a); //compile error!

 

const_cast <new_type> (expression) 常量向非常量转换

这个转换好理解,可以将常量转成非常量。

复制代码
 1 // const_cast
 2 #include <iostream>
 3 using namespace std;
 4 
 5 void print (char * str)
 6 {
 7   cout << str << endl;
 8 }
 9 
10 int main () {
11   const char * c = "sample text";
12   char *cc = const_cast<char *> (c) ;
13   Print(cc);
14   return 0;
15 }
复制代码

char *cc = const_cast<char *>(c)可以看出了这个转换的作用了,但切记,这个转换并不转换原常量本身,即c还是常量,只是它返回的结果cc是非常量了

 

 

总结

C风格转换是“万能的转换”,但需要程序员把握转换的安全性,编译器无能为力;static_cast最接近于C风格转换,但在无关类指针转换时,编译器会报错,提升了安全性;dynamic_cast要求转换类型必须是指针或引用,且在下行转换时要求基类是多态的,如果发现下行转换不安全,dynamic_cast返回一个null指针,dynamic_cast总是认为void*之间的转换是安全的;reinterpret_cast可以对无关类指针进行转换,甚至可以直接将整型值转成指针,这种转换是底层的,有较强的平台依赖性,可移植性差;const_cast可以将常量转成非常量,但不会破坏原常量的const属性,只是返回一个去掉const的变量。

注:本文中大部分样例来源自C++标准网站:

http://www.cplusplus.com/doc/tutorial/typecasting/ 

以及微软的MSDN:

http://msdn.microsoft.com/en-us/library/cby9kycs

若有理解出错的地方,望不吝指正。

posted on 2014-08-13 21:06 berkeleysong 阅读(...) 评论(...)  编辑 收藏

导航

公告