C++ 中四种cast比较(转载)

向右看齐 2022-09-21 15:20 104阅读 0赞

转载：http://www.cppblog.com/chaosuper85/archive/2009/08/07/92563.html

Q:什么是C风格转换？什么是static\_cast, dynamic\_cast 以及

reinterpret\_cast？区别是什么？为什么要注意？

A:转换的含义是通过改变一个变量的类型为别的类型从而改变该变量的表示方式

。为了类型转换一个简单对象为另一个对象你会使用传统的类型转换操作符。比

如，为了转换一个类型为doubole的浮点数的指针到整型：  
代码:  
int i;  
double d;

i = (int) d;  
或者：

i = int (d);

对于具有标准定义转换的简单类型而言工作的很好。然而，这样的转换符也能不

分皂白的应用于类（class）和类的指针。ANSI-C++标准定义了四个新的转换符：

'reinterpret\_cast', 'static\_cast', 'dynamic\_cast' 和 'const\_cast'，目的

在于控制类(class)之间的类型转换。  
代码:  
reinterpret\_cast<new\_type>(expression)  
dynamic\_cast<new\_type>(expression)  
static\_cast<new\_type>(expression)  
const\_cast<new\_type>(expression)

1 reinterpret\_cast

'reinterpret\_cast'转换一个指针为其它类型的指针。它也允许从一个指针转换

为整数类型。反之亦然。（译注：是指针具体的地址值作为整数值？）  
这个操作符能够在非相关的类型之间转换。操作结果只是简单的从一个指针到别

的指针的值的二进制拷贝。在类型之间指向的内容不做任何类型的检查和转换。

如果情况是从一个指针到整型的拷贝，内容的解释是系统相关的，所以任何的实

现都不是方便的。一个转换到足够大的整型能够包含它的指针是能够转换回有效

的指针的。

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

A \* a = new A;  
B \* b = reinterpret\_cast<B \*>(a);  
'reinterpret\_cast'就像传统的类型转换一样对待所有指针的类型转换。

2 static\_cast

'static\_cast'允许执行任意的隐式转换和相反转换动作。（即使它是不允许隐式

的）

应用到类的指针上，意思是说它允许子类类型的指针转换为父类类型的指针（这

是一个有效的隐式转换），同时，也能够执行相反动作：转换父类为它的子类。

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

Base \*a    = new Base;  
Derived \*b = static\_cast<Derived \*>(a);  
'static\_cast'除了操作类型指针，也能用于执行类型定义的显式的转换，以及基

础类型之间的标准转换:

代码:  
double d = 3.14159265;  
int    i = static\_cast<int>(d);

3 dynamic\_cast

'dynamic\_cast'只用于对象的指针和引用。当用于多态类型时，它允许任意的隐

式类型转换以及相反过程。不过，与static\_cast不同，在后一种情况里（注：即

隐式转换的相反过程），dynamic\_cast会检查操作是否有效。也就是说，它会检

查转换是否会返回一个被请求的有效的完整对象。  
检测在运行时进行。如果被转换的指针不是一个被请求的有效完整的对象指针，

返回值为NULL.  
代码：  
class Base \{ virtual dummy() \{\} \};  
class Derived : public Base \{\};

Base\* b1 = new Derived;  
Base\* b2 = new Base;

Derived\* d1 = dynamic\_cast<Derived \*>(b1);          // succeeds  
Derived\* d2 = dynamic\_cast<Derived \*>(b2);          // fails: returns

'NULL'

如果一个引用类型执行了类型转换并且这个转换是不可能的，一个bad\_cast的异

常类型被抛出：  
代码:  
class Base \{ virtual dummy() \{\} \};  
class Derived : public Base \{ \};

Base\* b1 = new Derived;  
Base\* b2 = new Base;

Derived d1 = dynamic\_cast<Derived &\*>(b1);          // succeeds  
Derived d2 = dynamic\_cast<Derived &\*>(b2);          // fails: exception

thrown

4 const\_cast

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

const C \*a = new C;

C \*b = const\_cast<C \*>(a);  
其它三种操作符是不能修改一个对象的常量性的。  
注意：'const\_cast'也能改变一个类型的volatile qualifier。

\--------------------------------------------------------------------

C++的4种类型转换

一、C 风格（C-style）强制转型如下：

(T) expression // cast expression to be of type T   
    函数风格（Function-style）强制转型使用这样的语法：  
    T(expression) // cast expression to be of type T   
    这两种形式之间没有本质上的不同，它纯粹就是一个把括号放在哪的问题。

我把这两种形式称为旧风格（old-style）的强制转型。

二、 C++的四种强制转型形式：

C++ 同时提供了四种新的强制转型形式（通常称为新风格的或 C++ 风格的强

