目前正在阅读 cpr 请求库的代码库: https://github.com/whoshuu/cpr/blob/master/include/cpr/api.h

注意到这个库的接口(interface)经常使用完美转发。只是学习右值引用，所以这对我来说都是相对较新的。

根据我的理解，右值引用、模板化和转发的好处是被环绕的函数调用将通过右值引用而不是值来获取其参数。这避免了不必要的复制。它还可以防止由于引用推导而不得不生成一堆重载。

然而，根据我的理解，const 左值引用本质上做同样的事情。它避免了重载的需要，并通过引用传递所有内容。需要注意的是，如果被环绕的函数采用非常量引用，它将无法编译。

但是，如果调用堆栈中的所有内容都不需要非常量引用，那么为什么不通过 const 左值引用传递所有内容呢？

我想我的主要问题是，什么时候应该使用一个而不是另一个以获得最佳性能？尝试使用以下代码对此进行测试。得到了以下比较一致的结果:

编译器:gcc 6.3 操作系统:Debian GNU/Linux 9

<<<<
Passing rvalue!
const l value: 2912214
rvalue forwarding: 2082953
Passing lvalue!
const l value: 1219173
rvalue forwarding: 1585913
>>>>

这些结果在运行之间保持相当一致。似乎对于右值 arg，const l 值签名稍微慢一些，尽管我不确定为什么，除非我误解了这一点并且 const 左值引用实际上复制了右值。

对于左值arg，我们看到计数器，右值转发较慢。为什么会这样？引用推导不应该总是产生对左值的引用吗？如果是这样的话，就性能而言，它不应该或多或少等同于 const 左值引用吗？

#include <iostream>
#include <string>
#include <utility>
#include <time.h>

std::string func1(const std::string& arg) {
    std::string test(arg);
    return test;
}

template <typename T>
std::string func2(T&& arg) {
    std::string test(std::forward<T>(arg));
    return test;
}

void wrap1(const std::string& arg) {
    func1(arg);
}

template <typename T>
void wrap2(T&& arg) {
    func2(std::forward<T>(arg));
}

int main()
{
     auto n = 100000000;

     /// Passing rvalue
     std::cout << "Passing rvalue!" << std::endl;

     // Test const l value
     auto t = clock();
     for (int i = 0; i < n; ++i)
         wrap1("test");
     std::cout << "const l value: " << clock() - t << std::endl;

     // Test rvalue forwarding
     t = clock();
     for (int i = 0; i < n; ++i)
         wrap2("test");
     std::cout << "rvalue forwarding: " <<  clock() - t << std::endl;

     std::cout << "Passing lvalue!" << std::endl;

     /// Passing lvalue
     std::string arg = "test";

     // Test const l value
     t = clock();
     for (int i = 0; i < n; ++i)
         wrap1(arg);
     std::cout << "const l value: " << clock() - t << std::endl;

     // Test rvalue forwarding
     t = clock();
     for (int i = 0; i < n; ++i)
         wrap2(arg);
     std::cout << "rvalue forwarding: " << clock() - t << std::endl;

}

最佳答案

首先，here are与您的代码的结果略有不同。如评论中所述，编译器及其设置非常重要。特别是，您可能会注意到所有情况都有相似的运行时间，除了第一个，它的速度大约是它的两倍。

Passing rvalue!
const l value: 1357465
rvalue forwarding: 669589
Passing lvalue!
const l value: 744105
rvalue forwarding: 713189

让我们看看每种情况下到底发生了什么。

1) 调用wrap1("test")时，因为该函数的签名需要一个 const std::string & ，您传递的 char 数组将隐式转换为临时 std::string每次调用(即 n 次)的对象，这涉及值的拷贝*。然后将对该临时文件的 const 引用传递到 func1 中。 ，另一个std::string是从它构造的，它又涉及一个拷贝(因为它是一个 const 引用，它不能被移动，尽管它实际上是一个临时的)。尽管函数按值返回，但由于 RVO，如果使用返回值，则可以保证删除该拷贝。在这种情况下，不使用返回值，我不完全确定标准是否允许编译器优化 temp 的构造。 .我怀疑不会，因为通常这样的构造可能会产生明显的副作用(并且您的结果表明它没有得到优化)。综上所述，std::string 的全面 build 和破坏在这种情况下执行两次。

2) 调用wrap2("test")时, 参数类型为 const char[5] , 它作为右值引用一直转发到 func2 , 其中 std::string来自 const char[] 的构造函数被称为复制值。模板参数的推导类型 T是const char[5] &&而且，很明显，尽管它是一个右值引用，但它不能被移动(因为两者都是 const 而不是是 std::string )。与前一种情况相比，字符串的构造/销毁每次调用仅发生一次(const char[5] 文字始终在内存中，不会产生开销)。

3) 调用wrap1(arg)时，您将左值作为 const string & 传递通过链，并在 func1 中调用一个复制构造函数.

4) 调用wrap2(arg)时，这与之前的情况类似，因为 T 的推导类型是const std::string & .

5) 我假设您的测试旨在展示当需要在调用链底部制作参数拷贝时完美转发的优势(因此创建了 temp )。在这种情况下，您需要更换 "test"前两种情况下的参数 std::string("test")为了真正拥有std::string &&参数，并将您的完美转发修复为 std::forward<T>(arg) ，如评论中所述。在这种情况下，the results是:

Passing rvalue!
const l value: 1314630
rvalue forwarding: 595084
Passing lvalue!
const l value: 712461
rvalue forwarding: 720338

这与我们之前的类似，但现在实际上调用了一个移动构造函数。

我希望这有助于解释结果。可能还有一些与函数调用内联和其他编译器优化相关的其他问题，这将有助于解释案例 2-4 之间较小的差异。

关于使用哪种方法的问题，我建议阅读 Scott Meyer 的“Effective Modern C++”第 23-30 项。对于书籍引用而不是直接答案表示歉意，但没有 Elixir ，最佳选择总是视情况而定，因此最好只了解每个设计决策的权衡。

* 由于短字符串优化，复制构造函数可能涉及也可能不涉及动态内存分配；感谢 ytoledano 在评论中提出这个问题。此外，我在整个答案中都隐含地假设拷贝比移动要昂贵得多，但情况并非总是如此。

关于c++ - 何时更喜欢 const 左值引用而不是右值引用模板，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/46168394/