深入理解C++类型转换

最新推荐文章于 2023-08-28 20:00:01 发布

屮武松屮

最新推荐文章于 2023-08-28 20:00:01 发布

阅读量1.2k

点赞数

分类专栏：国产操作系统文章标签： c++ 开发语言后端

本文链接：https://blog.csdn.net/qq_40781444/article/details/121284021

版权

国产操作系统专栏收录该内容

4 篇文章 0 订阅

订阅专栏

一.隐式转换

C++本身提供的类型转换分为隐式和显式两种类型。其中隐式转换主要是指：

①算术转换：如int+double之后，算术结果会完成从int到高精度的double的转换。

②表达式转换：int iVal = double dVal, dVal会完成从double到int 的转换。
③实参调用转换：将double型输入要求int型输入的函数里，完成该转换。

void f(int i)
{};
double d = 2.00;
f(d);

这段代码中，d在作为实参进入f函数时，完成了从double到int的转换。

④返回值转换：函数返回值类型与输入值类型不匹配，系统自动转换。

double difference(int ival1, int ival2)
{
    return ival1 - ival2;
    //返回值被提升为double类型
}

之所以叫隐式转换，是因为我们在操作的过程中，类型的转换完全是由编译器后台完成了，而作为用户的我们实际上看不到这个转换的过程，也无须介入转换的执行。

引用一段《C++primer》的原文：

除了以上情况，另外还有：

数据类型向指针的转换：

int i[10];int *ip = i;//在这段代码中，数组i被转换成了指针ip

指针之间的转换：

比如Nullptr空白指针可以被转换为任意指针类型。

非常量到常量的转换：

int i;
const int &j  = i;//非常量数据类型转换为常量引用
const int *p  = &i;//非常量引用转换为const 地址

以上是隐式转换的常见场景。

隐式转换一般被认为是安全的，因为它转换的两种对象之间存在关联关系。而当你将无关联关系的对象进行互相转换时，编译器会报错，从而阻止转换的发生。隐式转换无需人为干涉，转换的过程被隐藏。

二.显式转换

上文我们说到，隐式转换一般用于存在关联关系的两个对象之间的转换，例如double和int之间的转换。

有时候面对没有关联关系的两者，我们需要对它们进行强制性的转换。这种转换可以直接在代码上进行体现：

int i，j；
double result = double( i/j );// i/j本质还是int型，需要加double强制转换成double型

代码中的double（）就是一种显式的强制转换，这类强制转换叫做cast。

显示转换的标准格式：cast-name<type>(expression)

cast-name: 转换形式 <type> : 转换类型 (expression) : 转换对象

显示转换一共提供了四种转换形式，static-cast,const-cast,dynamic-cast和reinterpret-cast。

1.static-cast

CheckStaticCast - Check that a static_cast(SrcExpr) is valid.Refer to C++ 5.2.9 for details. Static casts are mostly used for making implicit conversions explicit and getting rid of data loss warnings.—[Clang源码]

根据Clang源码的解释，static_cast<>大部分情况下用于对隐式转换的显示化，同时去掉相关warning报警。

什么意思呢，比方我有一个double型变量，我想把它转换成int型，这时候我只需要写：

i = d 就行了，编译能够通过，运行也毫无问题，只是编译器会给出一个warning提示，告诉你将double转换到int时损失了精度。

所以你可以使用 i = static_cast<int>(d) 这种写法，来消除编译器给出的warning提示，完成一次强制显式转换。

需要注意的是，static_cast并不是能转换所有类型，当毫无关联的两个类之间进行相互转换时，即使使用static_cast也不会通过。

class A{
    type a;
};

class B{
    type b;
};

int MyMain(A a, B b){
    b = static_cast<B>(a);
    //上一行编译器会报错，阻止两个毫无关联类之间的转换
}

因为在逻辑上，A和B是两个毫不相关的类。但是如果定义了明确的类型定义后，这种不同对象之间的转换就是允许的。例如给Class B添加了类型为A的单参数构造函数后，就可以编译通过。

