C++类对象的隐式类型转换和编译器返回值优化

文章目录

前言
1. 隐式类型转换
- 1.1 单参数的隐式类型转换
- 1.2 多参数的隐式类型转换
- 1.3 explicit关键字
2. 编译器的优化
- 2.1 普通构造优化
- 2.2 函数传参优化
- 2.3 函数返回优化

前言

在类与对象的学习过程中，一定会对隐式类型转换这个词不陌生。对于内置类型而言，相似的类型会支持隐式类型转换，例如int a = 3.1;在这篇文章我们细细谈谈类对象中的隐式类型转换：

类对象的隐式类型转换
编译器的优化

注意：这里的讨论，没有考虑右值。

1. 隐式类型转换

关于隐式类型转换产生临时变量，我在类型转换细节中有谈到，大家可以先阅读一下。

1.1 单参数的隐式类型转换

C++11之前，C++98仅仅支持单参数的隐式类型转换，当然这种转换也带来了很多的便利！同时也有潜在危险，需要合理看待！

为了方便测试，我们在VS2022下，给出以下的A类：

#include<iostream>
using namespace std;
class A
{
public:A(int a = 1):_a(a){cout << "A(int a = 1)" << endl;}~A(){cout << "~A()" << endl;}A(const A& a){cout << "A(const A& a)" << endl;}A& operator=(const A& a){cout << "A& operator=(const A& a)" << endl;return *this;}//暂时不考虑移动构造和移动赋值int _a;
};

在大多数时候，我们会写出这样的代码, 例1.1.1：

int main()
{A a = 1; //直接以1来赋值这个a类对象return 0;
}

这个过程会发生什么呢？

编译器会先利用1来构造一个A类的tmp对象。
再调用a的对象的拷贝构造函数。

（但似乎这样的代价也太大了，所以编译器会做出优化，我们稍后再谈）

当我们在使用STL的时候，也常常会发生这种隐式类型的转换，例如：

#include<iostream>
#include<string>
#include<vector>
using namespace std;int main()
{vector<string> v;v.push_back("this is a string?");return 0;
}

我们的vector存放的是string类对象，而我们传入的却是一个char*类型（字符串常量类型都被解释为了const char *）。在不考虑其它因素外，这个时候就应该会发生隐式类型的转换：将char*类型构造一个string对象，再调用push_back函数

这就是单参数的隐式类型转换

1.2 多参数的隐式类型转换

C++11支持了列表初始化：
在这里插入图片描述
（C++11我们会在后面的专题谈到）

也对类的多参数的情况进行了升级！支持了多参数的隐式类型转换。给出下面一个例子：

#include<iostream>
using namespace std;
class A
{
public:A(int a = 1, int b = 2):_a(a),_b(b){cout << "A(int a = 1, int b = 2)" << endl;}~A(){cout << "~A()" << endl;}A(const A& a){cout << "A(const A& a)" << endl;}A& operator=(const A& a){cout << "A& operator=(const A& a)" << endl;return *this;}int _a;int _b;
};

那么支持了多参数的隐式类型转换之后，我们可以这么写
例1.2.1：

int main()
{A a = {1, 3}; //支持的return 0;
}

同样地，我们应该了解到这个语句干了什么？

编译器会先利用{1， 3}来构造一个A类的tmp对象。
再调用a的对象的拷贝构造函数。

1.3 explicit关键字

有些时候，我们其实并不想构造函数支持这种隐式类型转换，我们就可以采用关键字explicit来对构造函数进行声明！

语法如下：

class A
{
public:explicit A(int a = 1, int b = 2):_a(a),_b(b){cout << "A(int a = 1, int b = 2)" << endl;}~A(){cout << "~A()" << endl;}int _a;int _b;
};int main()
{//关于这样的代码就无法通过编译了！//A a = {1, 3}; //不支持了return 0;
}

但是这样真的很方便……所以我们还可以采用另外一个形式，匿名对象

例1.3.1

int main()
{A a = A{ 1, 3 }; //语句一//A a = A({ 1, 3 }); //语句二return 0;
}

说明：

语句一可以在支持隐式类型转换的情况下使用。本质和隐式类型转换类似，都是构造一个tmp类对象。
语句二使用的前提是这个A类支持initializer_list的A类构造函数。本质上是{ }调用了initializer_list的构造函数，是一个initializer_list的tmp对象，然后再初始化A类。所以，当你的A类不支持这样的一个构造函数，就无法成功初始化了！

