【C++】类型转换

类型转换

void Test ()
{
    int i = 1;
    double d = i; // 隐式类型转换
    printf("%d, %.2f\n" , i, d);

    int* p = &i;// 显示的强制类型转换
    int address = (int) p;

    printf("%x, %d\n" , p, address);
}

C++强制类型转换

static_cast/reinterpret_cast/const_cast/dynamic_cast

static_cast

static_cast用于非多态类型的转换（静态转换），任何标准转换都可以用它，但它不能用于两个不相关的类型进行转换。

void Test ()
{
     int i = 1;
     double d = static_cast< double>(i );
     printf("%d, %.2f\n" , i, d);
}

reinterpret_cast

reinterpret_cast操作符用于将一种类型转换为另一种不同的类型。

typedef void (* FUNC)();

int DoSomething (int i)
{
     cout<<"DoSomething" <<endl;
     return 0;
}
void Test ()
{

     FUNC f = reinterpret_cast< FUNC>(DoSomething );
     f();
}

reinterpret_cast可以编译器以FUNC的定义方式去看待 DoSomething函数，所以非常的BUG，下面转换函数指针的代码是不可移植的，所以不建议这样用。C++不保证所有的函数指针都被一样的使用，所以这样用有时会产生不确定的结果。

const_cast

const_cast最常用的用途就是删除变量的const属性，方便赋值。

void Test ()
{
     const int a = 2;
     int* p = const_cast< int*>(&a );
     *p = 3;

     cout<<a <<endl;
}

dynamic_cast

dynamic_cast用于将一个父类对象的指针转换为子类对象的指针或引用（动态转换）
向上转型：子类对象指针->父类指针/引用（不需要转换）
向下转型：父类对象指针->子类指针/引用（用dynamic_cast转型是安全的）

dynamic_cast只能用于含有虚函数的类
dynamic_cast会先检查是否能转换成功，能成功则转换，不能则返回0

class A
{
public :
     virtual void f(){}
};

class B : public A
{};

void fun (A* pa)
{
   // dynamic_cast会先检查是否能转换成功，能成功则转换，不能则返回
   B* pb1 = static_cast<B*>(pa);
   B* pb2 = dynamic_cast<B*>(pa);


   cout<<"pb1:" <<pb1<< endl;
   cout<<"pb2:" <<pb2<< endl;
}

int main ()
{
     A a;
     B b;
     fun(&a);
     fun(&b);
     return 0;
}

explicit关键字

explicit关键字阻止经过转换构造函数进行的隐式转换的发生。

class A
{
public :
     explicit A (int a)
    {
         cout<<"A(int a)" <<endl;
    }

     A(const A& a)
    {
         cout<<"A(const A& a)" <<endl;
    }
private :
     int _a ;
};

int main ()
{
     A a1 (1);

     // 隐式转换-> A tmp(1); A a2(tmp);
     A a2 = 1;
}