c++ cast 总结

1.

旧式强制转换依赖于所涉及的数据类型，具有与 const_cast、 static_cast 和 reinterpret_cast 一样的行为。
在合法使用 static_cast 或 const_cast 的地方，旧式强制转换提供了与各自对应的命名强制转换一样的功能。
如果这两种强制转换均不合法，则旧式强制转换执行 reinterpret_cast 功能。

dynamic_cast 是 C++ 对多态 支持的 强制类型转换。 所以class 里面必须有 virtual function；
通过运行时类型识别（RTTI），程序能够使用基类的指针或引用来检索这些指针或引用所指对象的实际派生类型。
1.  typeid 操作符，返回指针或引用所指对象的实际类型。 
2.  dynamic_cast 操作符，将基类类型的指针或引用安全地转换为派生类型的指针或引用。
与其他强制类型转换不同，dynamic_cast 涉及运行时类型检查。
如果绑定到引用或指针的对象不是目标类型的对象，则 dynamic_cast 失败。
to pointer : 如果转换到指针类型的 dynamic_cast 失败，则 dynamic_cast 的结果是 0 值；
to reference : 如果转换到引用类型的 dynamic_cast 失败，则抛出一个 bad_cast 类型的异常。

2.

C++ primer version 4:
5.12.4.  显式转换 
显式转换也称为强制类型转换（cast），包括以下列名字命名的强制类型转换操作符：static_cast、dynamic_cast、const_cast 和 reinterpret_cast。 

虽然有时候确实需要强制类型转换，但是它们本质上是非常危
险的。

5.12.5.  何时需要强制类型转换 
因为要覆盖通常的标准转换，所以需显式使用强制类型转换。下面的复合赋
值： 
     double dval; 
     int ival; 
     ival *= dval; // ival = ival * dval 
为了与 dval 做乘法操作，需将 ival 转换为 double 型，然后将乘法操作
的 double 型结果截尾为 int 型，再赋值给 ival。为了去掉将 ival 转换为 
double 型这个不必要的转换，可通过如下强制将 dval 转换为 int 型： 
     ival *= static_cast<int>(dval); // converts dval to int 
显式使用强制类型转换的另一个原因是：可能存在多种转换时，需要选择一
种特定的类型转换。我们将在第 14 章中详细讨论这种情况。 

5.12.6.  命名的强制类型转换 
命名的强制类型转换符号的一般形式如下： 
     cast-name<type>(expression); 
其中 cast-name 为 static_cast、dynamic_cast、const_cast 和 reinterpret_cast 之一，type 为转换的目标类型，而 expression 则是被强制转换的值。
强制转换的类型指定了在 expression 上执行某种特定类型的转换。 

dynamic_cast 
dynamic_cast 支持运行时识别指针或引用所指向的对象。对 dynamic_cast 的讨论将在第 18.2 节中进行。 

const_cast 
const_cast ，顾名思义，将转换掉表达式的 const 性质。
例如，假设有函数 string_copy，只有唯一的参数，为 char* 类型，我们对该函数只读不写。
在访问该函数时，最好的选择是修改它让它接受 const char* 类型的参数。
如果不行，可通过 const_cast 用一个 const 值调用 string_copy 函数： 
     const char *pc_str; 
   char *pc = string_copy(const_cast<char*>(pc_str)); 
只有使用 const_cast 才能将 const 性质转换掉。在这种情况下，试图使
用其他三种形式的强制转换都会导致编译时的错误。类似地，除了添加或删除 
const 特性，用 const_cast 符来执行其他任何类型转换，都会引起编译错误。 

static_cast 
编译器隐式执行的任何类型转换都可以由 static_cast 显式完成： 
     double d = 97.0; 
     // cast specified to indicate that the conversion is intentional 
     char ch = static_cast<char>(d); 
当需要将一个较大的算术类型赋值给较小的类型时，使用强制转换非常有用。
此时，强制类型转换告诉程序的读者和编译器：我们知道并且不关心潜在的精度损失。
对于从一个较大的算术类型到一个较小类型的赋值，编译器通常会产生警告。
当我们显式地提供强制类型转换时，警告信息就会被关闭。 
如果编译器不提供自动转换，使用 static_cast 来执行类型转换也是很有用的。
例如，下面的程序使用 static_cast 找回存放在 void* 指针中的值（第 4.2.2 节）： 
     void* p = &d; // ok: address of any data object can be stored in a 
void* 
     // ok: converts void* back to the original pointer type 
     double *dp = static_cast<double*>(p); 
