C++进阶--类型转换，你看我就够了

C/C++编程中，通常会需要对类型进行转换，以符合编程需要。在C语言中，有两种转换方式：隐式转换和强制类型转换。那么C++中有哪些方式呢。

static_cast 静态类型转换
reinterpret_cast 重解析类型转换
dynamic_cast 动态类型转换
const_cast 去只读属性转换

下面，我们来一一介绍他们的使用场景和使用方法。

静态类型转换

static_cast静态类型转换，一般用在比如int和char的转换上，也就是说，只要C语言中能够隐式转换的所有类型都可以使用static_cast进行转换。如果类型不能兼容，编译阶段会报错。

能使用隐式转换的地方，均可以使用static_cast转换
如果类型不兼容，使用static_cast编译检查，会报错

int main(int argc, const char * argv[]) {

    double dpi = 3.1415926;
     //C类型转换
    int num1 = (int)dpi;  
    
    //静态类型转换                  
    int num2 = static_cast<int>(dpi); 
     
    //C语言中，隐式类型转换的地方均可使用 static_cast<>()进行转换     
    int num3 = dpi; 
    
    //静态类型转换，编译器会做类型检查,类型不兼容,会报错 
    char *p1  = "hello world";                       
    int  *p2  = static_cast<int *>(p1);    
    
    return 0;
}

重解析类型转换

我们可以使用statci_cast来替代隐式转换。但是如果碰到上述类型不兼容的情况，C语言可以使用(int)a强制类型转换来处理，那么C++该如何处理呢？

C++中可以通过重解析类型转换reinterpret_cast来实现C语言的强制类型转换的效果。C++会将类型进行重新解析，转换成你需要的类型，不考虑转换后的后果。

int main(int argc, const char * argv[]) {

    //重解析类型转换，前置进行类型转换 
    char *p1  = "hello world";                       
    int  *p2  = reinterpret_cast<int *>(p1);
    
    cout<<p1<<endl;
    cout<<p2<<endl;
    
    return 0;
}

<a name="fenced-code-block">小结</a>

通过静态类型转换和重解析类型转换完全可以替代C语言中的隐式转换和强制类型转换。

动态类型转换

dynamic_cast动态类型转换一般是用在父类和子类的转换上。一个典型的应用场景类似于Objecive-C语言中的isKindOfClass方法，可以动态的来判断当前对象的真实类型。

#include <iostream>
using namespace std;

class Animal {
public:
    virtual void cry() = 0;
};

class Dog : public Animal {
    
public:
    void cry()
    {
        cout<<"狗叫"<<endl;
    }
    
    void todo()
    {
        cout<<"看门"<<endl;
    }
};


class Cat : public Animal{
    
public:
    void cry()
    {
        cout<<"猫叫"<<endl;
    }
    
    void doSome()
    {
        cout<<"睡懒觉"<<endl;
    }
};

void test(Animal *base)
{
    base->cry();
    
    //强制转换成Dog类，如果转换不成功说明当前传入的实际类型是Cat类
    Dog *dog = dynamic_cast<Dog *>(base);
    if (dog != NULL) {
        //说明，当前传入对象的实际类型是Dog类
        dog->todo();
    }
    
    //强制转换成Cat类，如果转换不成功说明当前传入的实际类型是Dog类
    Cat *cat = dynamic_cast<Cat *>(base);
    if (cat != NULL) {
        //说明，当前传入的对象的实际类型是Cat类
        cat->doSome();
    }
}


int main()
{
    
    Dog dog;
    Cat cat;
    
    Animal *animal = &dog;
    
    test(animal);
    
    return 0;
}

在上面的例子中，是将父类动态转换成子类。可以通过dynamic_cast来抓换，从而动态的确认当前传入对象的实际类型。

去只读属性转换

C++中const关键字声明的对象，一般是常量，不能对其直接进行修改。如果想要对传入的const对象进行修改，需要将当前对象进行去只读属性，从而进行更改。

#include <iostream>
using namespace std;


void changeWord(const char *buf)
{
    //报错，提示当前是常量，不能修改
    buf[0] = '9';
}

int main()
{
    char buf[] = "123456789";
    
    changeWord(buf);
    
    cout<<buf<<endl;
    
    return 0;
}

编译上述代码后，会报错，提示buf是只读的。如果我们想要修改怎么办？可以使用const_cast转换，从而可以修改。修改后的changeWord方法如下。

void changeWord(const char *buf)
{
    //使用const_cast转换去常量化，再进行修改
    char *tmp = const_cast<char *>(buf);
    tmp[0] = '9';
}

通过const_cast可以将只读属性去掉，修改对应的数据。但是需要注意的是，当前的指针直线的内存空间是可读的。比如说:如果传给changeWord是一个常量，只能读，不能改。

void changeWord(const char *buf)
{
    //此时buf指向的数据是一个常量，不仅仅是只读属性
    //const char *buf = "123456789" 常量不可更改
    //使用const_cast转换去只读属性，仍然不能进行修改
    char *tmp = const_cast<char *>(buf);
    tmp[0] = '9';
}

int main()
{
    //是字符串指针
    char *buf = "123456789";
    
    changeWord(buf);
    
    cout<<buf<<endl;
    
    return 0;
}