编译器之返回值优化-c++ 返回值优化

今天，借助本文，聊聊编译器的函数返回值优化。

本文的主要内容如下图所示：

函数返回机制

既然本文的主题是返回值优化，那么就不得不提一下函数返回值在编译器中的实现机制，这样以便更好的理解本文内容。

函数返回值的传递分为两种情况：

当返回的对象大小不超过8字节时，通过寄存器(eax edx)返回

当返回的对象大小大于8字节时，通过栈返回。此处需要注意的时候，如果返回的是struct或者class对象，即使其大小不大于8字节，也是通过栈返回的。

在通过栈返回的时候，栈上会有一块空间来保存函数的返回值。当函数结束的时候，会把要返回的对象拷贝到这块区域，对于内置类型是直接拷贝，类类型的话是调用拷贝构造函数。这块区域又称为函数返回的临时对象。

示例

为了能够方便通过输出理解程序的运行情况，本文中所有的代码示例均如下类所示：

class Obj {
 public:
  Obj() { // 构造函数
    std::cout << "in Obj() " << " " << this << std::endl;
  }
  
  Obj(int n) {
    std::cout << "in Obj(int) " << " " << this << std::endl;
  }

  Obj(const Obj &obj) { // 拷贝构造函数
    std::cout << "in Obj(const Obj &obj) " << &obj << " " << this << std::endl;
  }

  Obj &operator=(const Obj &obj) { // 赋值构造函数

    std::cout << "in operator=(const Obj &obj)" << std::endl;
    return *this;
  }

  ~Obj() { // 析构函数
    std::cout << "in ~Obj() " << this << std::endl;
  }

int n;
};

在本示例代码中

在各个函数中均加入了函数名称输出，以方便了解函数的调用情况
各个函数中加入了对象指针地址输出，以方便了解构造、拷贝以及赋值等情况

禁用优化

为了提升程序的性能，编译器在某些情况下，会对我们的代码进行优化，为了搞清楚编译都做了哪些优化，我们首先在禁用优化的情况下，看看程序的。

首先，我们看一段代码，如下：

Obj fun() {
  Obj obj;
  // do sth;
  return obj;
}

int main() {
  Obj obj = fun();
  std::cout << "&obj is " << &obj << std::endl;
  return 0;
}

现在，撇开编译器优化，我们单纯从上面代码进行分析，调用的Obj类成员函数的顺序应该为：

调用构造函数，生成对象
调用拷贝构造函数，生成临时对象
析构第1步生成的对象
调用拷贝构造函数，将第2步生成的临时变量拷贝到main()函数中的局部对象obj中
调用析构函数，释放第2步生成的临时对象
调用析构函数，释放main()函数中的obj局部对象

为了验证我们所理解的顺序是否跟程序运行结果一致，编译并运行，结果如下：

g++ -g -std=c++11 test.cc -o test && ./test

in Obj()  0x7ffd6fb15240
&obj is 0x7ffd6fb15240
in ~Obj() 0x7ffd6fb15240

输出结果与我们预期差别很大，是不是怀疑之前的理解是错误的?其实这是因为编译器对函数返回值做了优化导致。

编译器提供了个编译选项-fno-elide-constructors来禁用返回值优化，编译并运行之后，输出如下：

g++ -std=c++11 -fno-elide-constructors -g test.cc -o test && ./test
  
in Obj()  0x7ffee18a9a00 // 在fun()函数中，构造obj对象
in Obj(const Obj &obj) 0x7ffee18a9a00  0x7ffee18a9a40 // 通过拷贝构造创建临时变量(fun()函数定义的obj--->临时对象)
in ~Obj() 0x7ffee18a9a00 // 析构fun()函数中构造的obj对象(fun()函数定义的obj)
in Obj(const Obj &obj) 0x7ffee18a9a40 0x7ffee18a9a30 // 通过拷贝构造函数构建obj(main函数中的)对象(临时对象--->main()函数定义的obj)
in ~Obj() 0x7ffee18a9a40 // 释放临时对象
&obj is 0x7ffee18a9a30 
in ~Obj() 0x7ffee18a9a30 // 释放main()函数中定义的obj对象

