显式复制构造函数或按值隐式参数

Question

我最近读到（不幸的是忘记在哪里），编写operator=的最佳方法是这样的：

foo &operator=(foo other)
{
    swap(*this, other);
    return *this;
}

而不是这样：

foo &operator=(const foo &other)
{
    foo copy(other);
    swap(*this, copy);
    return *this;
}

这个想法是，如果使用右值调用operator=，第一个版本可以优化副本的构造。因此，当使用右值调用时，第一个版本更快，而当使用左值调用时，两个版本是等效的。

我很好奇其他人对此有何看法？人们会因为缺乏明确性而避免使用第一个版本吗？我是否正确地认为第一个版本可以更好并且永远不会更差？

Answer 1

您可能从以下位置阅读： http://cpp -next.com/archive/2009/08/want-speed-pass-by-value/

我没有太多要说的，因为我认为该链接很好地解释了原理。有趣的是，我可以确认第一种形式会导致我使用 MSVC 构建的副本较少，这是有道理的，因为编译器可能无法对第二种形式进行复制消除。我同意第一种形式是严格的改进，并且绝不会比第二种更差。

编辑：
第一种形式可能不太惯用，但我认为它并不太不清楚。 （IMO，这并不比第一次看到赋值运算符的复制和交换实现更令人惊讶。）

编辑#2：哎呀，我的意思是写复制省略，而不是 RVO。

Answer 2

从可读性和“最少惊喜”的角度来看，我通常更喜欢第二个，但是我确实承认，当参数是临时参数时，第一个可以更有效。

第一个确实可能导致无副本，而不仅仅是单个副本，可以想象，这在极端情况下可能是一个真正的问题。

例如，采用这个测试程序。 gcc -O3 -S（gcc 版本 4.4.2 20091222 (Red Hat 4.4.2-20) (GCC)）生成一次对 B 的复制构造函数的调用，但不会调用 A 的函数复制构造函数 < code>f （A 和 B 都内联赋值运算符）。 A 和 B 都可以被视为非常基本的字符串类。数据的分配和复制将发生在构造函数中，而释放将发生在析构函数中。

#include <algorithm>

class A
{
public:
    explicit A(const char*);
    A& operator=(A val)      { swap(val); return *this; }
    void swap(A& other)      { std::swap(data, other.data); }
    A(const A&);
    ~A();

private:
    const char* data;
};

class B
{
public:
    explicit B(const char*);
    B& operator=(const B& val)  { B tmp(val); swap(tmp); return *this; }
    void swap(B& other)         { std::swap(data, other.data); }
    B(const B&);
    ~B();

private:
    const char* data;
};

void f(A& a, B& b)
{
    a = A("Hello");
    b = B("World");
}

Answer 3

考虑到这一点，

foo &foo::operator=(foo other) {/*...*/ return *this;}
foo f();

在这样的代码中

foo bar;
bar = f();

编译器可能更容易消除对复制构造函数的调用。使用 RVO，它可以使用运算符的 other 参数的地址作为 f() 构造其返回值的位置。

看来这种优化对于第二种情况也是可能的，尽管我认为这可能会更困难。 （特别是当运算符未内联时。）

Answer 4

这两个其实是一样的。唯一的区别在于您在调试器中按“Step In”的位置。而且你应该提前知道在哪里做。

Answer 5

我认为您可能会混淆以下之间的区别：

foo &operator=(const foo &other); 和
const foo &operator=(const foo &other);

第一种形式应该用于允许： (a = b) = c;