将const std :: string&作为参数传递的日子是多少？

Question

我听取了香草萨特最近的谈话谁建议的理由来传递std::vector和std::string利用const &在很大程度上消失了.他建议现在更好地编写如下函数:

std::string do_something ( std::string inval )
{
   std::string return_val;
   // ... do stuff ...
   return return_val;
}

我理解return_val在函数返回时将是一个rvalue,因此可以使用非常便宜的移动语义返回.但是,inval仍然远大于引用的大小(通常实现为指针).这是因为a std::string具有各种组件,包括指向堆的指针和char[]用于短字符串优化的成员.所以在我看来,通过引用传递仍然是一个好主意.

谁能解释为什么Herb可能会说这个？

Answer 1

赫伯说他说的原因是因为这样的情况.

假设我有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采用a 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的小字符串.值得做吗？

这取决于您的使用案例.你讨厌内存分配多少钱？

Answer 2

将const std :: string&作为参数传递的日子是多少？

不.许多人将此建议(包括Dave Abrahams)超出其适用的域,并简化它以应用于所有 std::string参数 - 始终通过std::string值传递不是任何和所有任意参数和应用程序的"最佳实践",因为优化这些会谈/文章的重点仅适用于一组有限的案例.

如果您返回一个值,改变参数或取值,那么按值传递可以节省昂贵的复制并提供语法上的便利.

与以往一样,当您不需要副本时,通过const引用可以节省大量复制.

现在来看具体的例子:

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

如果堆栈大小是一个问题(假设没有内联/优化),return_val+ inval> return_val- IOW,可以通过在此处传递值来减少峰值堆栈使用量(注意:ABI的过度简化).同时,通过const引用可以禁用优化.这里的主要原因不是避免堆栈增长,而是确保可以在适用的地方执行优化.

通过const引用的日子并没有结束 - 规则比以前更加复杂.如果性能很重要,那么根据您在实现中使用的详细信息,最好考虑如何传递这些类型.

Answer 3

这在很大程度上取决于编译器的实现.

但是,它还取决于您使用的是什么.

让我们考虑下一个功能:

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会执行深层复制.

在我的电脑上,使用g ++ 4.6.1,我得到了以下结果:

• 通过引用变量:1000000000次迭代 - >经过的时间:2.25912秒
• 按值变化:1000000000次迭代 - >经过的时间:27.2259秒
• 通过引用的字面值:100000000次迭代 - >经过的时间:9.10319秒
• 按字面值计算:100000000次迭代 - >经过的时间:8.62659秒

Answer 4

简答:不!答案很长:

• 如果您不修改字符串(处理为只读),请将其作为传递const ref&.
  (const ref&当使用它的函数执行时,显然需要保持在范围内)
• 如果您打算修改它或者您知道它将超出范围(线程),请将其作为a传递value,不要复制const ref&函数体内部.

在cpp-next.com上有一篇名为"想要速度,按值传递!"的帖子..TL; DR:

指南:不要复制你的函数参数.相反,按值传递它们,让编译器进行复制.

翻译^

不要复制函数参数 ---意味着:如果计划通过将参数值复制到内部变量来修改参数值,则只需使用值参数.

所以,不要这样做:

std::string function(const std::string& aString){
    auto vString(aString);
    vString.clear();
    return vString;
}

这样做:

std::string function(std::string aString){
    aString.clear();
    return aString;
}

当您需要修改函数体中的参数值时.

您只需要知道您打算如何在函数体中使用该参数.只读或不...并且如果它在范围内.

Answer 5

除非你真的需要副本,否则它仍然是合理的const &.例如:

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

如果你改变这个来获取字符串的值,那么你最终将移动或复制参数,并且没有必要.复制/移动不仅可能更昂贵,而且还会引入新的潜在故障; 复制/移动可能会抛出异常(例如,复制期间的分配可能会失败),而对现有值的引用则不能.

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