上述输出结果跟我们之前的理解一致了吧😁。

通过上述示例可以看出，如果编译器没有进行返回值优化，则一个简单的拷贝赋值行为，总共调用了6次，分别为1次构造函数，2次拷贝构造函数，以及3次析构函数。而如果做了优化之后呢，只调用了1次构造函数和1次析构函数，相比起来，优化的程度非常高。

当一个函数返回一个对象实例的时候，理论上会产生临时变量，那必然会导致新对象的构造和旧对象的析构，这对性能是有影响的。C++标准允许省略拷贝构造函数。简单来说，就是在调用的地方，将需要初始化对象的引用作为函数参数传递给函数，进而避免不必要的拷贝。

编译器对函数返回值优化的方式分为RVO和NRVO(自c++11开始引入)，在后面的文章中，我们将对该两种方式进行详细分析。

在此需要说明的是，因为自C++11起才引入了NRVO，而NRVO针对的是具名函数对象返回，而C++11之前的RVO相对NRVO来说，是一种URVO(未具名返回值优化)

RVO

RVO(Return Value Optimization)，是一种编译器优化技术，通过该技术，编译器可以减少函数返回时生成临时对象的个数，从某种程度上可以提高程序的运行效率，对需要分配大量内存的类对象其值复制过程十分友好。

当一个未具名且未绑定到任何引用的临时变量被移动或复制到一个相同的对象时，拷贝和移动构造可以被省略。当这个临时对象在被构造的时候，他会直接被构造在将要拷贝/移动到的对象。当未命名临时对象是函数返回值时，发生的省略拷贝的行为被称为RVO(返回值优化)。

RVO优化针对的是返回一个未具名对象，也就是说RVO的功能是消除函数返回时创建的临时对象。

Obj fun() {
  return Obj();
}

int main() {
  Obj obj = fun();
  std::cout << "&obj is " << &obj << std::endl;
  return 0;
}

为了理解编译所做的优化，我们首先禁用RVO优化，输出如下：

in Obj()  0x7ffd9bd8ab30 // 在fun()函数中，构造obj对象
in Obj(const Obj &obj) 0x7ffd9bd8ab30 0x7ffd9bd8ab70 // // 通过拷贝构造创建临时变量(fun()函数定义的obj--->临时对象)
in ~Obj() 0x7ffd9bd8ab30 // // 析构fun()函数中构造的obj对象(fun()函数定义的obj)
in Obj(const Obj &obj) 0x7ffd9bd8ab70 0x7ffd9bd8ab60 // // 通过拷贝构造函数构建obj(main函数中的)对象(临时对象--->main()函数定义的obj)
in ~Obj() 0x7ffd9bd8ab70 // 释放临时对象
&obj is 0x7ffd9bd8ab60
in ~Obj() 0x7ffd9bd8ab60 // 释放main()函数中定义的obj对象

从上述输出，我们可以看出，上述代码总共调用了1次构造函数、2次拷贝构造函数以及3次析构函数。

下面，我们去掉禁用优化的选项，重新编译运行，输出如下：

in Obj()  0x7ffcc33536e0
&obj is 0x7ffcc33536e0
in ~Obj() 0x7ffcc33536e0

可以看出，经过编译器优化之后，总共调用了1次构造函数，一次拷贝构造函数。

那么，编译器优化后与优化前相比，减少了2次拷贝构造函数以及两次析构函数。

编译器明确知道函数会返回哪一个局部对象，那么编译器会把存储这个局部对象的地址和存储返回临时对象的地址进行复用，也就是说避免了从局部对象到临时对象的拷贝操作，这就是RVO。

可以通过-fno-elide-constructors来禁用RVO。

NRVO

NRVO，又名具名返回值优化(Named Return Value Optimization)，为RVO的一个变种，也是一种编译器对于函数返回值优化的方式。此特性从C++11开始支持，也就是说C++98、C++03都是没有将此优化特性写到标准中的，与RVO的不同之处在于函数返回的临时值是具名的。

NRVO与RVO的区别是返回的对象是具名的，既然返回的对象是具名的，那么对象是在return语句之前就构造完成。

我们仍然以一个例子来分析编译器的NRVO都做了哪些优化。

