static_cast , dynamic_cast , reindivter_cast , const_cast CSND 纪要

static_cast转换类似于C/C++里面的强制类型转换。
dynamic_cast转换是根据基类派生类的原则进行转换，把一个派生类转换为基类使用这个转换。
const_cast转换是去掉const变量的const

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

dynamic_cast:   通常在基类和派生类之间转换时使用,run-time   cast

const_cast:   主要针对const和volatile的转换.

static_cast:   一般的转换，no   run-time   check.通常，如果你不知道该用哪个，就用这个。

reinterpret_cast:   用于进行没有任何关联之间的转换，比如一个字符指针转换为一个整形数。

这些偏重于口语化解释，最好还是看看书，讲述标准c＋＋的教材上都会有的。

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

我基本上明白了，谢谢楼上的几位．
问下：goodluckyxl(被人遗忘的狗)
你是zju的那个wishingbone么？
我看msdn做了下笔记．
＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝
这个例子说明,子类向基类转换.
class   B   {   ...   };
class   C   :   public   B   {   ...   };
class   D   :   public   C   {   ...   };

void   f(D*   pd)
{
      C*   pc   =   dynamic_cast <C*> (pd);       //   ok:   C   is   a   direct   base   class
                                               
      //   pc   points   to   C   subobject   of   pd  

      B*   pb   =   dynamic_cast <B*> (pd);       //   ok:   B   is   an   indirect   base   class
                                               
      //   pb   points   to   B   subobject   of   pd  
      ...
}

这个例子说明的是void*类型的向某一种类型的转换
其实这里不用dynamic_cast <type_id> 也可以,他会隐士转换
class   A   {   ...   };

class   B   {   ...   };

void   f()
{
      A*   pa   =   new   A;
      B*   pb   =   new   B;
      void*   pv   =   dynamic_cast <void*> (pa);
      //   pv   now   points   to   an   object   of   type   A
      ...
      pv   =   dynamic_cast <void*> (pb);
      //   pv   now   points   to   an   object   of   type   B
}

这个例子说明自身类型转换主要是看它当前所直的对象和它将要转换的类型是否一致.而且这个一直是在程序运行中检测的.
class   B   {   ...   };
class   D   :   public   B   {   ...   };

void   f()
{
      B*   pb   =   new   D;                               //   unclear   but   ok
      B*   pb2   =   new   B;

      D*   pd   =   dynamic_cast <D*> (pb);             //   ok:   pb   actually   points   to   a   D
      ...
      D*   pd2   =   dynamic_cast <D*> (pb2);       //error:   pb2   points   to   a   B,   not   a   D
                                                            //   pd2   ==   NULL
      ...
}

下面是多重继承的,
这里我觉得有点奇怪,因为msdn上说从type   D   to   type   A,存在二义性.
但我觉得类型A就是一种啊,怎么会有二义性呢?
Class   A
Class   B   :   public   A{….}
Class   C:   public   A{….}
Class   D:   B,C;

void   f()
{
      D*   pd   =   new   D;
      A*   pa   =   dynamic_cast <A*> (pd);             //   error:   ambiguous
      B*   pb   =   dynamic_cast <B*> (pd);             //   first   cast   to   B
      A*   pa2   =   dynamic_cast <A*> (pb);       //   ok:   unambiguous
}

下面这个我就更有问题了.
Class   A{….}
Class   B:   public   A{……}
Class   C:public   A{……..}
Class   D{……………}
Class   E:public   B,C,D{…….}
//这里是从父类到基类
void   f(D*   pd)
{
      E*   pe   =   dynamic_cast <E*> (pd);
      B*   pb   =   pe;             //   upcast,   implicit   conversion
      A*   pa   =   pb;             //   upcast,   implicit   conversion
}//这里从子类到父类,没用到dynamic_cast,也就是说,从子类到父类是可以不用这个的,我以前学C++的时候,觉得是可以不用dynamic_cast的,但必须要隐士转换.

下面这样转换都可以啊—cross   cast!第一次看到.
void   f(D*   pd)
{
      B*   pb   =   dynamic_cast <B*> (pd);             //   cross   cast
      A*   pa   =   pb;                                     //   upcast,   implicit   conversion
}

Static_cast
1.当类型从父类到子类转换时,不安全!
class   B   {   ...   };

class   D   :   public   B   {   ...   };

void   f(B*   pb,   D*   pd)
{
        D*   pd2   =   static_cast <D*> (pb);                 //   not   safe,   pb   may
                                               
                                  //   point   to  
just   B

        B*   pb2   =   static_cast <B*> (pd);                 //   safe   conversion
        ...
}

2.用static_cast感觉好象是程序员要强制类型转换,是否安全就由程序员自己决定了.
typedef   unsigned   char   BYTE

void   f()
{
      char   ch;
      int   i   =   65;
      float   f   =   2.5;
      double   dbl;

      ch   =   static_cast <char> (i);                   //   int   to   char
      dbl   =   static_cast <double> (f);                   //   float   to   double
      ...
      i   =   static_cast <BYTE> (ch);
      ...
}
现在我的认识就是:static_cast和dynamic_cast的区别主要在与,前者是静态检测类型,而后者是动态的.