我是否应该通过右值引用返回右值引用参数
Should I return an rvalue reference parameter by rvalue reference?
我有一个函数,它就地修改std::string&
左值引用,返回对输入参数的引用:
std::string& transform(std::string& input)
{
// transform the input string
...
return input;
}
我有一个辅助函数,它允许对右值引用执行相同的内联转换:
std::string&& transform(std::string&& input)
{
return std::move(transform(input)); // calls the lvalue reference version
}
请注意,它返回一个右值引用。
我已经阅读了几个关于 SO 的关于返回右值引用的问题(例如,这里和这里),并得出结论,这是不好的做法。
从我所读到的内容来看,似乎共识是,由于返回值是右值,再加上考虑到 RVO,仅按值返回将同样有效:
std::string transform(std::string&& input)
{
return transform(input); // calls the lvalue reference version
}
但是,我也读到返回函数参数会阻止 RVO 优化(例如这里和这里)
这让我相信会从transform(...)
的左值引用版本的std::string&
返回值复制到std::string
返回值。
这是对的吗?
保留我的std::string&& transform(...)
版本更好吗?
没有正确的答案,但按值返回更安全。
我已经阅读了几个关于 SO 的有关返回右值引用的问题,并得出结论,这是不好的做法。
返回对参数的引用会将协定强加给调用方,该协定要么
- 参数不能是临时的(这正是右值引用所表示的),或者
- 返回值不会保留在调用方上下文中的下一个分号之后(当临时值被销毁时)。
如果调用方传递临时并尝试保存结果,则会获得一个悬而未决的引用。
从我所读到的内容来看,似乎共识是,由于返回值是右值,再加上考虑到 RVO,仅按值返回将同样有效:
按值返回会增加移动构造操作。这样做的成本通常与对象的大小成正比。通过引用返回只需要机器确保一个地址在寄存器中,而按值返回需要在参数std::string
中将几个指针归零,并将它们的值放入要返回的新std::string
中。
它很便宜,但不是零。
令人惊讶的是,标准库目前采取的方向是快速且不安全并返回引用。(我知道唯一实际执行此操作的功能是从<tuple>
std::get
。碰巧的是,我已经向C++核心语言委员会提出了解决这个问题的建议,修订正在进行中,就在今天,我开始调查实施情况。但这很复杂,而且不是一件确定的事情。
std::string transform(std::string&& input) { return transform(input); // calls the lvalue reference version }
编译器不会在此处生成move
。如果input
根本不是引用,并且您确实return input;
它会,但是没有理由相信transform
会仅仅因为它是一个参数而返回input
,并且无论如何它都不会从右值引用类型推断所有权。(参见 C++14 §12.8/31-32。
您需要做:
return std::move( transform( input ) );
或等效
transform( input );
return std::move( input );
上述版本的transform
的一些(非代表性)运行时:
在科里鲁上运行
#include <iostream>
#include <time.h>
#include <sys/time.h>
#include <unistd.h>
using namespace std;
double GetTicks()
{
struct timeval tv;
if(!gettimeofday (&tv, NULL))
return (tv.tv_sec*1000 + tv.tv_usec/1000);
else
return -1;
}
std::string& transform(std::string& input)
{
// transform the input string
// e.g toggle first character
if(!input.empty())
{
if(input[0]=='A')
input[0] = 'B';
else
input[0] = 'A';
}
return input;
}
std::string&& transformA(std::string&& input)
{
return std::move(transform(input));
}
std::string transformB(std::string&& input)
{
return transform(input); // calls the lvalue reference version
}
std::string transformC(std::string&& input)
{
return std::move( transform( input ) ); // calls the lvalue reference version
}
string getSomeString()
{
return string("ABC");
}
int main()
{
const int MAX_LOOPS = 5000000;
{
double start = GetTicks();
for(int i=0; i<MAX_LOOPS; ++i)
string s = transformA(getSomeString());
double end = GetTicks();
cout << "nRuntime transformA: " << end - start << " ms" << endl;
}
{
double start = GetTicks();
for(int i=0; i<MAX_LOOPS; ++i)
string s = transformB(getSomeString());
double end = GetTicks();
cout << "nRuntime transformB: " << end - start << " ms" << endl;
}
{
double start = GetTicks();
for(int i=0; i<MAX_LOOPS; ++i)
string s = transformC(getSomeString());
double end = GetTicks();
cout << "nRuntime transformC: " << end - start << " ms" << endl;
}
return 0;
}
输出
g++ -std=c++14 -O2 -Wall -pedantic -pthread main.cpp && ./a.out
Runtime transformA: 444 ms
Runtime transformB: 796 ms
Runtime transformC: 434 ms
这让我相信从 std::string& 转换 (...) 的左值引用版本的返回值为 标准::字符串返回值。
这是对的吗?
如果编译器不执行 RVO,则返回引用版本不会允许 std::string 复制发生,但返回值版本将具有 copy。但是,RVO 有其局限性,因此 C++11 添加 r 值引用并移动构造函数/赋值/std::move 以帮助处理这种情况。是的,RVO 比移动语义更有效,移动比复制便宜,但比 RVO 更昂贵。
保留我的 std::string&& transform(...) 版本更好吗?
这在某种程度上很有趣和奇怪。正如Potatoswatter回答的那样,
std::string transform(std::string&& input)
{
return transform(input); // calls the lvalue reference version
}
您应该手动调用 std::move。
但是,您可以单击此developerworks链接:RVO V.S. std::move以查看更多详细信息,这些详细信息清楚地解释了您的问题。
如果你的问题纯粹是面向优化的,最好不要担心如何传递或返回参数。 编译器足够聪明,可以将您的代码分为纯引用传递、复制 elision、函数内联,甚至是移动语义(如果它是最快的方法)。
基本上,移动语义在某些深奥的情况下可以使你受益。 假设我有一个矩阵对象,它将double**
作为成员变量保存,并且此指针指向两个二元数组double
。 现在假设我有这个表达式:Matrix a = b+c;
复制构造函数(或 assigment 运算符,在本例中)将获取b
和c
的总和作为 temorary,将其作为 const 引用传递,在a
内部指针上重新分配m*n
doubles
量,然后,它将在 Sum-array 上运行a+b
并将一个接一个地复制其值。 简单的计算表明,它最多可以采取O(nm)
步(可以通用为O(n^2)
)。移动语义只会将隐藏的double**
从临时a
重新连接到内部指针中。这需要O(1)
.
现在让我们考虑一下std::string
: 将其作为引用传递需要O(1)
步骤(获取内存地址,传递它,取消引用它等,这在任何种类上都不是线性的)。 将其作为 r-value-reference 传递需要程序将其作为引用传递,重新连接隐藏的底层 C-char*
,其中包含内部缓冲区,将原始缓冲区清空(或在它们之间交换),复制size
和capacity
以及更多操作。我们可以看到,尽管我们仍处于O(1)
区域 - 实际上可以有更多的步骤,而不仅仅是将其作为常规参考传递。
好吧,事实是我没有对其进行基准测试,这里的讨论纯粹是理论上的。 尽管如此,我的第一段仍然是正确的。 作为开发人员,我们假设了很多事情,但除非我们将所有内容都基准测试到死 - 编译器在 99% 的时间内比我们更了解
考虑到这个论点,我会说将其保留为引用传递而不是移动语义,因为它与 backword 兼容,并且对于尚未掌握 C++11 的开发人员来说更容易理解。
- 如何通过引用返回对象
- 函数如何使用引用返回所需的数字?
- 如何防止引用返回的私有结构的突变
- 如何在不使用临时变量的情况下取消引用返回指针的函数的返回值?
- 通过引用返回的变量的范围
- 对于具有引用返回类型的搜索算法,默认返回值应该是什么?
- 运算符重载C++类中的引用返回
- C++对象引用返回不同的值
- 解释通过从函数引用返回数组的语法
- 具有引用返回类型的重写方法上的协变返回类型无效
- 为什么在通过引用返回运算符分配时取消引用'this'指针?
- 为什么我在函数中使用引用并通过引用返回它仍然有效?
- 直接在 C++ 中将值分配给引用返回类型
- C++当您取消引用指向类对象的指针,然后将其作为引用返回时,是否可以对此引用调用方法
- 可以通过常量引用返回默认参数的值吗?
- 按值与右值引用返回
- 非常量引用返回函数在常量值返回函数上用作 r 值
- 当我使用按引用返回时,我不知道这些代码之间的区别
- 为什么通过引用返回向量比通过移动返回要快得多?
- 通过引用返回包含对象的向量