C++四种类型转换的关键字及其特点

c++中类型转换相关关键字（4个）

http://blog.csdn.net/u010025211/article/details/48626687

原文地址：http://blog.sina.com.cn/s/blog_5a2bbc860101hgho.html

C++的四种强制类型转换，所以C++不是类型安全的。

关键字分别为：static_cast , dynamic_cast , const_cast , reinterpret_cast

为什么使用C风格的强制转换可以把想要的任何东西转换成合乎心意的类型。那为什么还需要一个新的C++类型的强制转换呢？
新类型的强制转换可以提供更好的控制强制转换过程，允许控制各种不同种类的强制转换。C++中风格是static_cast<type>(content)。C++风格的强制转换其他的好处是，它们能更清晰的表明它们要干什么。程序员只要扫一眼这样的代码，就能立即知道一个强制转换的目的。
四种转换的区别：

• static_cast:可以实现C++中内置基本数据类型之间的相互转换。

复制代码代码如下:

int c=static_cast<int>(7.987); 

如果涉及到类的话，static_cast只能在有 相互联系的类型 中进行相互转换, 不一定包含虚函数 。

复制代码代码如下:

class A 
{}; 
class B:public A 
{}; 
class C 
{}; 

int main() 
{ 
    A* a=new A; 
    B* b; 
    C* c; 
    b=static_cast<B>(a);  // 编译不会报错, B类继承A类 
    c=static_cast<B>(a);  // 编译报错, C类与A类没有任何关系 
    return 1; 
}

注意：如上例所示，应该只有派生类到基类的转换，基类到派生类本不应该存在转换，但static_cast<>编译不报错，有风险。

• const_cast (expression)

http://www.cnblogs.com/ider/archive/2011/07/22/cpp_cast_operator_part2.html

const_cast转换符是用来移除变量的const或volatile限定符。对于后者，我不是太清楚，因为它涉及到了多线程的设计，而我在这方面没有什么了解。所以我只来说const方面的内容。

用const_cast来去除const限定

对于const变量，我们不能修改它的值，这是这个限定符最直接的表现。但是我们就是想违背它的限定希望修改其内容怎么办呢？

下边的代码显然是达不到目的的：const int constant = 10;
int modifier = constant;

因为对modifier的修改并不会影响到constant，这暗示了一点:const_cast转换符也不该用在对象数据上，因为这样的转换得到的两个变量/对象并没有相关性。

只有用指针或者引用，让变量指向同一个地址才是解决方案，可惜下边的代码在C++中也是编译不过的：const int constant = 21;
int* modifier = &constant 
// Error: invalid conversion from 'const int*' to 'int*'

（上边的代码在C中是可以编译的，最多会得到一个warning，所在在C中上一步就可以开始对constant里面的数据胡作非为了）

把constant交给非const的引用也是不行的。const int constant = 21;
int& modifier = constant;
// Error: invalid initialization of reference of type 'int&' from expression of type 'const int'

于是const_cast就出来消灭const，以求引起程序世界的混乱。

下边的代码就顺利编译功过了：const int constant = 21;
const int* const_p = &constant;
int* modifier = const_cast<int*>(const_p);
*modifier = 7;


传统转换方式实现const_cast运算符

我说过标：准转换运算符是可以用传统转换方式实现的。const_cast实现原因就在于C++对于指针的转换是任意的，它不会检查类型，任何指针之间都可以进行互相转换，因此const_cast就可以直接使用显示转换(int*)来代替：const int constant = 21;
const int* const_p = &constant;
int* modifier = (int*)(const_p);


或者我们还可以把他们合成一个语句，跳过中间变量，用const int constant = 21;
int* modifier = (int*)(&constant);


替代const int constant = 21;
int* modifier = const_cast<int*>(&constant);

为何要去除const限定

从前面代码中已经看到，我们不能对constant进行修改，但是我们可以对modifier进行重新赋值。

但是但是，程序世界真的混乱了吗？我们真的通过modifier修改了constatn的值了吗？修改const变量的数据真的是C++去const的目的吗？

如果我们把结果打印出来：cout << "constant: "<< constant <<endl;
cout << "const_p: "<< *const_p <<endl;
cout << "modifier: "<< *modifier <<endl;
/**
constant: 21
const_p: 7
modifier: 7
**/


constant还是保留了它原来的值。

可是它们的确指向了同一个地址呀：
cout << "constant: "<< &constant <<endl;
cout << "const_p: "<< const_p <<endl;
cout << "modifier: "<< modifier <<endl;

/**
constant: 0x7fff5fbff72c
const_p: 0x7fff5fbff72c
modifier: 0x7fff5fbff72c
**/


这真是一件奇怪的事情，但是这是件好事：说明C++里是const，就是const，外界千变万变，我就不变。不然真的会乱套了，const也没有存在的意义了。

IBM的C++指南称呼“*modifier = 7;”为“未定义行为（Undefined Behavior）”。所谓未定义，是说这个语句在标准C++中没有明确的规定，由编译器来决定如何处理。

位运算的左移操作也可算一种未定义行为，因为我们不确定是逻辑左移，还是算数左移。