是否需要验证呢？

#include<iostream>
using namespace std;
class A
{
public:explicit A(int a = 1, int b = 2):_a(a), _b(b){cout << "A(int a = 1, int b = 2)" << endl;}~A(){cout << "~A()" << endl;}A(initializer_list<int> il) //支持列表初始化的构造函数{cout << "A(initializer_list<int> il)" << endl;}int _a;int _b;
};int main()
{A a = A({ 1, 3 }); //注意不要写成这样return 0;
}

在这里插入图片描述

这样的调用，不知道是否有说服力呢？

2. 编译器的优化

在上面的大多数例子中，我并没有验证那些我们看起来的步骤。因为：编译器是会对同一行的连续构造采取优化措施的。

现在，在来考虑这个类，和几条语句：

2.1 普通构造优化

例2.1.1：

class A
{
public:A(int a = 1, int b = 2):_a(a),_b(b){cout << "A(int a = 1, int b = 2)  " << _a << endl; //为了区别每一个构造，这里多给了一个打印}~A(){}A(const A& a){cout << "A(const A& a)" << endl;}A& operator=(const A& a){cout << "A& operator=(const A& a)" << endl;return *this;}int _a;int _b;
};int main()
{A a0(-1, -1);cout << " ------------------ " << endl;A a1 = a0; //语句一A a2 = { 0, 0 }; //语句二A a3 = A{ 1, 1 }; //语句三return 0;
}

来看运行结果：
在这里插入图片描述
（单参数的也是这样的结果）
在此之前，我们并没有给出实际的运行结果，因为编译器会为我们做出优化：

语句一没有优化。a0本身就是一个存在的对象！
语句二、三进行了优化，本来我们应该是先普通构造再拷贝构造，但编译器为我们直接构造！

2.2 函数传参优化

同样直接给出示例：

class A
{
public:A(int a = 1, int b = 2):_a(a),_b(b){cout << "A(int a = 1, int b = 2)  " << _a << endl; //为了区别每一个构造，这里多给了一个打印}~A(){}A(const A& a){cout << "A(const A& a)" << endl;}A& operator=(const A& a){cout << "A& operator=(const A& a)" << endl;return *this;}int _a;int _b;
};void func(A a) //注意这里并没有传引用 -- 传引用就不会进行拷贝构造了
{//……
}int main()
{A a0(-1, -1);cout << " ------------------ " << endl;func(a0); //语句一func({ 2, 2 }); //语句二func(A{ 3, 3 }); //语句三return 0;
}

在这里插入图片描述

同样发生了优化！

2.3 函数返回优化

这里的函数返回值优化又有所不同，返回值优化又被称为：RVO（Return Value Optimization）

给出示例：

class A
{
public:A(int a = 1, int b = 2):_a(a),_b(b){cout << "A(int a = 1, int b = 2)  " << _a << endl; //为了区别每一个构造，这里多给了一个打印}~A(){}A(const A& a){cout << "A(const A& a)" << endl;}A& operator=(const A& a){cout << "A& operator=(const A& a)" << endl;return *this;}int _a;int _b;
};A func()
{A tmp(5,5);//……return tmp;
}int main()
{A a0(-1, -1);cout << " ------------------ " << endl;a0 = func(); //语句一A a1 = func(); //语句二return 0;
}

我们在func中创建一个临时变量tmp，想让这个tmp完成一些业务，然后返回这个临时变量。来看运行结果：
在这里插入图片描述
语句一：创建一个tmp对象，然后调用一个赋值运算符重载，十分合理的。但是看到语句二：直接就完成了构造！。没有在func()中调用tmp的构造函数？还是没有调用a1的构造函数？

首先分析：A a1 = func();。首先函数返回的时候是会将返回值拷贝到一个tmp对象中的，然后再通过这个tmp对象返回给外面的接收变量，这里本身就有两个拷贝构造，编译器发生优化是很情理之中的！
同时函数func中又定义了一个变量，这个变量也会调用一个构造函数的。
可是结果告诉我们整个的调用只调用了一次构造函数！

没错，这就是编译器的RVO！

RVO：编译器优化技术。它可以减少函数返回时创建临时对象的次数，从而提高程序的运行效率。RVO主要针对未命名的临时对象，消除了函数返回时创建的临时对象，避免了不必要的拷贝构造函数调用。

来看这样一张图片：
在这里插入图片描述