关于强制类型转换：强制类型转换

• 记住核心原则－－C语言里面的强制类型不改变内存数据。
  
  比如我们可以(int)'A'，这样转换后的结果为A的ASCII码数值，因为那块内存本来就存的那个数，只是换个形式使用而已。
  
  知道上面的原则，我们可以对任何数据类型进行转换，但是转换的结果可能不是你想像的结果，举例(int)'9'的结果为多少？不是9而是0x39。来个高深点的printf("%d",'12');的输出是什么？正确答案是12849，知道是怎么来的吗，提示你0x3231，涉及INTEL的字节地址交换，不明白就算了吧。

  ###################################################################

  1. static_cast
  用法：static_cast < type-id > ( expression )
  该运算符把expression转换为type-id类型，但没有运行时类型检查来保证转换的安全性。它主要有如下几种用法：
  ①用于类层次结构中基类和子类之间指针或引用的转换。
  　　进行上行转换（把子类的指针或引用转换成基类表示）是安全的；
  　　进行下行转换（把基类指针或引用转换成子类表示）时，由于没有动态类型检查，所以是不安全的。
  ②用于基本数据类型之间的转换，如把int转换成char，把int转换成enum。这种转换的安全性也要开发人员来保证。
  ③把空指针转换成目标类型的空指针。
  ④把任何类型的表达式转换成void类型。

  注意：static_cast不能转换掉expression的const、volitale、或者__unaligned属性。

  
  2. dynamic_cast
  用法：dynamic_cast < type-id > ( expression )
  该运算符把expression转换成type-id类型的对象。Type-id必须是类的指针、类的引用或者void *；
  如果type-id是类指针类型，那么expression也必须是一个指针，如果type-id是一个引用，那么expression也必须是一个引用。
  dynamic_cast主要用于类层次间的上行转换和下行转换，还可以用于类之间的交叉转换。
  在类层次间进行上行转换时，dynamic_cast和static_cast的效果是一样的；
  在进行下行转换时，dynamic_cast具有类型检查的功能，比static_cast更安全。

  注意：这里要求派生类从要有虚拟函数，否则编译不能够通过。而static_cast则无此要求。

  
  
  
  3. reinpreter_cast
  用法：reinpreter_cast (expression)
  type-id必须是一个指针、引用、算术类型、函数指针或者成员指针。
  它可以把一个指针转换成一个整数，也可以把一个整数转换成一个指针（先把一个指针转换成一个整数，
  在把该整数转换成原类型的指针，还可以得到原先的指针值）。
  该运算符的用法比较多。

  
  4. const_cast
  用法：const_cast (expression)
  该运算符用来修改类型的const或volatile属性。除了const 或volatile修饰之外， type_id和expression的类型是一样的。
  常量指针被转化成非常量指针，并且仍然指向原来的对象；
  常量引用被转换成非常量引用，并且仍然指向原来的对象；常量对象被转换成非常量对象。
  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 (n);

  ##########################################################################

  C++ 里最好杜绝使用 C 方式的强制转换.

  换用以上 4 个.

  
  我们通常用的是 static_cast
  在一类东西都可以转, 但是不是一类的就不能转.
  即, 语义上说不通的, 两个完全不同的数据类型 static_cast 是拒绝工作的.

  比如你想把一个指针转成浮点数, 或者想把 class A * 转成 class B * , 但是 class A 和 class B
  又没有任何关系. 等等....
  
  static_cast 在通过编译后, 空间和时间效率实际等价于 C 方式强制转换. 都是编译时决定的.
  
  dynamic_cast 类似 static_cast, 但是在一颗类继承树上转换时,
  将利用 RTTI 在运行时检查. 我们一般用于 downcast
  
  比如,
  class A {};
  class B : public A {};
  
  A* a=new B();
  
  这个时候, 可以用 dynamic_cast 做 downcast, 把 a 转成 B*.
  和 static_cast 不同, dynamic_cast 会检查一下 a 到底是不是指向一个
  B, (利用了 RTTI) 如果转不了, 将返回一个 NULL.
  
  reinterpret_cast 就比 static_cast 更接近 C 的强制转换了.
  它更进一步的, 实现一些看起来没关系的两种类型转换.
  比如我习惯干的, 把一个 void * 转成 unsigned ;)
  当然它比 static_cast 危险.
  
  但是有 reinterpret_cast 干不了的,
  比如你在一个 const 成员函数里企图修改一个非 mutable 的成员变量.
  编译器会对你咆哮, "不许动, 那玩意是我 const 住的, 把你的爪子
  收回去" 这个时候就要利用 const_cast 了, 呵呵.
  
  const_cast 就是可以解除 const 限制的"神"的武器
  但我认为, 这在很多情况下比 reinterpret_cast 更危险, 我还是老实做
  人的好. 让编译器来捍卫我的代码的安全.
  
  
  ---------------------------------------------------------------
  
  这四个cast用来替代C里面包打一切类型转换的（）.
  const_cast用来改变变量的“常数性”，例如：
  void func(const int* pcn)
  {
  int* pn = const_cast<int*>(pcn);
  *pn = 10;
  }
  
  dynamic_cast用来把指向基类的指针安全地转化为指向派生类的指针，如果基类指针指向的对象不是派生类的对象，那么转换结果为NULL。例如，
  CMainFrame* pFrame = dynamic_cast<CMainFrame*>(GetParent());
  如果调用GetParent的窗口的父窗口确实是CMainFrame类型，则pFrame指向
  该窗口，否则pFrame为NULL。
  
  static_cast也可以加基类的指针转化为派生类的指针，但不做运行是类型检查，所以可以隐含错误。此外，static_cast还可用于显式的类型转化，如将float转化为int，将int转化为double等等。例如：
  int i = 3;
  double d = static_cast<double>(i);
  这样做的好处是避免了编译时关于精度损失的警告信息。
  
  reinterpret_cast是强力类型转换，进行所谓不合理的转换，或者说上面三个操作符无法进行的转换。例如把int转化为指向类的指针：
  void OnMessage(WPARAM wParam, LPARAM lParam)
  {
  CMyClass* pMyStructure
  = reinterpret_cast<CMyClass*>(lParam);
  ...
  }
  关于这四个运算符，我能说的最后一句话就是，请不要再用（）cast了，专心使用这四个啰嗦的运算符吧。他们会使你受益的。
  
  
  
  ---------------------------------------------------------------
  
  
  * C++提供了四种新的类型强制：
  
  static_cast
  const_cast
  reinterpret_cast
  dynamic_cast
  
  1)staic_cast静态强制；
  
  不能在无关的指针之间进行static类型强制
  class CAnimal
  {
  //...
  public:
  CAnimal(){}
  };
  
  class CGiraffe:public CAnimal
  {
  //...
  public:
  CGiraffe(){}
  };
  
  int main(void)
  {
  CAnimal an;
  CGiraffe jean;
  
  an = static_cast<CAnimal>(jean);//将对象jean强制成CAnimal类型
  return 0;
  }
  
  2、const_cast类型强制
  
  const_cast类型强制将一个const变量变成一个非const的等价形式
  int main()
  {
  const int j = 99;
  int * k;
  
  k = const_cast<int *>(&j);//解除const
  return 0;
  }
  
  3、reinterpret_cast运算符
  
  reinterpret_cast运算符用来将一个类型指针转变为另一种类型的指针，也用在将整开型量转为指针，或将指针转为整型量上；
  int main()
  {
  int j = 10;
  int * ptr = &j;
  char * cptr;
  
  cptr = reinterpret_cast<char *>(ptr);//将int指针类型转变为char的指针类型
  
  return 0;
  }
  
  4、dynamic_cast运算符
  
  dynamic_cast的主要目的是：
  
  1）它返回派生类对象的地址；
  2）它测试基类指针是否指向下一尖括号<>中所指定类型的对象
  
  dynamic_cast是一个运行时类型信息，dynamic_cast运算符将指向派生对象的基类部分的基类指针转变为指向派生对象的派生类指针，dynamic_cast必须严格地指定与派生对象相同的类，或者它返回NULL指针;
  class CAnimal
  {
  //...
  };
  class CGiraffe:public CAnimal
  {
  //...
  };
  class CGoat:public CAnimal
  {
  //...
  };
  
  int main()
  {
  CGiraffe gene;
  CAnimal * aptr = &gene;
  CGiraffe * ptr1,* ptr2;
  
  ptr1 = dynamic_cast<CGiraffe *>(aptr);
  ptr2 = dynamic_cast<CGoat *>(aptr); //return NULL
  
  return 0;
  }
  
  ---------------------------------------------------------------
  
  想不出比此更好的表达，请参阅more effected c++
  
  条款2 尽量使用C++风格的类型转换

  
  仔细想想地位卑贱的类型转换功能 cast 其在程序设计中的地位就象goto 语句一样令人鄙视 但是它还不是无法令人忍受 因为当在某些紧要的关头 类型转换还是必需的 这时它是一个必需品不过C风格的类型转换并不代表所有的类型转换功能 一来它们过于粗鲁 能允许你在任何类型之间进行转换 不过如果要进行更精确的类型转换 这会是一个优点 在这些类型转换中存在着巨大的不同 例如把一个指向const 对象的指针 pointer-to-const-object 转换成指向非const对象的指针 pointer-to-non-const-object
  (即一个仅仅去除cosnt 的类型转换) 把一个指向基类的指针转换成指向子类的指针 即完全改变对象类型 传统的C风格的类型转换不对上述两种转换进行区分 这一点也不令人惊讶 因为C风格的类型转换是为C语言设计的 而不是为C++语言设计的 二来C风格的类型转换在程序语句中难以识别 在语法上类型转换由圆括号和标识符组成 而这些可以用在C 中的任何地方 这使得回答象这样一个最基本的有关类型转换的问题变得很困难 在这个程序中是否使用了类型转换