class A{
    type a;
};

class B{
    public:
        B(const A& lhs) {}
};
int MyMain()
{
    A a;
    // static_cast<B>(a)直接调用B(const A& lhs)构造函数
    B b = static_cast<B>(a);
    // 编译通过，转换完成
}

如果一个构造函数只接受一个实参，则它实际上定义了转换此类类型的隐式转换机制，有时我们把这种构造函数称作转换构造函数（converting constructor）。 —-Primer 5th

在上一段代码中，B的构造函数实际只有A一个实参，因此可以对类型A进行强制转换，完成到B的转换过程。

2.const_cast

static_cast并不是万能的，除了不能对毫无关联的类进行转换外，也不能对const修饰的常量进行转换。

因此引申出了const_cast转换类型，顾名思义，用于去除被const修饰的对象的const属性。

需要注意的是，const_cast只能改变运算对象的底层const。const_cast不能改变表达式的类型，也不能改变变量本身。

什么意思呢，以下用一段代码来说明const_cast的作用：

using namespace std;

int main(int argc, CHAR* argv[])
{        
        const int val=13; // 定义一个常量数值
        int temp=15; // 定义一个非常量数值
        const int* ptr=&temp; // 定义一个常量指针指向非常数值
        int* p=const_cast<int*>(ptr); // 执行解常量转换
        *p = 16; // 改地址成功
        //        (*ptr)++;    // 失败，解除引用的值依旧是const
        ptr++;                 // 成功，说明指针已经不是常量了
        //        (*ptr)++;    // 失败，指针+1了，指向下一个地址了，但其解除引用后依旧是const
        ptr--;                 // 成功，同上
        
        return 0;
}

很明显，const_cast对于指针的解常量是有用的，但是并不会改变常量本身的数值，只能把指向数值的常量指针解除常量属性以改指向另一个地址。

Class B{
   int m_iNum = 0;
}

int MyMain{

	const B *b1 = new B();
	//b1->m_iNum = 1;          // 编译错误,因为b1是常量指针，指向的地址无法更改

	B *b2 = const_cast<B*>(b1);// 解常量属性
	b2->m_iNum = 1;            // 修改成功

    // 此时b1和b2都为1

 
	const B b3;
	//b3.m_iNum = 1;     // error,常量无法修改
	B b4 = const_cast<B&>(b3);          // 解除数值本身的常量属性
	b4.m_iNum = 1;
    
    // 此时，b3 = 0， b4 = 1
    // 常量引用被转换成非常量引用，但是仍然指向原来的对象；
 
	const B b5;
	//b5.m_iNum = 1;     // error
 
	// 左侧也可以用引用类型，如果对b6的数据成员做改变，就是对b5的值在做改变
	B &b6 = const_cast<B&>(b5);
	b6.m_iNum = 1;
	
    // 此时， b5 = 1， b6 = 1
    // 解除常量属性后，使用引用方式直接改变数值本身

    return 0;
}

因此，const_cast的用法可以总结为：

　　一、常量指针被转化成非常量指针，并且仍然指向原来的对象；
　　二、常量引用被转换成非常量引用，并且仍然指向原来的对象；
　　三、常量对象被转换成非常量对象。

3.dynamic_cast

dynamic_cast主要用于类层次间的上行转换和下行转换，以及类之间的交叉转换。

同样举个例子说明：

class Basic{
    public:
        virtual int funcA();
}
// 以上定义一个基类


class ChildrenA : public Basic{

    public:
        int funcChildrenA();
}


int MyMain(){
    Basic b;
    childrenA * a =  dynamic_cast< Children* > b;
}

在实际的生产中，基类往往是随着动态库一起封装在头文件里给开发者使用的。这个时候基类是不能进行扩展的，失去了虚函数的衍生性支持，开发者想要在基类上拓展功能，可以选择将新建的基类用dynamic_cast进行转换变成子类，同时在其它地方实现子类自定义的函数 funcchildrenA。

