C++四种case的详细介绍小结

时间：2022-12-09 09:56:47|栏目：C代码|点击：次

在C++中，我们经常使用到类型的转换，像把一个int类型转换成char类型，一个int类型转换成double类型，这些转换属于隐式类型转换。而今天我们要来讲的是显式类型转换。C++提供了四种显式类型转换，分别是：static_cast、dynamic_cast、const_case、reinterpret_case。

一、static_case

static_case的定义为：

static_case<type_name>(expression)

type_name是转换的类型，expression是被转换的对象或者表达式。

static_case一般用于隐式转换，当type_name和express至少有一方可以隐式转换时，则可以用static进行强制类型转换。可以用于常见的int、float、double等类型转换；转换成功返回true，否则返回false（相当于C语言中的强制类型转换）。

1、基本数据类型转换

double serven_double_1 = 1.2;
std::cout<<serven_double_1<<std::endl;
 
int serven_int_1 = static_cast<int>(serven_double_1);
std::cout<<serven_int_1<<std::endl;
 
double serven_double_2 = static_cast<double>(serven_int_1);
std::cout<<serven_double_2<<std::endl;

运行结果：基本类型的转换，可以看到double类型转换成int类型后丢失了精度，这一点跟reinterpret_case不一样，reinterpret_case是底层二进制的强制拷贝和语义转换，所以不会丢失精度，后面会讲到。

2、指针和void指针的转换

int* serven_int_2 = new int(2);
void * serven_void_1 = static_cast<void*>(serven_int_2);
int *serven_int_3 = static_cast<int*>(serven_void_1);
*serven_int_2 = 6;
 
std::cout<<*serven_int_2<<std::endl;
std::cout<<*serven_int_3<<std::endl;
std::cout<<serven_void_1<<std::endl;
std::cout<<serven_int_2<<std::endl;
std::cout<<serven_int_3<<std::endl;

运行结果：void指针和其他类型的指针进行转化的时候，他们都是指向同一个地址。

3、父类和子类之间的转换

class SERVEN_PARENT{
public:
    SERVEN_PARENT(){}
    void Function(){
        std::cout<<"PARENT"<<std::endl;
    }
};
 
class SERVEN_CHILD : public SERVEN_PARENT{
public:
    SERVEN_CHILD(){}
    void Function(){
        std::cout<<"CHILD"<<std::endl;
    }
};
 
 
void main(){
 
    SERVEN_PARENT* ser_par = new SERVEN_PARENT();
    ser_par->Function();
    SERVEN_CHILD* ser_chi = static_cast<SERVEN_CHILD*>(ser_par);
    ser_chi->Function();
 
}

运行结果：在main函数第二行中定义了一个ser_chi，是一个派生类对象，然后强制将基类对象转换成子类，这种叫做下行转换，转换后打印的结果是子类的Function，使用static_case来进行向下转换是不安全的，因为当子类中定义了基类没有的变量，并且在Function函数中使用了这个变量，那么程序将会报错。

下面我们来看一下static_case不安全的例子：

class SERVEN_PARENT{
public:
    SERVEN_PARENT(){}
    void Function(){
        std::cout<<"PARENT"<<std::endl;
    }
};
 
class SERVEN_CHILD : public SERVEN_PARENT{
public:
    SERVEN_CHILD(){}
    void Function(){
        std::cout<<"CHILD"<<std::endl;
        std::cout<<nums<<std::endl;
    }
 
private:
    char nums = 'g';
};
 
 
void main(){
 
    SERVEN_PARENT* ser_par = new SERVEN_PARENT();
    ser_par->Function();
    SERVEN_CHILD* ser_chi = static_cast<SERVEN_CHILD*>(ser_par);
    ser_chi->Function();
 
}

运行结果：因为派生类对象使用了自己独有的变量，所以打印char字符的时候就出现了乱码。

二、dynamic_case

dynamic_case的定义为：

dynamic<type_name>(expression)

type_name是转换的类型，expression是被转换的对象或者表达式。

