按值、引用和右值传递字符串

Question

我只是比较将字符串传递给函数的性能。 benchmark results 很有趣。

这是我的代码：

void add(std::string msg)
{
    msg += "world";
}

void addRvalue(std::string&& msg)
{
    msg += "world";
}

void addRef(std::string& msg)
{
    msg += "world";
}

void StringCreation() {
    add(std::string("hello "));
}

void StringCopy() {
    std::string msg("hello ");
    add(msg);
}

void StringMove() {
    std::string msg("hello ");
    add(std::move(msg));
}

void StringRvalue() {
    std::string msg("hello ");
    addRvalue(std::move(msg));
}

void StringReference() {
    std::string msg("hello ");
    addRef(msg);
}

StringCreation()、StringRvalue() 和StringReference() 是等价的。我很惊讶 StringMove() 是性能最低的 - 比涉及副本的按值传递更糟糕。

我是否认为调用 StringMove() 涉及一个移动构造函数，然后在调用 add() 时调用一个复制构造函数？它不只是涉及一个移动构造函数吗？我认为移动构造对于字符串来说很便宜。

更新

我增加了传递给 add() 的字符串的长度，这确实有所作为。现在 StringMove() 只比 StringCreation 和 StringReference 慢 1.1 倍。 StringCopy 现在是最差的，这是我所期望的。

这是新的 benchmark results。

所以 StringMove 毕竟不涉及复制 - 仅适用于小字符串。

Answer 1

在这个例子中，none 正在 "benchmarked" 的函数实际上正在做任何重要的事情。也就是说，其中 none 实际上是 returns 一个计算值，然后在其他地方使用。

因此，任何（半）体面的编译器可能会决定完全忽略它们！

为了进行有效的基准测试，each/every调用的字符串结果必须用于某些事情，即使是简单的输出到file/console.

试试这个代码看看发生了什么（没有发生）：

#include<iostream>
#include<string>

using namespace std;

void add(std::string msg)
{
    msg += " + 'add'";
}

void addRef(std::string& msg)
{
    msg += " + 'addRef'";
}

void addRvalue(std::string&& msg)
{
    msg += " + 'addRefRef'";
}

int main()
{
    std::string msg("Initial string!");
    cout << msg << endl;
    add(msg);
    cout << msg << endl; // msg will be the same as before!
    addRef(msg);
    cout << msg << endl; // msg will be extended!
    addRvalue(std::move(msg));
    cout << msg << endl; // msg will again be extended
    add(std::move(msg)); 
    cout << msg << endl; // msg will be completely emptied!
    return 0;
}

Answer 2

让我们分析您的代码并假设长字符串（未应用 SSO）：

void add(std::string msg) {
   msg += "world";
}

void StringCreation() {
   add(std::string("hello "));
}

这里，首先调用来自字符串文字的转换构造函数（ConvC）来初始化临时std::string("hello ")。然后 移动构造函数 (MC) 使用这个临时值（右值）来初始化参数 msg。然而，后者很可能被 copy elision 优化掉了。最后，运算符 += 被调用。底线：1x ConvC 和 1x +=.

void StringCopy() {
   std::string msg("hello ");
   add(msg);
}

这里，参数msg被[=44复制初始化（通过复制构造函数 - CC） =]左值参数msg。底线：1x ConvC、1x CC 和 1x +=。对于长字符串，这是最慢的版本，因为复制涉及动态内存分配（唯一的情况）。

void StringMove() {
   std::string msg("hello ");
   add(std::move(msg));
}

为什么这比 StringCreation 慢？仅仅是因为有一个额外的 MC 涉及初始化参数 msg。它不能被省略，因为对象 msg 在调用 add 之后仍然存在。只是它被移走了。底线：1x ConvC，1x MC，1x +=。

void addRef(std::string& msg) {
   msg += "world";
}

void StringReference() {
   std::string msg("hello ");
   addRef(msg);
}

这里，运算符+=应用于引用对象，所以没有任何理由copy/move。底线：1x ConvC，1x +=。与 StringCreation.

的时间相同

void addRvalue(std::string&& msg) {
   msg += "world";
}

void StringRvalue() {
   std::string msg("hello ");
   addRvalue(std::move(msg));
}

使用 Clang，时间与 StringReference 相同。使用 GCC，时间与 StringMove 相同。事实上，我暂时没有对这种行为的解释。（在我看来，GCC 正在创建一些由 MC 初始化的额外临时文件。但是，我不知道为什么。）

按值、引用和右值传递字符串

Passing a string by value, reference and rvalue

c++

stdstring

c++11

更新