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构造。对于任何特定的情况，这可能是可接受的，也可能是不可接受的。这两种解决方案各有优缺点。

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

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

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

假设我有一个函数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的小字符串。值得做吗?

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

Herb Sutter和Bjarne Stroustroup一起推荐使用const std::string&作为形参类型;见https://github.com/isocpp/CppCoreGuidelines/blob/master/CppCoreGuidelines.md#Rf-in。

这里有一个在其他答案中没有提到的陷阱:如果你将一个字符串字面值传递给一个const std::string& parameter，它将传递一个临时字符串的引用，该字符串是动态创建的，用于保存字面值的字符。如果然后保存该引用，那么一旦释放临时字符串，它将无效。为了安全起见，您必须保存副本，而不是参考资料。这个问题源于字符串字面值是const char[N]类型，需要升级为std::string。

下面的代码说明了陷阱和解决方法，以及一个较小的效率选项——使用const char*方法重载，如在c++中是否有一种方法将字符串文字作为引用传递。

(注意:Sutter & Stroustroup建议，如果你保留了字符串的副本，也要提供一个带有&&形参和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 *构造函数 常量std::string&构造函数 第二个字符串 第二个字符串

除非你真的需要一个副本，否则使用const &仍然是合理的。例如:

bool isprint(std::string const &s) {
    return all_of(begin(s),end(s),(bool(*)(char))isprint);
}

如果你改变它，以按值获取字符串，那么你最终会移动或复制参数，这是没有必要的。复制/移动不仅成本更高，而且还会带来新的潜在失败;复制/移动可能会抛出异常(例如，复制期间的分配可能会失败)，而引用现有值则不会。

如果你确实需要一个副本，那么通过值传递和返回通常是(总是?)最好的选择。事实上，在c++ 03中我通常不会担心这个问题，除非你发现额外的副本实际上会导致性能问题。复制省略在现代编译器上似乎相当可靠。我认为人们的怀疑和坚持，你必须检查你的编译器支持RVO的表，现在大部分已经过时了。

简而言之，c++ 11在这方面并没有真正改变任何东西，除了那些不相信复制省略的人。