强制类型转换

C++中的强制类型转换：static_cast、reinterpret_cast、const_cast、dynamic_cast.

static_cast：用于非多态类型之间的转换(静态转换)，任何标准类型之间都可以用它，但它不能用于不相关类型之间的转换。static_cast只能用于相关类型之间的转换。
例：
       int i = 2;
       double d = static_cast<double>(i); //正确，相关类型转换      
       int *p = &i;
       double d = static_cast<double>(p);//错误，不能转换，不想关类型



reinterpret_cast：操作符用于将一种类型转换成另一种不同的类型.
例：
typedef void(*FUNC)();
int DoSomthing(int i)
{
       cout << "DoSomthing():" << i << endl;
       return 0;
}
void test()
{
       FUNC pf = reinterpret_cast<FUNC>(DoSomthing);
       pf();
}
reinterpret_cast：可以让编译器以FUNC的定义方式去看待DoSomething函数，不过这样有时会产生不确定的结果。总而言之，reinterpret_cast非常的BUG。


const_cast：最常见的用途就是删除变量的const属性，方便赋值。
例：
void test()
{
       const int i = 10;
       int* b =const_cast<int *>(&i);
       *b = 20;
       cout << i << endl;      //结果是10，因为编译器有优化，所以会到寄存器中取值
       cout << *b << endl;     //结果是20，b指向内存中的i,改的是内存中的值
}

void test()
{
       volatile const int i = 10;   
       int* b =const_cast<int *>(&i);
       *b = 20;
       cout << i << endl;      //结果是20,因为volatile保证内存可见性
       cout << *b << endl;    
}

dynamic_cast：用于将一个父类对象的指针或引用转换成子类对象的指针或引用。
1、dynamic_cast只能用于含有虚函数的类
2、如果父类指针指向的是父类对象，则会返回0，如果父类指针指向子类对象，则转化成功。
例：
void test()
{
       A a;
       B b;
       A *pa = &a;  //正确，父类指针指向父类对象
       pa = &b;     //正确，父类指针指向子类对象
       //B *pb = &a;  //c错误，子类指针指向父类对象
       B *pb = &b;      //正确，子类指针指向子类对象
}

void fun(A *pa)
{
       B *pb = dynamic_cast<B *>(pa);        //如果pa指向父类对象，则返回0，如果指向子类对象，成功转换
       cout << "pb1:" << pb<< endl;
}
void test()
{
       A a;
       B b;
       fun(&a);           
       cout << &a << endl;
       fun(&b);
       cout << &b<< endl;
}

explicit：防止经过构造函数进行的隐式类型转换
例：
class A
{
public:
       A(int a)
              :_a(0){}
       A(const A& a)
       {
       }
private:
       int _a;
};
void test()
{
       A a1(1);  //直接初始化
       //1隐式转换成 A tmp(1),A a2(tmp)
       A a2 = 1;       //正确
}


class A
{
public:
       explicit A(int a)
              :_a(0){}
       A(const A& a)
       {
       }
private:
       int _a;
};
void test()
{
       A a1(1);  //直接初始化
       //1隐式转换成 A tmp(1),A a2(tmp)
       A a2 = 1;    //错误
}
如果不希望生成中间对象的话，可以在构造函数前面声明explicit.