Obj fun() {
  Obj obj; // 具名对象
  // do sth;
  return obj;
}

int main() {
  Obj obj = fun();
  std::cout << "&obj is " << &obj << std::endl;
  return 0;
}

通过-fno-elide-constructors禁用编译器优化之后，输出如下：

in Obj()  0x7ffee18a9a00 // 在fun()函数中，构造obj对象
in Obj(const Obj &obj) 0x7ffee18a9a00  0x7ffee18a9a40 // 通过拷贝构造创建临时变量(fun()函数定义的obj--->临时对象)
in ~Obj() 0x7ffee18a9a00 // 析构fun()函数中构造的obj对象(fun()函数定义的obj)
in Obj(const Obj &obj) 0x7ffee18a9a40 0x7ffee18a9a30 // 通过拷贝构造函数构建obj(main函数中的)对象(临时对象--->main()函数定义的obj)
in ~Obj() 0x7ffee18a9a40 // 释放临时对象
&obj is 0x7ffee18a9a30 
in ~Obj() 0x7ffee18a9a30 // 释放main()函数中定义的obj对象

从上述输出，我们可以看出，总共1次构造函数，2次拷贝构造函数，以及3次析构函数。

如果启用编译器返回值优化后，输出如下：

in Obj()  0x7ffd9e16b2b0
&obj is 0x7ffd9e16b2b0
in ~Obj() 0x7ffd9e16b2b0

与RVO一样，也可以通过-fno-elide-constructors来禁用NRVO。

NRVO优化后，输出与RVO一致，在下一节，将通过分析实现原理来进行说明。

原理

从上述几节中，我们可以看到，编译器对返回值进行优化后，减少了很多不必要的函数调用开销，那么(N)RVO的原理到底是什么呢?

事实上，返回值优化的原理是将返回一个类对象的函数的返回值当做该函数的参数来处理。

为了能够更加清晰明了的分析编译器RVO和NRVO的优化机制，我们以下面代码为例，如下：

Obj fun() {
  Obj obj(1);
  return obj;
}

int main() {
  Obj obj = fun();
  return 0;
}

可能会有人有疑问，上面代码编译器是可以执行NRVO的，为什么还可以RVO呢?这是因为NRVO相比于RVO，是一种要求更为严格的优化方式，编译器启用NRVO的前提条件是返回值是具名的，但并不能说一段代码可以NRVO就不能RVO。

本节的内容，均是对于<<深度探索C++对象模型>>的理解，如果有误，请私信或者在评论区讨论

RVO原理

RVO优化的原理是消除函数返回时产生的一次临时对象。

正如<<深度探索C++对象模型>>中所述，编译器会将返回值函数的原型进行调整，编译器启用RVO优化，fun()函数会变成如下：

void fun(Obj &_obj) {
  Obj obj(1);
  _obj.Obj::Obj(obj); // 拷贝构造函数
  return;
}

而main函数内的调用则会变成：

int main() {
  Obj obj; // 仅定义不构造
  fun(obj);
  return 0;
}

经过上述转换，编译器将只调用一次构造函数和一次拷贝构造函数:

构造函数：fun()函数中局部对象的构造
拷贝构造函数: 在fun()返回前用局部对象obj的值来拷贝构造传入的引用参数

经过上述优化，消除了为保存返回值而创建的临时对象以及将该局部对象拷贝给该临时对象的一次拷贝构造调用。

虽然经过RVO优化后，性能有了部分提升，但是仍然存在一次拷贝构造，那么，在哪种场景下，RVO能够彻底优化呢?我们看下如下代码：

Obj fun() {
  return Obj(1);
}

int main() {
  Obj obj = fun();
  return 0;
}

编译会将fun函数优化为如下：

void fun(Obj &_obj) {
  _obj.Obj::Obj(1);
}

同样的，main函数会优化为如下：

int main() {
  Obj obj;
  fun(obj);
  
  return 0;
}

上述两种代码都进行了RVO优化，但是针对第一段代码，RVO的优化并没起什么作用，相反第二种代码块的优化优化的更彻底，彻底的消除了拷贝构造。

NRVO原理