可通过 static_cast 将存放在 void* 中的指针值强制转换为原来的指针类型，此时我们应确保保持指针值。
也就是说，强制转换的结果应与原来的地址值相等。 

reinterpret_cast 
reinterpret_cast 通常为操作数的位模式提供较低层次的重新解释。 
reinterpret_cast 本质上依赖于机器。
为了安全地使用 reinterpret_cast，要求程序员完全理解所涉及的数据类型,以及编译器实现强制类型转换的细节。 
例如，对于下面的强制转换：
 int *ip; 
     char *pc = reinterpret_cast<char*>(ip); 
程序员必须永远记得 pc 所指向的真实对象其实是 int 型，而并非字符数组。
任何假设 pc 是普通字符指针的应用，都有可能带来有趣的运行时错误。
例如，下面语句用 pc 来初始化一个 string 对象： 
     string str(pc); 
它可能会引起运行时的怪异行为。 
用 pc 初始化 str 这个例子很好地说明了显式强制转换是多么的危险。
问题源于类型已经改变时编译器没有提供任何警告或错误提示。
当我们用 int 型地址初始化 pc 时，由于显式地声明了这样的转换是正确的，因此编译器不提供任何错误或警告信息。
后面对 pc 的使用都假设它存放的是 char* 型对象的地址，编译器确实无法知道 pc 实际上是指向 int 型对象的指针。
因此用 pc 初始化 str 是完全正确的——虽然实际上是无意义的或是错误的。
查找这类问题的原因相当困难，特别是如果 ip 到 pc 的强制转换和使用 pc 初始化 string 对象这两个应用发生在不同文件中的时候。

//-----------------------------------------------------------------------//
建议：避免使用强制类型转换 
强制类型转换关闭或挂起了正常的类型检查（第 2.3 节）。强烈建议程
序员避免使用强制类型转换，不依赖强制类型转换也能写出很好的 C++ 
程序。 
这个建议在如何看待 reinterpret_cast 的使用时非常重要。此类强制
转换总是非常危险的。相似地，使用 const_cast 也总是预示着设计缺
陷。设计合理的系统应不需要使用强制转换抛弃 const 特性。其他的强
制转换，如 static_cast 和 dynamic_cast，各有各的用途，但都不应
频繁使用。每次使用强制转换前，程序员应该仔细考虑是否还有其他不
同的方法可以达到同一目的。如果非强制转换不可，则应限制强制转换
值的作用域，并且记录所有假定涉及的类型，这样能减少错误发生的机
会。
//-----------------------------------------------------------------------//

5.12.7.  旧式强制类型转换 
在引入命名的强制类型转换操作符之前，显式强制转换用圆括号将类型括起来实现： 
     char *pc = (char*) ip; 

效果与使用 reinterpret_cast 符号相同，但这种强制转换的可视性比较差，难以跟踪错误的转换。 
标准 C++ 为了加强类型转换的可视性，引入命名的强制转换操作符，为程
序员在必须使用强制转换时提供了更好的工具。例如，非指针的 static_cast 和const_cast 要比 reinterpret_cast 更安全。
结果使程序员（以及读者和操纵程序的工具）可清楚地辨别代码中每个显式的强制转换潜在的风险级别。 

虽然标准 C++ 仍然支持旧式强制转换符号，但是我们建议，只有在 C 语言或标准 C++ 之前的编译器上编写代码时，才使用这种语法。 
旧式强制转换符号有下列两种形式： 
     type (expr); // Function-style cast notation 
     (type) expr; // C-language-style cast notation 
旧式强制转换依赖于所涉及的数据类型，具有与 const_cast、 static_cast 和 reinterpret_cast 一样的行为。
在合法使用 static_cast 或 const_cast 的地方，旧式强制转换提供了与各自对应的命名强制转换一样的功能。
如果这两种强制转换均不合法，则旧式强制转换执行 reinterpret_cast 功能。
例如，我们可用旧式符号重写上一节的强制转换： 
     int ival; double dval; 
     ival += int (dval); // static_cast: converts double to int 
     const char* pc_str; 
     string_copy((char*)pc_str); // const_cast: casts away const 
     int *ip; 
     char *pc = (char*)ip; // reinterpret_cast: treats int* as char* 
支持旧式强制转换符号是为了对“在标准 C++ 之前编写的程序”保持向后兼容性，并保持与 C 语言的兼容性。 

3.

以下来自，转载请标明出处：http://blog.csdn.net/zjl_1026_2001/archive/2008/04/03/2246510.aspx 
本文讨论static_cast<> 和 reinterpret_cast<>。