那么你可能要问了，static_cast也能实现这个功能，所以

static_cast 和 dynamic_cast 的区别是什么？

回到以上那段代码：

int MyMain(){
    Basic b = new Children;
    ChildrenA * a =  dynamic_cast< Children* > b;
    ChildrenA * c =  static_cast< Children* > b;
}

在上面的代码段中，如果b实际指向一个Children 类型的对象，a 和 c 是一样的，并且对这两个指针执行Children类型的任何操作都是安全的；
如果b实际指向的是一个Basic类型的对象(如图中例子），那么a将是一个指向该对象的指针，对它进行Children类型的操作将是不安全的，而c将是一个空指针(即nullptr，因为dynamic_cast失败)。

因此，对以上代码进行修改：

int MyMain(){
    Basic b = new Basic;
    ChildrenA * a =  dynamic_cast< Children* > b;// 通过
    // ChildrenA * c =  static_cast< Children* > b;// 直接报错
}

另外要注意：b 要有虚函数，否则会编译出错；static_cast则没有这个限制。

这是由于运行时类型检查需要运行时类型信息，而这个信息存储在类的虚函数表（关于虚函数表的概念，详细可见<Inside c++ object model>）中，只有定义了虚函数的类才有虚函数表，没有定义虚函数的类是没有虚函数表的。

这块博主不过多做解释，直接一个百度百科的复制粘贴：

在C++的面对对象思想中，虚函数起到了很关键的作用，当一个类中拥有至少一个虚函数，那么编译器就会构建出一个虚函数表(virtual method table)来指示这些函数的地址，假如继承该类的子类定义并实现了一个同名并具有同样函数签名（function siguature）的方法重写了基类中的方法，那么虚函数表会将该函数指向新的地址。此时多态性就体现出来了：当我们将基类的指针或引用指向子类的对象的时候，调用方法时，就会顺着虚函数表找到对应子类的方法而非基类的方法。

当然虚函数表的存在对于效率上会有一定的影响，首先构建虚函数表需要时间，根据虚函数表寻到到函数也需要时间。

因为这个原因如果没有继承的需要，一般不必在类中定义虚函数。但是对于继承来说，虚函数就变得很重要了，这不仅仅是实现多态性的一个重要标志，同时也是dynamic_cast转换能够进行的前提条件。

假如去掉上个例子中Stranger类析构函数前的virtual，那么语句

Children* child_r =dynamic_cast<Children*> (stranger_r);

在编译期就会直接报出错误，具体原因不是很清楚，我猜测可能是因为当类没有虚函数表的时候，dynamic_cast就不能用RTTI来确定类的具体类型，于是就直接不通过编译。

这不仅仅是没有继承关系的类之间的情况，如果基类或者子类没有任何虚函数（如果基类有虚函数表，子类当然是自动继承了该表），当他们作为dynamic_cast的源类型进行转换时，编译也会失败。

这种情况是有可能存在的，因为在设计的时候，我们可能不需要让子类重写任何基类的方法。但实际上，这是不合理的。导师在讲解多态性的时候，时刻强调了一点：如果要用继承，那么一定要让析构函数是虚函数；如果一个函数是虚函数，那么在子类中也要是虚函数。

总结：dynamic_cast 用于实现拥有虚函数的基类向子类的继承转换，以及子类之间的交叉转换。

4.reinterpret_cast

本来想写的，但是我下班了，所以有空再补充。

屮武松屮

关注

0
点赞
踩
1

收藏

觉得还不错? 一键收藏
0
评论
深入理解C++类型转换

一.隐式转换 C++本身提供的类型转换分为隐式和显式两种类型。其中隐式转换主要是指： ①算术转换：如int+double之后，算术结果会完成从int到高精度的double的转换。 ②表达式转换：int iVal = double dVal, dVal会完成从double到int 的转换。 ③实参调用转换：将double型输入要求int型输入的函数里，完成该转换。void f(int i){};double d = 2.00;f...
复制链接

扫一扫

专栏目录