制转型）：   
　　const\_cast(expression)   
　　dynamic\_cast(expression)   
　　reinterpret\_cast(expression)   
　　static\_cast(expression)

每一种适用于特定的目的：

·dynamic\_cast 主要用于执行“安全的向下转型（safe downcasting）”，

也就是说，要确定一个对象是否是一个继承体系中的一个特定类型。它是唯一不

能用旧风格语法执行的强制转型，也是唯一可能有重大运行时代价的强制转型。  
      
    ·static\_cast 可以被用于强制隐型转换（例如，non-const 对象转型为

const 对象，int 转型为 double，等等），它还可以用于很多这样的转换的反向

转换（例如，void\* 指针转型为有类型指针，基类指针转型为派生类指针），但

是它不能将一个 const 对象转型为 non-const 对象（只有 const\_cast 能做到

），它最接近于C-style的转换。  
      
　　·const\_cast 一般用于强制消除对象的常量性。它是唯一能做到这一点的

C++ 风格的强制转型。

·reinterpret\_cast 是特意用于底层的强制转型，导致实现依赖

（implementation-dependent）（就是说，不可移植）的结果，例如，将一个指

针转型为一个整数。这样的强制转型在底层代码以外应该极为罕见。  
　　  
　　旧风格的强制转型依然合法，但是新的形式更可取。首先，在代码中它们更

容易识别（无论是人还是像 grep 这样的工具都是如此），这样就简化了在代码

中寻找类型系统被破坏的地方的过程。第二，更精确地指定每一个强制转型的目

的，使得编译器诊断使用错误成为可能。例如，如果你试图使用一个 const\_cast

以外的新风格强制转型来消除常量性，你的代码将无法编译。

==    
==  dynamic\_cast .vs. static\_cast   
==

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

void f(B\* pb)  
\{  
   D\* pd1 = dynamic\_cast<D\*>(pb);  
   D\* pd2 = static\_cast<D\*>(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 == 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可用于继承体系中的向下转型，即将基类指针转换为派生类

指针，比static\_cast更严格更安全。dynamic\_cast在执行效率上比static\_cast

要差一些,但static\_cast在更宽上范围内可以完成映射,这种不加限制的映射伴随

着不安全性.static\_cast覆盖的变换类型除类层次的静态导航以外,还包括无映射

变换,窄化变换(这种变换会导致对象切片,丢失信息),用VOID\*的强制变换,隐式类

型变换等...

==  
==  static\_cast .vs. reinterpret\_cast   
==

reinterpret\_cast是为了映射到一个完全不同类型的意思,这个关键词在我们

需要把类型映射回原有类型时用到它.我们映射到的类型仅仅是为了故弄玄虚和其

他目的,这是所有映射中最危险的.(这句话是C++编程思想中的原话)

static\_cast 和 reinterpret\_cast 操作符修改了操作数类型. 它们不是互

逆的; static\_cast 在编译时使用类型信息执行转换, 在转换执行必要的检测(诸

如指针越界计算, 类型检查). 其操作数相对是安全的. 另一方面,

reinterpret\_cast 仅仅是重新解释了给出的对象的比特模型而没有进行二进制转

换, 例子如下:

int n=9; double d=static\_cast < double > (n);

上面的例子中, 我们将一个变量从 int 转换到 double. 这些类型的二进制

表达式是不同的. 要将整数 9 转换到 双精度整数 9, static\_cast 需要正确地

为双精度整数 d 补足比特位. 其结果为 9.0. 而reinterpret\_cast 的行为却不

同:

int n=9;  
    double d=reinterpret\_cast<double & > (n);

这次, 结果有所不同. 在进行计算以后, d 包含无用值. 这是因为

reinterpret\_cast 仅仅是复制 n 的比特位到 d, 没有进行必要的分析.

C++ 中四种cast比较(转载)

发表评论取消回复

还没有评论，来说两句吧...

相关阅读

相关 C++ 学习：C++ 的四种强制类型转换 static_cast、dynamic_cast、const_cast、reinterpret_cast

相关 C++的四种转换(const_cast、static_cast、dynamic_cast、reinterpreter_cast)

相关 C++ 中static_cast、dynamic_cast、const_cast和reinterpret_cast总结

相关 C++ 中四种cast比较(转载)

相关 static_cast, dynamic_cast, reinterpret_cast, const_cast区别比较

相关 static_cast, dynamic_cast, reinterpret_cast, const_cast区别比较

相关 static_cast, dynamic_cast, reinterpret_cast, const_cast区别比较

相关 const_cast,dynamic_cast,reinterpret_cast,static_cast四种转换的区别

相关 C++提供的四种新式转换--const_cast dynamic_cast reinterpret_cast static_cast

相关 C++四种cast及其使用