在上面内容中，我们讲述了在对一开始的代码进行了RVO优化，但是并没有彻底优化，那么，如果进行NRVO优化，编译器会将上述代码优化成什么样子呢?

fun函数会被优化成如下：

void fun(Obj &_obj) {
   _obj.Obj::Obj(1);
}

同样的，main函数会优化为如下：

int main() {
  Obj obj;
  fun(obj);
  
  return 0;
}

fun函数经过优化之后，去掉了RVO优化遗留的拷贝构造问题，达到了优化目标。

从上述代码可以看出，同样一块代码，RVO和NRVO的优化机制不同，得到的优化效果也不同。

编译器的优化，针对不同的场景，采取不同的优化方式，了解了这些，方便我们更好地写出更为高效的代码。

优化失效

在前面几节中，我们详细讲解了编译器在函数返回值中，启用(N)RVO进行优化，以提升程序性能，但是，编译器并非智能的，对于某些复杂场景或者特殊场景，是不会启用优化的，这个时候就需要开发人员依赖具体的情况，进行具体分析，以达到优化的目的。

运行时依赖(根据不同的条件分支，返回不同变量)

当编译器无法单纯通过函数来决定返回哪个实例对象时，会禁用(N)RVO。

代码如下：

Obj fun(bool flag) {
  Obj o1;
  Obj o2;
  if (flag) {
    return o1;
  }
  return o2;
}

int main() {
  Obj obj = fun(true);
  return 0;
}

程序输出如下：

in Obj()  0x7ffd8cbf7c00 // 构造o1对象
in Obj()  0x7ffd8cbf7bf0 // 构造o2对象
in Obj(const Obj &obj) 0x7ffd8cbf7c00 0x7ffd8cbf7c30 // 通过拷贝构造，将o1赋值给obj(main函数中的局部变量)
in ~Obj() 0x7ffd8cbf7bf0 // 析构o2对象
in ~Obj() 0x7ffd8cbf7c00 // 析构o1对象
in ~Obj() 0x7ffd8cbf7c30 // 析构obj

但是，下面这种情况例外，虽然其仍然依赖于具体的条件判断：

Obj fun(bool flag) {
  Obj obj;
  if (flag) {
    return obj;
  }
  obj.n = 10;
  return obj;
}

int main() {
  Obj obj = fun(true);
  return 0;
}

输出如下：

in Obj() 0x7ffd8cbf7bf0
in ~Obj() 0x7ffd8cbf7bf0

这是因为，对于单个对象以及多个函数出口的情况，编译器将多个出口优化为一个。

返回全局变量

当返回的对象不是在函数内创建的时候，是无法执行返回值优化的。

Obj g_obj;

Obj fun() {
  return g_obj;
}

int main() {
  Obj obj = fun();
  std::cout << &obj << std::endl;
  return 0;
}

编译并运行，结果如下：

in Obj()  0x6013b4 // 构造全局变量
in Obj(const Obj &obj) 0x6013b4 0x7ffc8abe14e0 // 构造main中的局部对象
0x7ffc8abe14e0
in ~Obj() 0x7ffc8abe14e0 // 析构main中的局部对象
in ~Obj() 0x6013b4 // 析构全局变量

返回函数参数

与返回全局变量类似，当返回的对象不是在函数内创建的时候，是无法执行返回值优化的。

代码如下：

Obj fun(Obj obj) {
  return obj;
}

int main() {
  Obj o;
  Obj obj = fun(o);
  std::cout << "in main " << &obj << std::endl;
  return 0;
}

编译并运行之后，输出：

in Obj() 0x7ffdbb43da00
in Obj(const Obj &obj) 0x7ffdbb43da00 0x7ffdbb43da10
in Obj(const Obj &obj) 0x7ffdbb43da10 0x7ffdbb43d9f0
in ~Obj() 0x7ffdbb43da10
in main 0x7ffdbb43d9f0
in ~Obj() 0x7ffdbb43d9f0
in ~Obj() 0x7ffdbb43da00

返回成员变量

在某些特殊情况下，即使是未具名变量，也不能RVO。

代码如下：

struct Wraper {
   Obj obj;
 };

Obj fun() {
  return Wraper().obj;
}

int main() {
  Obj obj = fun();
  std::cout << &obj << std::endl;
  return 0;
}

