【转】C++的四种cast操作符的区别类型转换

看程序中又遇到了c&＃43;&＃43;的类型之间转换的问题&＃xff0c;重新又温习了下&＃xff0c;转自 http://welfare.cnblogs.com/articles/336091.html

----------------------------------------------------------------------

Q: 什么是C风格转换&＃xff1f;什么是static_cast, dynamic_cast 以及 reinterpret_cast&＃xff1f;区别是什么&＃xff1f;为什么要注意&＃xff1f;

A: 转换的含义是通过改变一个变量的类型为别的类型从而改变该变量的表示方式。为了类型转换一个简单对象为另一个对象你会使用传统的类型转换操作符。比如&＃xff0c;为 了转换一个类型为doubole的浮点数的指针到整型&＃xff1a;
代码:
int i;
double d;

i &＃61; (int) d;
或者&＃xff1a;

i &＃61; int (d);

对于具有标准定义转换的简单类型而言工作的很好。然而&＃xff0c;这样的 转换符也能不分皂白的应用于类&＃xff08;class&＃xff09;和类的指针。ANSI-C&＃43;&＃43;标准定义了四个新的转换符&＃xff1a;&＃39;reinterpret_cast&＃39;, &＃39;static_cast&＃39;, &＃39;dynamic_cast&＃39; 和 &＃39;const_cast&＃39;&＃xff0c;目的在于控制类(class)之间的类型转换。
代 码:
reinterpret_cast(expression)
dynamic_cast(expression)
static_cast(expression)
const_cast(expression)


1 reinterpret_cast

&＃39;reinterpret_cast&＃39;转换一个指针为其它类型的指针。它也允许从一个指针转换为整数 类型。反之亦然。&＃xff08;译注&＃xff1a;是指针具体的地址值作为整数值&＃xff1f;&＃xff09;
这个操作符能够在非相关的类型之间转换。操作结果只是简单的从一个指针到别的指针的值 的二进制拷贝。在类型之间指向的内容不做任何类型的检查和转换。

如果情况是从一个指针到整型的拷贝&＃xff0c;内容的解释是系统相关的&＃xff0c;所以任何的 实现都不是方便的。一个转换到足够大的整型能够包含它的指针是能够转换回有效的指针的。

代码:
class A {};
class B {};

A * a &＃61; new A;
B * b &＃61; reinterpret_cast(a);
&＃39;reinterpret_cast&＃39; 就像传统的类型转换一样对待所有指针的类型转换。

2 static_cast

&＃39;static_cast&＃39;允许执行任意的 隐式转换和相反转换动作。&＃xff08;即使它是不允许隐式的&＃xff09;

应用到类的指针上&＃xff0c;意思是说它允许子类类型的指针转换为父类类型的指针&＃xff08;这是一个有效 的隐式转换&＃xff09;&＃xff0c;同时&＃xff0c;也能够执行相反动作&＃xff1a;转换父类为它的子类。

在这最后例子里&＃xff0c;被转换的父类没有被检查是否与目的类型相一致。
代 码&＃xff1a;
class Base {};
class Derived : public Base {};

Base *a    &＃61; new Base;
Derived *b &＃61; static_cast(a);
&＃39;static_cast&＃39; 除了操作类型指针&＃xff0c;也能用于执行类型定义的显式的转换&＃xff0c;以及基础类型之间的标准转换:

代码:
double d &＃61; 3.14159265;
int    i &＃61; static_cast(d);

3 dynamic_cast

&＃39;dynamic_cast&＃39;只用于对象的指针和引用。当用于多态类型时&＃xff0c;它允许任意的隐式类型转换以及相反过 程。不过&＃xff0c;与static_cast不同&＃xff0c;在后一种情况里&＃xff08;注&＃xff1a;即隐式转换的相反过程&＃xff09;&＃xff0c;dynamic_cast会检查操作是否有效。也就是说&＃xff0c;它会检 查转换是否会返回一个被请求的有效的完整对象。
检测在运行时进行。如果被转换的指针不是一个被请求的有效完整的对象指针&＃xff0c;返回值为NULL.
代 码&＃xff1a;
class Base { virtual dummy() {} };
class Derived : public Base {};

Base* b1 &＃61; new Derived;
Base* b2 &＃61; new Base;

Derived* d1 &＃61; dynamic_cast(b1);          // succeeds
Derived* d2 &＃61; dynamic_cast(b2);          // fails: returns &＃39;NULL&＃39;

如果一个引用类型执行了类型转换并且这个转换是不可能的&＃xff0c;一个bad_cast的异常类型被抛出&＃xff1a;
代码:
class Base { virtual dummy() {} };
class Derived : public Base { };

Base* b1 &＃61; new Derived;
Base* b2 &＃61; new Base;

Derived d1 &＃61; dynamic_cast(b1);          // succeeds
Derived d2 &＃61; dynamic_cast(b2);          // fails: exception thrown

4 const_cast

这个转换类型操纵传递对象的const属性&＃xff0c;或者是设置或者 是移除&＃xff1a;
代码:
class C {};

const C *a &＃61; new C;

C *b &＃61; const_cast(a);
其它三种操作符是不能修改一个对象的常量性的。
注意&＃xff1a;&＃39;const_cast&＃39;也能 改变一个类型的volatile qualifier。

--------------------------------------------------------------------

