c++ - CV 限定符会影响返回对象的复制省略吗？

Question

这可能是 this question 的重复项，但那里讨论的示例处理的是内置类型 (int)。在我目前的工作中，我经常因为未能像这样声明函数而在代码审查中被标记:

std::string getName();

作为:

const std::string getName();

后者对我来说似乎毫无意义，但我的一些同事认为 const 限定符可以让编译器有机会避免复制返回值(或一些类似的优化)。我在这个小测试程序上运行了 gcc -s:

#include <iostream>
#include <string>

const std::string name()
{
    return "World";
}

int main()
{
    std::cout << "Hello, " << name() << '!' << std::endl;
    return 0;
}

如果我从 name() 函数中删除 const，则生成的程序集是相同的。但是，我的同事建议 const 限定符提供的优化(如果有的话)可能是特定于平台/编译器的，因此最好在 const 上添加 'just in案件'。我不太愿意养成这个习惯，因为我还没有设法在野外找到任何这样做的代码。

所以我的问题是两个部分:

1. 上面例子中的 const 限定符有什么区别吗？
2. 如果返回值是某个 class Foo 的实例而不是 std::string 会有影响吗？

我的同事们是非常通情达理的人，他们乐于接受这样一种想法，即这是一种或多或少是偶然地潜入我们代码库的古怪约定。但是没有人对这种特殊用法有足够的把握，以至于他们愿意说这是完全没有必要的。

Answer 1

我在您的示例中没有看到任何 (N)RVO。 RVO，或复制/移动省略，允许但在 [class.copy]/31 中没有强制要求。以下是一些示例:

#include <iostream>

struct A
{
    A(int i) { std::cout << "ctor\n"; }
    ~A() { std::cout << "dtor\n"; }
    A& operator=(A const&)
    { std::cout << "copy-assignment-op\n"; return *this; }

    // N.B. no default move ctor will be created!
};

A foo() { return 42; }
A bar() { return A(42); }

const A cfoo() { return 42; }
const A cbar() { return A(42); }

int main()
{
    std::cout << "A a(42);\n";
    A a(42);
    std::cout << "\na = foo();\n";
    a = foo();
    std::cout << "\na = bar();\n";
    a = bar();

    std::cout << "\nA b( foo() );\n";
    A b( foo() );
    std::cout << "\nA c( bar() );\n";
    A c( bar() );

    std::cout << "\nA d( cfoo() );\n";
    A d( cfoo() );
    std::cout << "\nA e( cbar() );\n";
    A e( cbar() );

    std::cout << "\ndtors following for a, b, c, d, e\n";
}

最新编译器的输出(许多甚至在 -O0)是:

A a(42);
ctor

a = foo();
ctor
copy-assignment-op
dtor

a = bar();
ctor
copy-assignment-op
dtor

A b( foo() );
ctor

A c( bar() );
ctor

A d( cfoo() );
ctor

A e( cbar() );
ctor

dtors following for a, b, c, d, e
dtor
dtor
dtor
dtor
dtor

As you can see, whether the return type is const or not doesn't affect RVO. However, it could, as it isn't mandated. So if you have an old / weird compiler -- test it (or look up in the documentation).

---

There are two kinds of RVO in the example above:

1. copy/move elision of an object with automatic storage duration to the return value (also called NRVO), such as

   A foo() { A a; return a; }
   

   [class.copy]/31 允许这个

   in a return statement in a function with a class return type, when the expression is the name of a non-volatile automatic object (other than a function or catch-clause parameter) with the same cv-unqualified type as the function return type

2. 将临时对象的省略复制/移动到另一个对象

   A a( foo() ); // only 1 ctor is called
   A foo() { return A(); } // no copy/move from the temporary to the return value
   

   这是允许的

   when a temporary class object that has not been bound to a reference (12.2) would be copied/moved to a class object with the same cv-unqualified type

其中“cv-unqualified”(可能)表示这种优化忽略了顶级 const 限定。