为什么在这种情况下不会发生复制省略？

Question

考虑这段代码：

#include <iostream>

struct S
{
    S(std::string s) : s_{s} { std::cout << "S( string ) c-tor\n"; }
    S(S const&) { std::cout << "S( S const& ) c-tor\n"; }
    S(S&& s) { std::cout << "S&& c-tor\n"; s_ = std::move(s.s_); }
    S& operator=(S const&) { std::cout << "operator S( const& ) c-tor\n";  return *this;}
    S& operator=(S&& s) { std::cout << "operator (S&&)\n"; s_ = std::move(s.s_); return *this; }
    ~S() { std::cout << "~S() d-tor\n"; }

    std::string s_;
};

S foo() { return S{"blaaaaa"}; }

struct A
{
    A(S s) : s_{s} {}

    S s_;
};

struct B : public A
{
    B(S s) : A(s) {}
};

int main()
{
    B b(foo());
    return 0;
}

当我用g++ -std=c++1z -O3 test.cpp 编译它时，我得到以下输出：

S( string ) c-tor
S( S const& ) c-tor
S( S const& ) c-tor
~S() d-tor
~S() d-tor
~S() d-tor

我想知道为什么没有复制省略？我期待更多这样的东西：

S( string ) c-tor
~S() d-tor

当我使用 -fno-elide-constructors 编译时，输出相同

Answer 1

正如预期的那样，foo 返回值确实会发生复制省略。

另外两个副本发生在 B 和 A 构造函数中。请注意，在输出中它调用了两次S(S const&)，而人们希望看到至少一个S(S&&) 对应B(foo())。这是因为编译器已经消除了使用S(S&&) 创建的那些额外副本。如果您使用-fno-elide-constructors 编译，您可以看到这两个额外的副本：

S::S(std::string)
S::S(S&&)
S::~S()
S::S(S&&)
S::S(const S&)
S::S(const S&)
S::~S()
S::~S()
S::~S()
S::~S()

而没有-fno-elide-constructors 的输出是：

S::S(std::string)
S::S(const S&)
S::S(const S&)
S::~S()
S::~S()
S::~S()

见copy initialization（用于函数参数的初始化）：

首先，如果 T 是一个类类型，并且初始化程序是一个 prvalue 表达式，其 cv-unqualified 类型与 T 相同，则初始化程序表达式本身，而不是从它临时实现的，是用于初始化目标对象：参见copy elision。

您可以通过引用接受来避免剩余的两个副本：

struct A
{
    A(S&& s) : s_{std::move(s)} {}
    S s_;
};

struct B : public A
{
    B(S&& s) : A(std::move(s)) {}
};

输出：

S( string ) c-tor <--- foo
S&& c-tor         <--- A::s_
~S() d-tor
~S() d-tor