C++四种类型转换使用示例

C风格的强制类型转换很简单，均用Type b = (Type)a形式转换，C++风格的类型转换提供了4种类型转换操作符来应对不同场合的应用，例如：
转换类型操作符                作用
const_cast                       去掉类型的const或volatile属性
static_cast                       无条件转换，静态类型转换
dynamic_cast                  有条件转换，动态类型转换，运行时检查类型安全（转换失败返回NULL）
reinterpret_cast               仅重新解释类型，但没有进行进二进制的转换

下面来看具体的示例：

1、const_cast
去掉类型的const或volatile属性
const_cast<目标类型>（标识符）:目标类型只能是指针或者引用

#include <iostream>
#include <string>

struct STFile{
    std::string name;
};


int main()
{
    const STFile file;
    //file.name = "tree"; //直接修改const类型，编译错误
    STFile &fileName = const_cast<STFile&>(file);
    fileName.name = "red tree";
    std::cout << "fileName.name=======" << fileName.name << std::endl;

    STFile *fileName2 = const_cast<STFile*>(&file);
    fileName2->name = "black tree";
    std::cout << "fileName2->name=====" << fileName.name << std::endl;

    const int a = 3;
    //a = 47;  //直接修改报错
    int &x1 = const_cast<int&>(a);
    x1 = 52;
    std::cout << "a======" << a << " ===x1===" << x1 << std::endl;

    int *x2 = const_cast<int*>(&a);
    *x2 = 53;
    std::cout << "a======" << a << " ===x2===" << *x2 << std::endl;

    return 0;
}

2、static_cast
类似C风格的强制转换，进行无条件转换，静态类型转换：
1）基类和子类之间的转换：其中子类指针转换为父类指针是安全的，但父类指针转换为子类指针是不安全的（基类和子类之间的动态类型转换建议用dynamic_cast）。
2）基本数据类型转换，enum，struct，int，char，float等。static_cast不能进行无关类型（如非基类和子类）指针之间的转换。
3）把任何类型的表达式转换成void类型。
4）static_cast不能去掉类型的const、volatile属性（用const_cast）

#include <iostream>
#include <string>

class Car{
public:
    //void wheel() //是否为虚函数，影响后面的调用结果
    virtual void wheel()
    {
        std::cout << "parent===wheel======" << std::endl;
    }
};

class BenzCar: public Car{
public:
    std::string m_strName;
    void wheel() {
        std::cout << "Benz Car====wheel=====" << std::endl;
    }

    void carName(){
        std::cout << "Benz Car=====name==========" << std::endl;
    }
};

int main()
{
    int n1 = 9;
    double d1 = static_cast<double>(n1);//基本类型转换
    std::cout << "n1===" << n1 << " d1===" << d1 << std::endl;
    int *pn = &n1;
    //double *pd = static_cast<double*>(&n1);//无关类型，不能转换
    void *pv = static_cast<void*>(pn);
    std::cout << "pn======" << pn << "  pv====" << pv << std::endl;
    //======================================
    Car *car = new Car();
    car->wheel();

    //父类指针转子类指针
    BenzCar *benzCar = static_cast<BenzCar*>(car);
    benzCar->wheel();
    benzCar->m_strName = "beaf";//访问m_strName越界

    //子类指针转父类指针
    BenzCar *benzCar2 = new BenzCar();
    Car *car2 = static_cast<Car*>(benzCar2);
    //如果是虚函数，调用的是new 对象的函数, 如果是普通成员函数调用的是转化后对象的函数
    car2->wheel();
    std::cout << "Hello world!" << std::endl;
    return 0;
}

3、dynamic_cast
有条件转换，动态类型转换，运行时检查类型安全（转换失败返回NULL）：
1）安全的基类和子类之间的转换。
2）必须有虚函数。
3）相同基类不同子类之间的交叉转换，但结果返回NULL。

#include <iostream>
#include <string>
class CBase{
public:
    int m_n;
    virtual void print()//基类必须有虚函数。保持多态特性才能使用dynamic_cast
    {
        std::cout << "CBase====print====" << std::endl;
    }

    virtual ~CBase()
    {

    }
};

class CSub: public CBase{
public:
    std::string m_str;
    void print()
    {
        std::cout << "print====name====" << m_str << std::endl;
    }
};


int main()
{
    CBase *pb = new CSub();
    pb->print();
    CSub *ps1 = dynamic_cast<CSub*>(pb);
    ps1->m_str = "camel";
    ps1->print();
    std::cout << "pb===" << pb << " ps1===" << ps1 << std::endl;
    std::cout << "=====================" << std::endl;

    CSub *sub = new CSub();
    sub->print();
    CBase *ps2 = dynamic_cast<CBase*>(sub);
    ps2->print();
    std::cout << "sub==" << sub << " ps2==" << ps2 << std::endl;
    std::cout << "=====================" << std::endl;

    CBase *pb2 = new CBase();
    pb->print();
    CSub *ps3 = static_cast<CSub*>(pb2);//父类==》子类，静态类型转换
    std::cout << "pb2==" << pb2 << " ps3==" << ps3 << std::endl;
    //ps3->m_str = "camle222"; //危险！访问子类m_str成员越界
    ps3->print();
    CSub *ps4 = dynamic_cast<CSub*>(pb2);//父类==》子类，动态类型转换，安全，但结果为NULL
    if(nullptr == ps4)
    {
        std::cout << "ps4=======" << ps4 << std::endl;
    }
    else
    {
        ps4->print();
    }

    return 0;
}

4、reinterpret_cast
仅重新解释类型，但没有进行二进制的转换：
1）转换的类型必须是一个指针，应用、算术类型、函数指针或者成员指针。
2）在比特级别上进行转换，可以把一个指针转换成一个整数，
也可以把一个整数转换成一个指针（先把一个指针转换成一个整数，
在把该整数转换成原类型的指针，还可以得到原先的指针值）。但不能将非32bit的实例转成指针。
3） 最普通的用途就是在函数指针类型之间进行转换。
4） 很难保证移植性。

#include <iostream>
#include <string>

int funTest1()
{
    std::cout << "funTest1======" << std::endl;
    return 2;
}

int funTest2(int n)
{
    std::cout << "funTest2======" << n << std::endl;
    return n;
}

int main()
{
    typedef void(*FuncPtr)();
    FuncPtr funPtrArray[10];
    //funPtrArray[0] = &funTest1;//编译错误！类型不匹配
    funPtrArray[0] = reinterpret_cast<FuncPtr>(&funTest1);
    funPtrArray[0]();//调用
    std::cout << "funPtrArray[0]=" << &funPtrArray[0] << " funTest1=" << funTest1
              << " &funTest1=" << &funTest1 << std::endl;

    funPtrArray[1] = reinterpret_cast<FuncPtr>(&funTest2);
    funPtrArray[1]();//成功转换，但调用不是想要的结果
    std::cout << "funPtrArray[1]=" << &funPtrArray[1] << " funTest2=" << funTest2
              << " &funTest2=" << &funTest2 << std::endl;
    return 0;
}