我听了Herb Sutter最近的一次演讲，他建议传递std::vector和std::string的原因大多数已经消失。他建议编写以下函数现在更可取：
std::string do_something ( std::string inval )
{
std::string return_val;
// ... do stuff ...
return return_val;
}
return_val将成为一个右值，因此可以使用移动语义来返回，而移动语义非常廉价。但是，inval仍然比引用的大小要大得多（引用通常实现为指针）。这是因为具有各种组件，包括堆中的指针和成员char[]以进行短字符串优化。因此，按引用传递仍然是一个好主意。Herb说这样说的原因是因为像这样的情况。
假设我有一个名为A的函数，它调用函数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采用const&，因为它不存储字符串，只是使用它。
现在，我想做一个简单的改变：C需要在某个地方存储这个字符串。
void C(const std::string &str)
{
//Do something with `str`.
m_str = str;
}
你好，关于复制构造函数和潜在的内存分配（忽略短字符串优化（SSO））。C++11的移动语义应该能够消除不必要的复制构造，对吗？而且A传递了一个临时变量；没有理由让C必须复制这些数据。它只需要带走给定的内容。
但实际上它做不到。因为它使用了const&。
如果我将C更改为按值接受参数，那么这只会导致B将数据复制到该参数中，我并没有得到任何好处。
所以如果我刚开始就通过所有函数通过值传递了str，依靠std::move来调度数据，我们就不会有这个问题。如果有人想保留它，他们可以这样做。如果他们不这样做，那没关系。
这是否更昂贵？是的；移动到值中更昂贵，比使用引用更昂贵。对于具有SSO的小字符串而言，它是否比复制更便宜？不是。这值得做吗？
这取决于您的用例。你有多讨厌内存分配？
简短回答：不行！ 详细回答：
const ref&传递。const ref&需要在使用它的函数执行期间保持范围内）value传递，不要在函数体内复制const ref&。cpp-next.com上有一篇名为“Want speed, pass by value!”的帖子。 简而言之：
指南：不要复制函数参数，而是通过值进行传递，让编译器进行复制。
^的翻译
不要复制函数参数 --- 意思是：如果您计划通过将其复制到内部变量来修改参数值，则只需使用值参数即可。
所以不要这样做：
std::string function(const std::string& aString){
auto vString(aString);
vString.clear();
return vString;
}
执行此操作:
std::string function(std::string aString){
aString.clear();
return aString;
}
当你需要在函数体内修改参数值时。
你只需要注意在函数体内如何使用该参数。它是只读还是非只读...如果仅限于作用域内。
const ref&到一个内部变量中以修改它。如果你需要修改它...就将参数变成值传递。对于我这个非英语母语的人来说，这非常清楚易懂。 - CodeAngryconst ref＆。#2 如果我需要编写它或者我知道它会超出范围……我使用值。#3 如果我需要修改原始值，则通过ref＆传递。#4 如果参数是可选的，则使用pointers *，这样就可以将其设置为nullptr。 - CodeAngry这高度取决于编译器的实现。
但是，它也取决于你使用的内容。
让我们考虑下一个函数：
bool foo1( const std::string v )
{
return v.empty();
}
bool foo2( const std::string & v )
{
return v.empty();
}
为了避免内联，这些函数被实现在独立的编译单元中。然后：
1. 如果将字面量传递给这两个函数，则性能差异不大。在两种情况下，都需要创建一个字符串对象。
2. 如果传递另一个std::string对象，则foo2将优于foo1，因为foo1将执行深度复制。
在我的PC上，使用g ++ 4.6.1，我得到了以下结果：
除非你确实需要一个副本，否则仍然可以使用const&。例如：
bool isprint(std::string const &s) {
return all_of(begin(s),end(s),(bool(*)(char))isprint);
}
noexcept 实现，但显然复制构造函数不是。 - leftaroundaboutbasic_string_view<?>，这基本上使得std::string const&参数只有一种狭窄用途。std::string const&的一个用例--如果您打算存储参数，则通过值取std::string更加优化，因为您可以从参数中move。"字符串"调用您的函数，这意味着仅分配了一个std::string缓冲区，而不是std::string const&情况下的两个缓冲区。std::string const&。std::string_view，只要您没有将该字符串传递给期望C样式'\0'终止字符缓冲区的API，您就可以更有效地获得类似std::string的功能，而无需冒任何风险进行分配。甚至可以将原始C字符串转换为std::string_view，而无需进行任何分配或字符复制。std::string const&的用途是当您不会整体复制数据，并且将其传递给期望空终止缓冲区的C样式API，并且您需要std::string提供的更高级字符串功能。实际上，这是一组罕见的要求。std::string 占据主导地位，你不仅需要满足其中的 一些 要求，而是需要满足所有要求。其中任何一个或两个要求，我承认是很常见的。也许你通常需要这三个要求（比如，你正在解析字符串参数以选择要完整传递给哪个 C API？） - Yakk - Adam Nevraumontstd::string_view - 正如你所指出的，“原始的 C 字符串甚至可以被转换为 std::string_view，而无需进行任何分配或字符复制”，这是值得记住的事情，对于那些在此类 API 使用上下文中使用 C++ 的人来说，确实如此。 - fish2000void f(std::string&& s) { std::string copy = std::forward(s)}？ - Bobstd::string不是Plain Old Data(POD)，它的原始大小并不是最重要的事情。例如，如果你传入一个超过SSO长度并在堆上分配的字符串，我会期望复制构造函数不会复制SSO存储。
之所以建议这样做是因为inval是从参数表达式构造的，因此始终会根据需要移动或复制-假设您需要拥有参数。如果您不需要，则使用const引用仍然可能是更好的选择。
std::string<>也会分配32个字节从堆栈中，其中16个需要初始化。相比之下，只有8个字节被分配和初始化为引用：这是两倍的CPU工作量，并且占用四倍的缓存空间，这些空间将不可用于其他数据。 - cmaster - reinstate monica我复制/粘贴了来自这个问题的答案，并更改了名称和拼写以适应此问题。
下面是测量所需内容的代码：
#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&&)
+----+--------+--------+---------+
| | lvalue | xvalue | prvalue |
+----+--------+--------+---------+
| p1 | 1/1 | 0/2 | 0/1 |
+----+--------+--------+---------+
| p2 | 1/0 | 0/1 | 0/1 |
+----+--------+--------+---------+
按值传递的解决方案只需要一个重载，但在传递左值和右值时会多出一个移动构造函数。这在任何情况下都可能是可接受的或不可接受的。两种解决方案都有优缺点。
Herb Sutter和Bjarne Stroustrup仍然建议使用const std::string&作为参数类型；请参见https://github.com/isocpp/CppCoreGuidelines/blob/master/CppCoreGuidelines.md#Rf-in。
这里没有提到其他回答中未提到的一个陷阱：如果将字符串字面值传递给const std::string&参数，则会传递一个引用到临时字符串，即即时创建的字符串来保存文字的字符。 如果然后保存该引用，则在临时字符串被解除分配时，它将无效。为确保安全，必须保存副本而不是引用。问题源于字符串字面值是const char[N]类型，需要提升为std::string。
下面的代码说明了陷阱和解决方法，以及一种小的效率选项——重载具有const char*方法的函数，并参见Is there a way to pass a string literal as reference in C++。
（注意：Sutter和Stroustrup建议如果您保留字符串的副本，还应提供具有&&参数和std::move（）的重载函数。）
#include <string>
#include <iostream>
class WidgetBadRef {
public:
WidgetBadRef(const std::string& s) : myStrRef(s) // copy the reference...
{}
const std::string& myStrRef; // might be a reference to a temporary (oops!)
};
class WidgetSafeCopy {
public:
WidgetSafeCopy(const std::string& s) : myStrCopy(s)
// constructor for string references; copy the string
{std::cout << "const std::string& constructor\n";}
WidgetSafeCopy(const char* cs) : myStrCopy(cs)
// constructor for string literals (and char arrays);
// for minor efficiency only;
// create the std::string directly from the chars
{std::cout << "const char * constructor\n";}
const std::string myStrCopy; // save a copy, not a reference!
};
int main() {
WidgetBadRef w1("First string");
WidgetSafeCopy w2("Second string"); // uses the const char* constructor, no temp string
WidgetSafeCopy w3(w2.myStrCopy); // uses the String reference constructor
std::cout << w1.myStrRef << "\n"; // garbage out
std::cout << w2.myStrCopy << "\n"; // OK
std::cout << w3.myStrCopy << "\n"; // OK
}
const char * constructor
const std::string& constructor
Second string
Second string
请参阅“Herb Sutter "Back to the Basics! Essentials of Modern C++ Style”。除其他主题外，他还回顾了过去给出的参数传递建议以及C++11带来的新思想，并特别关注按值传递字符串的想法。
std::string可能会明显地变慢！const&版本将更新旧字符串，这可能会重用已分配的缓冲区。通常，您应该将“string”参数声明为std::string_view（按值）。这样可以像使用const std::string&一样高效地传递现有的std::string对象，并且可以传递词法字符串文字（例如"hello!"）而不需要复制它，并且可以传递类型为string_view的对象，因为这些现在也在生态系统中。
例外情况是当函数需要一个实际的std::string实例，以便传递给另一个声明为const std::string&的函数时。
std::string_view，就再也没有一个好的理由传递字符串的引用了。但是考虑到你提出这个问题的时间，这可能不是你想要的答案！ - undefined