reinterpret_cast可以转换任意一个32bit整数，包括所有的指针和整数。可以把任何整数转成指针，也可以把任何指针转成整数，以及把指针转化为任意类型的指针，威力最为强大！
但不能将非32bit的实例转成指针。总之，只要是32bit的东东，怎么转都行！ 

static_cast和dynamic_cast可以执行指针到指针的转换，或实例本身到实例本身的转换，但不能在实例和指针之间转换。
static_cast只能提供编译时的类型安全，  而dynamic_cast可以提供运行时类型安全。举个例子：

class a；class b:a；class c。 
上面三个类a是基类，b继承a，c和ab没有关系。 
有一个函数void function(a&a); 
现在有一个对象是b的实例b，一个c的实例c。 
function(static_cast<a&>(b)可以通过而 function(static_cast<a&>(c))不能通过编译，因为在编译的时候编译器已经知道c和a的类型不符，因此static_cast可以保证安全。 
下面我们骗一下编译器，先把c转成类型a 
b& ref_b = reinterpret_cast<b&>c; 
然后function(static_cast<a&>(ref_b))就通过了！因为从编译器的角度来看，在编译时并不能知道ref_b实际上是c！ 
而function(dynamic_cast<a&>(ref_b))编译时也能过，但在运行时就失败了，因为dynamic_cast在运行时检查了ref_b的实际类型，这样怎么也骗不过去了。 

在应用多态编程时，当我们无法确定传过来的对象的实际类型时使用dynamic_cast，如果能保证对象的实际类型，用 static_cast 就可以了。
至于reinterpret_cast，我很喜欢，很象c语言那样的暴力转换.

dynamic_cast:动态类型转换 
static_cast:静态类型转换 
reinterpret_cast:重新解释类型转换 
const_cast:常量类型转换 

专业的上面很多了,我说说我自己的理解吧: 
synamic_cast 一般用在父类和子类指针或应用的互相转化; 
static_cast 一般是普通数据类型(如int m =static_cast<int>(3.14)); 
reinterpret_cast 很像c的一般类型转换操作 
const_cast 是把cosnt或volatile属性去掉

介绍
大多程序员在学C++前都学过C，并且习惯于C风格(类型)转换。当写C++(程序)时，有时候我们在使用static_cast<>和reinterpret_cast<>时可能会有点模糊。
在本文中，我将说明static_cast<>实际上做了什么，并且指出一些将会导致错误的情况。

泛型(Generic Types)

  float f = 12.3;

  float *pf = &f;


// static cast<>

// 成功编译, n = 12
int n = static_cast<int>(f);

// 错误,指向的类型是无关的(译注：即指针变量pf是float类型，现在要被转换为int类型)
//int* pn = static_cast<int*>(pf);

//成功编译
void* pv = static_cast<void*>(pf);

//成功编译, 但是 *pn2是无意义的内存(rubbish)
int* pn2 = static_cast<int*>(pv);


// reinterpret_cast<>

//错误,编译器知道你应该调用static_cast<>
//int i = reinterpret_cast<int>(f);

//成功编译, 但是 *pn 实际上是无意义的内存,和 *pn2一样
         int* pi = reinterpret_cast<int*>(pf);

简而言之，static_cast<> 将尝试转换，举例来说，如float-到-integer，而reinterpret_cast<>简单改变编译器的意图重新考虑那个对象作为另一类型。

指针类型(Pointer Types)

指针转换有点复杂，我们将在本文的剩余部分使用下面的类：
class CBaseX
{
public:
  int x;
  CBaseX() { x = 10; }
  void foo() { printf("CBaseX::foo() x =%d/n", x); }
};

class CBaseY
{
public:
  int y;
  int* py;

  CBaseY() { y = 20; py = &y; }
  void bar() { printf("CBaseY::bar() y =%d, *py =%d/n", y, *py); }

};


class CDerived : public CBaseX, public CBaseY
{
public:
  int z;
};
情况1：两个无关的类之间的转换

      // Convert between CBaseX* and CBaseY*

      // CBaseX* 和 CBaseY*之间的转换

      CBaseX* pX = new CBaseX();

      // Error, types pointed to are unrelated

      // 错误， 类型指向是无关的

      // CBaseY* pY1 = static_cast<CBaseY*>(pX);

      // Compile OK, but pY2 is not CBaseX

      // 成功编译, 但是 pY2 不是CBaseX

      CBaseY* pY2 = reinterpret_cast<CBaseY*>(pX);

      // System crash!!

      // 系统崩溃!!

      // pY2->bar();
正如我们在泛型例子中所认识到的，如果你尝试转换一个对象到另一个无关的类static_cast<>将失败，而reinterpret_cast<>就总是成功“欺骗”编译器：那个对象就是那个无关类。

情况2：转换到相关的类
       CDerived* pD = new CDerived();

       printf("CDerived* pD = %x/n", (int)pD);

      // static_cast<> CDerived* -> CBaseY* -> CDerived*
      //成功编译，隐式static_cast<>转换
       CBaseY* pY1 = pD;

       printf("CBaseY* pY1 = %x/n", (int)pY1);

      // 成功编译, 现在 pD1 = pD
       CDerived* pD1 = static_cast<CDerived*>(pY1);

       printf("CDerived* pD1 = %x/n", (int)pD1);



      // reinterpret_cast
      // 成功编译, 但是 pY2 不是 CBaseY*
       CBaseY* pY2 = reinterpret_cast<CBaseY*>(pD);

       printf("CBaseY* pY2 = %x/n", (int)pY2);



       // 无关的 static_cast<>
       CBaseY* pY3 = new CBaseY();

       printf("CBaseY* pY3 = %x/n", (int)pY3);

      // 成功编译,尽管 pY3 只是一个 "新 CBaseY()"
       CDerived* pD3 = static_cast<CDerived*>(pY3);

       printf("CDerived* pD3 = %x/n", (int)pD3);
      ---------------------- 输出 ---------------------------

      CDerived* pD = 392fb8

      CBaseY* pY1 = 392fbc

      CDerived* pD1 = 392fb8

      CBaseY* pY2 = 392fb8

      CBaseY* pY3 = 390ff0

      CDerived* pD3 = 390fec


注意：在将CDerived*用隐式 static_cast<>转换到CBaseY*(第5行)时，结果是(指向)CDerived*(的指针向后) 偏移了4(个字节)(译注：4为int类型在内存中所占字节数)。为了知道static_cast<> 实际如何，我们不得不要来看一下CDerived的内存布局。
CDerived的内存布局(Memory Layout)



如图所示，CDerived的内存布局包括两个对象，CBaseX 和 CBaseY，编译器也知道这一点。因此，当你将CDerived* 转换到 CBaseY*时，它给指针添加4个字节，同时当你将CBaseY*转换到CDerived*时，它给指针减去4。然而，甚至它即便不是一个CDerived你也可以这样做。
当然，这个问题只在如果你做了多继承时发生。在你将CDerived转换 到 CBaseX时static_cast<> 和 reinterpret_cast<>是没有区别的。

情况3：void*之间的向前和向后转换

因为任何指针可以被转换到void*，而void*可以被向后转换到任何指针(对于static_cast<> 和 reinterpret_cast<>转换都可以这样做)，如果没有小心处理的话错误可能发生。

  CDerived* pD = new CDerived();

  printf("CDerived* pD = %x/n", (int)pD);

  CBaseY* pY = pD; // 成功编译, pY = pD + 4

  printf("CBaseY* pY = %x/n", (int)pY);

  void* pV1 = pY; //成功编译, pV1 = pY

  printf("void* pV1 = %x/n", (int)pV1);

  // pD2 = pY, 但是我们预期 pD2 = pY - 4
  CDerived* pD2 = static_cast<CDerived*>(pV1);

  printf("CDerived* pD2 = %x/n", (int)pD2);

  // pD2->bar();// 系统崩溃
  ---------------------- 输出 ---------------------------

  CDerived* pD = 392fb8

  CBaseY* pY = 392fbc

  void* pV1 = 392fbc

  CDerived* pD2 = 392fbc


一旦我们已经转换指针为void*，我们就不能轻易将其转换回原类。在上面的例子中，从一个void* 返回CDerived*的唯一方法是将其转换为CBaseY*然后再转换为CDerived*。 
但是如果我们不能确定它是CBaseY* 还是 CDerived*，这时我们不得不用dynamic_cast<> 或typeid[2]。

注释：
1. dynamic_cast<>，从另一方面来说，可以防止一个泛型CBaseY* 被转换到CDerived*。
2. dynamic_cast<>需要类成为多态，即包括“虚”函数，并因此而不能成为void*。
参考： 
1. [MSDN] C++ Language Reference -- Casting 
2. Nishant Sivakumar, Casting Basics - Use C++ casts in your VC++.NET programs 
3. Juan Soulie, C++ Language Tutorial: Type Casting