简而言之,除了那些不信任copy elision的人之外,C++ 11在这方面并没有真正改变.

Answer 6

几乎.

在C++ 17中,我们basic_string_view<?>将基本上用于std::string const&参数的一个狭窄用例.

移动语义的存在已经消除了一个用例std::string const&- 如果你计划存储参数,那么取一个std::stringby值就更合理了,因为你可以move超出参数.

如果有人用原始C调用你的函数,"string"这意味着只std::string分配了一个缓冲区,而不是两个缓冲区std::string const&.

但是,如果您不打算复制,那么std::string const&在C++ 14中使用by 仍然很有用.

使用std::string_view,只要您没有将所述字符串传递给期望C样式'\0'终止字符缓冲区的API ,您就可以更高效地获得std::string类似功能,而不会冒任何分配风险.原始C字符串甚至可以变成std::string_view没有任何分配或字符复制的字符串.

在这一点上,std::string const&当你没有复制批量数据,并且将它传递给期望空终止缓冲区的C风格的API时,你需要使用提供的更高级别的字符串函数std::string.实际上,这是一组罕见的要求.

Answer 7

std::string不是普通旧数据(POD),它的原始大小并不是最相关的东西.例如,如果传入一个高于SSO长度并在堆上分配的字符串,我希望复制构造函数不复制SSO存储.

建议这样做的原因是因为它inval是从参数表达式构造的,因此总是在适当时移动或复制 - 假设您需要参数的所有权,则不会有性能损失.如果不这样做,const参考仍然是更好的方法.

Answer 8

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

以下是衡量要求的代码:

#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值时需要额外的移动构造.对于任何给定的情况,这可能是也可能是不可接受的.两种解决方案都有优点和缺点.

Answer 9

Herb Sutter与Bja​​rne Stroustroup一起推荐const std::string&作为参数类型; 请参阅https://github.com/isocpp/CppCoreGuidelines/blob/master/CppCoreGuidelines.md#Rf-in.

在这里的任何其他答案中都没有提到的缺陷:如果将字符串文字传递给const std::string&参数,它将传递对临时字符串的引用,该字符串是即时创建的,用于保存文字的字符.如果您随后保存该引用,则在取消分配临时字符串后它将无效.为安全起见,您必须保存副本,而不是参考.问题源于字符串文字是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
}

OUTPUT:

const char * constructor
const std::string& constructor

Second string
Second string

Answer 10

使用C++参考的IMO std::string是一种快速和简短的本地优化,而使用传递值可能(或不是)更好的全局优化.

所以答案是:它取决于具体情况:

1. 如果您从外部函数编写所有代码到内部函数,您知道代码的作用,您可以使用该引用const std::string &.
2. 如果您编写库代码或使用大量库代码传递字符串,那么通过信任std::string复制构造函数行为,您可能在全局意义上获得更多.

Answer 11

请参阅"Herb Sutter"回到基础知识!现代C++风格的基本知识".在其他主题中,他回顾了过去给出的参数传递建议,以及C++ 11带来的新想法,特别是按值传递字符串的想法.

基准测试显示std::string,在函数将以任何方式复制它的情况下,按值传递s可能会明显变慢!

这是因为您强制它始终制作完整副本(然后移动到位),而const&版本将更新旧字符串,这可能会重用已分配的缓冲区.

请参阅他的幻灯片27:对于"设置"功能,选项1与以往一样.选项2为右值参考添加了一个重载,但如果有多个参数,则会产生组合爆炸.

它仅适用于"sink"参数,其中必须创建字符串(不更改其现有值),即按值传递技巧有效.也就是说,参数直接初始化匹配类型的成员的构造函数.

如果你想看看你有多深入担心这一点,请观看Nicolai Josuttis的演讲并祝你好运("完美 - 完成!"在找到上一版本的错误后n次.曾经去过那里？)

这也归纳为标准指南中的⧺F.15.