赫伯说那些话的原因就是因为这样的案子。

假设我有一个函数A，它调用函数B，函数B调用函数C, A将一个字符串通过B传递给C, A不知道也不关心C;A只知道B，也就是说，C是B的一个实现细节。

假设A的定义如下:

void A()
{
  B("value");
}

如果B和C通过const&获取字符串，那么它看起来像这样:

void B(const std::string &str)
{
  C(str);
}

void C(const std::string &str)
{
  //Do something with `str`. Does not store it.
}

一切都很好。你只是传递指针，没有复制，没有移动，每个人都很开心。C接受一个参数&，因为它不存储字符串。它只是简单地使用它。

现在，我想做一个简单的改变:C需要将字符串存储在某个地方。

void C(const std::string &str)
{
  //Do something with `str`.
  m_str = str;
}

你好，复制构造函数和潜在的内存分配(忽略短字符串优化(SSO))。c++ 11的move语义应该可以消除不必要的复制构造，对吧?A只是暂时的;C没有理由复制数据。它应该带着给它的东西潜逃。

但它不能。因为它需要一个常量。

如果我改变C的参数值，这只会导致B对参数进行复制;我什么也得不到。

所以如果我在所有函数中都按值传递str，依靠std::move来打乱数据，我们就不会有这个问题。如果有人想留住它，他们可以做到。如果没有，那好吧。

会更贵吗?是的,移动到值中比使用引用代价更大。它比复制品便宜吗?不适合使用SSO的小字符串。值得做吗?

这取决于您的用例。你有多讨厌内存分配?

IMO使用c++引用std::string是一个快速而简短的局部优化，而使用传递值可能是(或不是)一个更好的全局优化。

所以答案是:这取决于环境:

如果你把所有的代码从外部写到内部函数，你知道代码是做什么的，你可以使用引用const std::string &。 如果您编写库代码，或者在传递字符串的地方大量使用库代码，那么通过信任std::string复制构造函数行为，您可能会获得更多全局意义上的好处。

是传递const std::string &作为参数的日子?

不。许多人采纳了这个建议(包括Dave Abrahams)，并将其简化为适用于所有std::string参数——始终按值传递std::string对于任何和所有任意参数和应用程序都不是“最佳实践”，因为这些演讲/文章关注的优化只适用于有限的一组情况。

如果要返回值、改变参数或获取值，那么按值传递可以节省昂贵的复制，并提供语法上的便利。

与以往一样，当您不需要拷贝时，传递const引用可以节省大量复制。

现在来看看具体的例子:

然而，inval仍然比引用(通常实现为指针)的大小大得多。这是因为std::string有各种组件，包括指向堆的指针和用于短字符串优化的成员char[]。所以在我看来，通过引用传递仍然是一个好主意。谁能解释一下赫伯为什么会这么说?

如果考虑到堆栈大小(并且假设这不是内联/优化的)，return_val + inval > return_val——IOW，可以通过在这里传递值来降低堆栈使用的峰值(注意:ABIs的过度简化)。同时，通过const引用传递可以禁用优化。这里的主要原因不是为了避免堆栈增长，而是为了确保优化可以在适用的地方执行。

通过const引用传递的日子并没有结束——规则只是比以前更复杂了。如果性能很重要，明智的做法是根据实现中使用的细节考虑如何传递这些类型。

string不是普通旧数据(POD)，它的原始大小不是最相关的东西。例如，如果传入的字符串超过SSO的长度，并且分配在堆上，我希望复制构造函数不复制SSO存储。

推荐这样做的原因是，inval是从参数表达式构造的，因此总是被适当地移动或复制——假设您需要参数的所有权，这不会造成性能损失。如果不这样做，const引用仍然是更好的方法。

我复制/粘贴了这个问题的答案，并更改了名称和拼写以适应这个问题。

下面是用来衡量问题的代码:

#include <iostream>

struct string
{
    string() {}
    string(const string&) {std::cout << "string(const string&)\n";}
    string& operator=(const string&) {std::cout << "string& operator=(const string&)\n";return *this;}
#if (__has_feature(cxx_rvalue_references))
    string(string&&) {std::cout << "string(string&&)\n";}
    string& operator=(string&&) {std::cout << "string& operator=(string&&)\n";return *this;}
#endif

};

#if PROCESS == 1

string
do_something(string inval)
{
    // do stuff
    return inval;
}

#elif PROCESS == 2

string
do_something(const string& inval)
{
    string return_val = inval;
    // do stuff
    return return_val; 
}

#if (__has_feature(cxx_rvalue_references))

string
do_something(string&& inval)
{
    // do stuff
    return std::move(inval);
}

#endif

#endif

string source() {return string();}

int main()
{
    std::cout << "do_something with lvalue:\n\n";
    string x;
    string t = do_something(x);
#if (__has_feature(cxx_rvalue_references))
    std::cout << "\ndo_something with xvalue:\n\n";
    string u = do_something(std::move(x));
#endif
    std::cout << "\ndo_something with prvalue:\n\n";
    string v = do_something(source());
}

对我来说，这输出:

$ clang++ -std=c++11 -stdlib=libc++ -DPROCESS=1 test.cpp
$ a.out
do_something with lvalue:

string(const string&)
string(string&&)

do_something with xvalue:

string(string&&)
string(string&&)

do_something with prvalue:

string(string&&)
$ clang++ -std=c++11 -stdlib=libc++ -DPROCESS=2 test.cpp
$ a.out
do_something with lvalue:

string(const string&)

do_something with xvalue:

string(string&&)

do_something with prvalue:

string(string&&)

下表总结了我的结果(使用clang -std=c++11)。第一个数字是复制结构的数量，第二个数字是移动结构的数量:

+----+--------+--------+---------+
|    | lvalue | xvalue | prvalue |
+----+--------+--------+---------+
| p1 |  1/1   |  0/2   |   0/1   |
+----+--------+--------+---------+
| p2 |  1/0   |  0/1   |   0/1   |
+----+--------+--------+---------+

值传递解决方案只需要一次重载，但在传递左值和x值时需要额外的move构造。对于任何特定的情况，这可能是可接受的，也可能是不可接受的。这两种解决方案各有优缺点。

参见“Herb Sutter”回归基础!《现代c++风格要点》。在其他主题中，他回顾了过去给出的参数传递建议，以及c++ 11中引入的新思想，并特别介绍了按值传递字符串的思想。

基准测试显示，在函数无论如何都会复制std::strings的情况下，按值传递std::strings可能会显著变慢!

这是因为你强迫它总是做一个完整的拷贝(然后移动到适当的位置)，而const&version将更新旧字符串，这可能会重用已经分配的缓冲区。

请看他的幻灯片27:对于“set”函数，选项1一如既往。选项2为右值引用添加了重载，但如果有多个参数，则会导致组合爆炸。

只有对于必须创建字符串(而不是更改其现有值)的“sink”参数，值传递技巧才有效。也就是说，形参直接初始化匹配类型的成员的构造函数。

如果你想知道你能有多担心这个问题，看看尼科莱·约苏蒂斯的演讲，祝你好运(“完美-完成!”n次后发现错误的前一个版本。你去过那里吗?)

这也总结为⧺F。标准指南中的15条。

更新

一般情况下，你需要声明"string"参数为std::string_view(按值)。这允许你像使用const std::string&一样有效地传递一个现有的std::string对象，也可以传递一个词汇字符串字面量(如“hello!”)而不复制它，并传递类型为string_view的对象，现在这些也在生态系统中是必要的。

例外情况是当函数需要一个实际的std::string实例，以便传递给另一个声明为接受const std::string&的函数。