编译并运行，结果如下：

in Obj()  0x7ffed7f85290 // 构造Wraper中的obj对象
in Obj(const Obj &obj) 0x7ffed7f85290 0x7ffed7f852c0 // 通过拷贝赋值给main函数中的局部变量
in ~Obj() 0x7ffed7f85290 // 析构Wraper中的obj对象
0x7ffed7f852c0
in ~Obj() 0x7ffed7f852c0 // 析构main中的局部对象

存在赋值行为

(N)RVO只能在从返回值创建对象时发送，在现有对象上使用operator=而不是拷贝/移动构造函数，这样是不会进行RVO操作的。

代码如下：

Obj fun() {
  return Obj();
}

int main() {
  Obj obj;
  obj = fun();
  return 0;
}

编译并运行之后，输出：

in Obj()  0x7ffd7a100cf0 // 构造main()函数中的obj对象
in Obj()  0x7ffd7a100d00 // 生成临时对象
in operator=(const Obj &obj) 0x7ffd7a100d00 0x7ffd7a100cf0 // 调用赋值函数，将临时变量赋值给目标(main函数中的局部对象obj)
in ~Obj() 0x7ffd7a100d00 // 析构临时对象
in ~Obj() 0x7ffd7a100cf0 // 析构main中的局部对象

使用std::move()返回

在返回值上调用std::move()进行返回是一种错误的方式。它会尝试强制调用移动构造函数，但这样会导致RVO失效。因为即使没有显示调用std::move()，编译器优化中也会执行move操作。

代码如下：

Obj fun() {
  Obj obj;
  return std::move(obj);
}

int main() {
  Obj obj = fun();
  return 0;
}

输出如下：

in Obj()  0x7ffe7d4d1720
in Obj(const Obj &&obj)
in ~Obj() 0x7ffe7d4d1720
0x7ffe7d4d1750
in ~Obj() 0x7ffe7d4d1750

从上面输出可以看出，与不使用std::move()返回相比，使用std::move()返回增加了一次拷贝构造调用和一次析构调用。

经验之谈

之前看过一篇文章，也是(N)RVO相关的，当时作者观点是优化依赖于编译器，而作者同事的观点则是依赖代码实现来实现优化，当时给出的例子如下：

class BigObject {
// 定义
};

BigObject fun() {
  BigObject obj;
  // do sth
  return obj;
}

是不是似曾相识?类似于我们前面NVRO中的代码示例。

作者的观点是此种代码满足编译器NVRO优化的条件，所以不需要优化;而作者同事的观点则是，不能严格依赖编译器，所以作者同事的优化建议如下：

void fun(BigObject &obj) {
  // do sth with obj
}

在此，我说下自己的观点吧：

代码优化不应该依赖编译器，因为无法保证在其他编译器下就能得出跟当前类似的优化效果
依赖编译器优化的前提是开发人员了解编译器的优化机制或者说开发人员知道写怎样的代码能达到编译器优化的标准，但是，如果部门入职的新人接手了这块工作，在开发过程中，发现老代码都是直接返回(也就是作者口中的编译器优化)，然后新人也直接返回(即使编译器不会进行优化，例如前面的返回全局变量等)，这样恰恰得到相反的结果

所以，总的来说，我倾向于作者同事的优化方案。对于char、int、double等元类型，在函数中直接返回;而对于需要返回struct、class类型的函数，则直接作为函数入参，在函数内部进行初始化。

当然了，上面仅仅是我的个人观点，至于使用编译器优化还是上述引用传参的方式，则依赖于开发者的个人喜好或者团队的代码风格。但是需要注意的是，如果使用编译器优化，则需要小心小心再小心，否则就会导致事倍功半的效果，进而导致程序性能损失。

结语

(N)RVO是编译器对于函数返回值的一种优化技术，旨在消除临时对象的创建。了解编译器的优化，可以提升我们的程序运行效率，但是需要注意的是，如果单纯依赖编译器优化，可能会导致某些我们意想不到的情况发生。所以，在使用编译器优化方式之前，我们需要保证代码的实现方式能够启用RVO优化。

好了，今天的文章就到这里，我们下期见!