dynamic一般用于基类指向派生类时的强制转换，转换成功返回true，失败返回false。它不像static_case一样向下转换不安全，它是安全的。它的安全性体现在RTTI，那什么是RTTI呢？
RTTI是运行时类型识别。程序能够使用基类的指针或引用来检查着这些指针或引用所指的对象的实际派生类型（判断指针原型）。RTTI提供了两个非常有用的操作符：typeid和dynamic_cast。（三个最主要的东西，dynamic_cast,typeid,type_info）。typeid:typeid函数（为type_info类的友元函数，为什么要这样呢？目的是防止创建type_info对象）的主要作用就是让用户知道当前的变量是什么类型的,它可以返回一个type_info的引用，可以获取类的名称和编码typeid重载了type_info中的==和!=可以用于判断两个类型是否相等。
dynamic_case和static_case在类继承的区别就是dynamic_case向下转换是安全的。

三、const_case

const_case的定义为:

const_case<type_name>(expression)

type_name是转换的类型，expression是被转换的对象或者表达式。

const_case有两个功能，分别是去掉const和加上const，一般用于去掉const，修改被const修饰为常量的值。但是修改的这个值本身不能是const常量，而是被二次引用或者传参数时被引用为const，才能修改，否则修改失败。同时type和express两个类型要一直去掉const，修改成功返回true，否则返回false。

1、加上const

int* serven_int_4 = new int(2);
const int* serven_int_5 = const_cast<const int*>(serven_int_4);     // 转换为常量指针
*serven_int_4 = 3;
//*serven_int_5 = 4;              // 不能修改
std::cout<<*serven_int_4<<std::endl;
std::cout<<*serven_int_5<<std::endl;
std::cout<<serven_int_4<<std::endl;
std::cout<<serven_int_5<<std::endl;

2、去掉const

（1）const修饰指针，指针指向一个类对象（常量指针）

将一个常量指针转换成非常量指针。

class SERVEN_PARENT{
public:
    SERVEN_PARENT(){}
    void Function(){
        std::cout<<"PARENT"<<std::endl;
    }
};
 
class SERVEN_CHILD : public SERVEN_PARENT{
public:
    SERVEN_CHILD(){}
    void Function(){
        std::cout<<"CHILD"<<std::endl;
        std::cout<<nums<<std::endl;
    }
 
private:
    char nums = 'g';
};
 
void main(){
    SERVEN_PARENT ser_par;
    const SERVEN_PARENT* pP = &ser_par;
    SERVEN_PARENT* pP_1 = const_case<SERVEN_PARENT*>(pP);    // 强制将pP转换成非const
    
}

（2）const修饰指针指向对象的数值（指针常量）

将指针常量转换为非指针常量。

void main(){
    SERVEN_PARENT ser_par;
    SERVEN_PARENT* const pP = &ser_par;
    SERVEN_PARENT* pP_1 = const_case<SERVEN_PARENT*>(pP);    // 强制将pP转换成非const
    
}

（3）const修饰指针指向对象的数值并且修饰指针（常量指针常量）

常量指针常量可以被转换为非常量指针常量，也可以转换成指针常量或者常量指针。

void main(){
    SERVEN_PARENT ser_par;
    const SERVEN_PARENT* const pP = &ser_par;
    SERVEN_PARENT* pP_1 = const_case<SERVEN_PARENT*>(pP);    // 强制将pP转换成非const
    const SERVEN_PARENT* pP_2 = const_case<SERVEN_PARENT*>(pP);    // 强制将pP转换成常量指针
    SERVEN_PARENT* const pP_2 = const_case<SERVEN_PARENT*>(pP);    // 强制将pP转换成指针常量
 
    
}

四、reinterpret_case

reinterpret_case的定义为：

reinterpret_case<type_name>(expression)

type_name是转换的类型，expression是被转换的对象或者表达式。

reinterpret_case是一种比较粗暴的转换方式，并且是最不安全的，为什么说它粗暴呢？因为它直接去拷贝最底层的二进制，它的本质是编译器的指令，它的作用是可以把一个指针转换成一个整数，也可以把一个整数转换成一个指针。或者不同类型的指针相互转换。

double serven_double_2 = 1.20;
char* serven_char_1 = reinterpret_cast<char* >(&serven_double_2);
double* serven_double_3 = reinterpret_cast<double*>(serven_char_1);
std::cout<<*serven_double_3<<std::endl;
 
int* serven_int_6 = reinterpret_cast<int*>(&serven_double_2);
double* serven_double_4 = reinterpret_cast<double*>(serven_int_6);
std::cout<<*serven_double_3<<std::endl;

运行结果：我们可以看到reinterpret_case将double类型转换成int，再转换成double类型后精度不会丢失，而static_case会丢失。