C&＃43;&＃43; 的4种类型转换

    一、C 风格&＃xff08;C-style&＃xff09;强制转型如下&＃xff1a;

    (T) expression // cast expression to be of type T
    函数风格&＃xff08;Function-style&＃xff09;强制转型使用这样的语法&＃xff1a;
    T(expression) // cast expression to be of type T
    这两种形式之间没有本质上的不同&＃xff0c;它纯粹就是一个把括号放在哪的问题。我把这两种形式称为旧风格&＃xff08;old-style&＃xff09;的强制转型。

   二、 C&＃43;&＃43;的四种强制转型形式&＃xff1a;

　　C&＃43;&＃43; 同时提供了四种新的强制转型形式&＃xff08;通常称为新风格的或 C&＃43;&＃43; 风格的强制转型&＃xff09;&＃xff1a;
　 　const_cast(expression)
　　dynamic_cast(expression)
　　 reinterpret_cast(expression)
　　static_cast(expression)

　　每一种 适用于特定的目的&＃xff1a;

　　·dynamic_cast 主要用于执行“安全的向下转型&＃xff08;safe downcasting&＃xff09;”&＃xff0c;也就是说&＃xff0c;要确定一个对象是否是一个继承体系中的一个特定类型。它是唯一不能用旧风格语法执行的强制转型&＃xff0c;也是唯一可能有重 大运行时代价的强制转型。
    
    ·static_cast 可以被用于强制隐型转换&＃xff08;例如&＃xff0c;non-const 对象转型为 const 对象&＃xff0c;int 转型为 double&＃xff0c;等等&＃xff09;&＃xff0c;它还可以用于很多这样的转换的反向转换&＃xff08;例如&＃xff0c;void* 指针转型为有类型指针&＃xff0c;基类指针转型为派生类指针&＃xff09;&＃xff0c;但是它不能将一个 const 对象转型为 non-const 对象&＃xff08;只有 const_cast 能做到&＃xff09;&＃xff0c;它最接近于C-style的转换。
    
　　·const_cast 一般用于强制消除对象的常量性。它是唯一能做到这一点的 C&＃43;&＃43; 风格的强制转型。

　　·reinterpret_cast 是特意用于底层的强制转型&＃xff0c;导致实现依赖&＃xff08;implementation-dependent&＃xff09;&＃xff08;就是说&＃xff0c;不可移植&＃xff09;的结果&＃xff0c;例如&＃xff0c;将一个指针转型为一个 整数。这样的强制转型在底层代码以外应该极为罕见。
　　
　　旧风格的强制转型依然合法&＃xff0c;但是新的形式更可取。首先&＃xff0c;在代码中它们更容易识 别&＃xff08;无论是人还是像 grep 这样的工具都是如此&＃xff09;&＃xff0c;这样就简化了在代码中寻找类型系统被破坏的地方的过程。第二&＃xff0c;更精确地指定每一个强制转型的目的&＃xff0c;使得编译器诊断使用错误成为可 能。例如&＃xff0c;如果你试图使用一个 const_cast 以外的新风格强制转型来消除常量性&＃xff0c;你的代码将无法编译。

&＃61;&＃61;  
&＃61;&＃61;  dynamic_cast .vs. static_cast
&＃61;&＃61;

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

void f(B* pb)
{
   D* pd1 &＃61; dynamic_cast(pb);
   D* pd2 &＃61; static_cast(pb);
}

If pb really points to an object of type D, then pd1 and pd2 will get the same value. They will also get the same value if pb &＃61;&＃61; 0.

If pb points to an object of type B and not to the complete D class, then dynamic_cast will know enough to return zero. However, static_cast relies on the programmer’s assertion that pb points to an object of type D and simply returns a pointer to that supposed D object.

    即dynamic_cast可用于继承体系中的向下转型&＃xff0c;即将基类指针转换为派生类指针&＃xff0c;比static_cast更严格更安全。 dynamic_cast在执行效率上比static_cast要差一些,但static_cast在更宽上范围内可以完成映射,这种不加限制的映射伴随 着不安全性.static_cast覆盖的变换类型除类层次的静态导航以外,还包括无映射变换,窄化变换(这种变换会导致对象切片,丢失信息),用 VOID*的强制变换,隐式类型变换等...


&＃61;&＃61;
&＃61;&＃61;  static_cast .vs. reinterpret_cast
&＃61;&＃61;

    reinterpret_cast是为了映射到一个完全不同类型的意思,这个关键词在我们需要把类型映射回原有类型时用到它.我们映射到的类型仅仅是为 了故弄玄虚和其他目的,这是所有映射中最危险的.(这句话是C&＃43;&＃43;编程思想中的原话)

    static_cast 和 reinterpret_cast 操作符修改了操作数类型. 它们不是互逆的; static_cast 在编译时使用类型信息执行转换, 在转换执行必要的检测(诸如指针越界计算, 类型检查). 其操作数相对是安全的. 另一方面, reinterpret_cast 仅仅是重新解释了给出的对象的比特模型而没有进行二进制转换, 例子如下:

    int n&＃61;9; double d&＃61;static_cast (n);

    上面的例子中, 我们将一个变量从 int 转换到 double. 这些类型的二进制表达式是不同的. 要将整数 9 转换到 双精度整数 9, static_cast 需要正确地为双精度整数 d 补足比特位. 其结果为 9.0. 而reinterpret_cast 的行为却不同:

    int n&＃61;9;
    double d&＃61;reinterpret_cast (n);

    这次, 结果有所不同. 在进行计算以后, d 包含无用值. 这是因为 reinterpret_cast 仅仅是复制 n 的比特位到 d, 没有进行必要的分析.