再比如下边的语句：v[i] = i++; 也是一种未定义行为，因为我们不知道是先做自增，还是先用来找数组中的位置。

对于未定义行为，我们所能做的所要做的就是避免出现这样的语句。对于const数据我们更要这样保证：绝对不对const数据进行重新赋值。

如果我们不想修改const变量的值，那我们又为什么要去const呢？

原因是，我们可能调用了一个参数不是const的函数，而我们要传进去的实际参数确实const的，但是我们知道这个函数是不会对参数做修改的。于是我们就需要使用const_cast去除const限定，以便函数能够接受这个实际参数。

#include <iostream>
using namespace std;

void Printer (int* val,string seperator = "\n")
{
        cout << val<< seperator;
}

int main(void) 
{       
        const int consatant = 20;
        //Printer(consatant);//Error: invalid conversion from 'int' to 'int*'
        Printer(const_cast<int *>(&consatant));
        
        return 0;
}

出现这种情况的原因，可能是我们所调用的方法是别人写的。还有一种我能想到的原因，是出现在const对象想调用自身的非const方法的时候，因为在类定义中，const也可以作为函数重载的一个标示符。有机会，我会专门回顾一下我所知道const的用法，C++的const真的有太多可以说的了。

在IBM的C++指南中还提到了另一种可能需要去const的情况：

#include <iostream>
using namespace std;

int main(void) {
        int variable = 21;
        int* const_p = &variable;
        int* modifier = const_cast<int*>(const_p);
        
        *modifier = 7
        cout << "variable:" << variable << endl;
        
        return 0;
} 
/**
variable:7
**/

我们定义了一个非const的变量，但用带const限定的指针去指向它，在某一处我们突然又想修改了，可是我们手上只有指针，这时候我们可以去const来修改了。上边的代码结果也证实我们修改成功了。

不过我觉得这并不是一个好的设计，还是应该遵从这样的原则： 使用const_cast去除const限定的目的绝对不是为了修改它的内容，只是出于无奈。（如果真像我说是种无奈，似乎const_cast就不太有用到的时候了，但的确我也很少用到它）

• reinterpret_cast: 有着和C风格的强制转换同样的能力。它可以转化任何内置的数据类型为其他任何的数据类型，也可以转化任何指针类型为其他的类型。它甚至可以转化内置的数据类型为指针，无须考虑类型安全或者常量的情形。不到万不得已绝对不用。
• dynamic_cast: 

（1）其他三种都是编译时完成的，dynamic_cast是运行时处理的，运行时要进行类型检查。
（2）不能用于内置的基本数据类型的强制转换。
（3）dynamic_cast转换如果成功的话返回的是指向类的指针或引用，转换失败的话则会返回NULL。
（4）使用dynamic_cast进行转换的， 基类中一定要有虚函数 ，否则编译不通过。
         B中需要检测有虚函数的原因： 类中存在虚函数，就说明它有想要让基类指针或引用指向派生类对象的情况，此时转换才有意义。 
        这是由于运行时类型检查需要运行时类型信息，而这个信息存储在类的虚函数表（关于虚函数表的概念，详细可见<Inside c++ object model>）中，
        只有定义了虚函数的类才有虚函数表。
 （5）在类的转换时，在类层次间进行上行转换时，dynamic_cast和static_cast的效果是一样的。在进行下行转换时，dynamic_cast具有类型检查的功能，比               static_cast更安全。向上转换即为指向子类对象的向下转换，即将父类指针转化子类指针。向下转换的成功与否还与将要转换的类型有关，即要转换的指针指向的对象的实际类型与转换以后的对象类型一定要相同，否则转换失败。
参考例子:

复制代码代码如下:

#include<iostream> 
#include<cstring> 
using namespace std; 
class A 
{ 
   public: 
   virtual void f() 
   { 
       cout<<"hello"<<endl; 
       }; 
}; 

class B:public A 
{ 
    public: 
    void f() 
    { 
        cout<<"hello2"<<endl; 
        }; 

}; 

class C 
{ 
  void pp() 
  { 
      return; 
  } 
}; 

int fun() 
{ 
    return 1; 
} 
int main() 
{ 
    A* a1=new B;//a1是A类型的指针指向一个B类型的对象 
    A* a2=new A;//a2是A类型的指针指向一个A类型的对象 
    B* b; 
    C* c; 
    b=dynamic_cast<B*>(a1);//结果为not null，向下转换成功，a1之前指向的就是B类型的对象，所以可以转换成B类型的指针。 
    if(b==NULL) 
    { 
        cout<<"null"<<endl; 
    } 
    else
    { 
        cout<<"not null"<<endl; 
    } 
    b=dynamic_cast<B*>(a2);//结果为null，向下转换失败 
    if(b==NULL) 
    { 
        cout<<"null"<<endl; 
    } 
    else
    { 
        cout<<"not null"<<endl; 
    } 
    c=dynamic_cast<C*>(a);//结果为null，向下转换失败 
    if(c==NULL) 
    { 
        cout<<"null"<<endl; 
    } 
    else
    { 
        cout<<"not null"<<endl; 
    } 
    delete(a); 
    return 0; 

}