0

在以下示例中，我不明白为什么赋值运算符中的参数使用复制构造函数而不是要构建的移动构造函数

struct Foo
{
    int data;

    Foo()
    {
        static int cpt = 1;
        data = cpt++;
        std::cout <<  "Foo\n";
    }

    Foo(const Foo& foo)
    {
        std::cout <<  "const Foo&\n";
        data = foo.data; 
    }

    Foo(Foo&& foo)
    {
        std::cout <<  "Foo&&\n";
        data = foo.data;
        foo.data = 0;
    }

    Foo& operator= (Foo foo)  //<--- call the copy ctor and not the move ctor as I expected
    {
        data = foo.data;
    std::cout <<  "operator=\n";
    return *this;   
    }

    Foo& operator+ (const Foo& foo)
    {
        data += foo.data;
        return *this;
    }
};


int main()
{ 
    Foo f;
    Foo f1;
    Foo f3;

    f3 = f + f1;

    std::cout << f3.data;

    std::cin.ignore(); 

    return 1; 
}

输出：

Foo
Foo
Foo
const Foo&
operator=
3

编译器：MSVCS2012 CTP

编辑：

从什么是移动语义？

“但是如果你说 a = x + y，移动构造函数将初始化它（因为表达式 x + y 是一个右值）......”

但实际上 x + y 只有operator +在以“特殊”方式实现时才是右值，所以呢？

4

3 回答 3

3

你的假设是不正确的。赋值运算符使用任何可用的构造函数：

Foo a;
Foo b;

Foo x;

x = a;             // copy constructor
x = std::move(b);  // move constructor
x = Foo();         // move constructor

您的误解来自您的笨拙operator+，它不会像您所相信的那样返回右值。

更新：正确的“加号”运算符对如下所示：

Foo& operator+= (const Foo& foo)
{
    data += foo.data;
    return *this;
}

Foo operator+ (const Foo& rhs)
{
    return Foo(*this) += rhs;
}

（通常，您也可以制作这些签名Foo rhs并std::move(rhs)在适当的情况下使用，尽管对于这个简单的类没有任何区别。）

于 2013-04-02T08:14:58.760 回答
1

正如其他人指出的那样，问题是operator +(). 具体来说，它返回一个Foo&，即一个左值引用。由于左值引用是左值（这不是重言式），它不能绑定到右值引用。因此，Foo(Foo&&)无法调用。

我不会说operator +()andoperator +=()应该如何实现（有关此主题的更多信息，请参阅其他答案和其中的评论）。我将专注于rvalue x lvalue。正如 Scott Meyers在 C++11 中的通用引用中所说

这些术语的精确定义很难开发（C++11 标准通常根据具体情况指定表达式是左值还是右值）......

但是，可以使用以下函数来检查对象是左值还是右值：

#include <type_traits>

template <typename T>
bool is_lvalue(T&&) {
    return std::is_reference<T>::value;
}

template <typename T>
bool is_rvalue(T&&) {
    return !std::is_reference<T>::value;
}

例如下面的代码

struct bar {
    bar&  operator+(const bar&) { return *this;  }
    bar&& operator-(const bar&) { return std::move(*this); }
};

int main() {

    bar b1;
    bar b2;

    std:: cout << std::boolalpha;

    std:: cout << is_rvalue( b1 + b2) << std::endl;
    std:: cout << is_rvalue( b1 - b2) << std::endl;

}

输出

false
true

注意：bar，受原始代码的启发，使用operator +()，operator -()但就这件事而言，作为运算符并没有什么特别之处。

功能is_lvalue()和is_rvalue()可以改进。例如它们可以，constexrp但我在这里保持简单，因为一些编译器（特别是 VS2012）还没有实现constexpr。

关于这些函数如何工作的解释，是基于如何T推导出来的。我引用前面提到的 Scott Meyers 的文章：

在模板参数 [ ... ] 的类型推导期间，相同类型的左值和右值被推导为具有略微不同的类型。特别是，类型 T 的左值被推导为类型 T&（即，对 T 的左值引用），而类型 T 的右值被推导为简单类型 T。

于 2013-04-02T10:48:05.223 回答
0

您需要提供两个重载，operator=因为您的代码不会移动data：

Foo& operator= (const Foo& foo)
{
    data = foo.data;
    return *this;   
}

// only needed if the implementation can benefit from a movable object
Foo& operator= (Foo&& foo)
{
    data = std::move(foo.data); // without std::move, as above, the copy-ctor is called
    return *this;   
}

也就是说，这个签名有什么问题：

Foo& operator= (Foo foo);

? 问题是，您总是强制传递一个对象，这会导致效率低下。考虑：

Foo f, f2;
f = f2;

（当然，在示例中，优化器很可能会移除所有开销）。

一般来说，operator=不需要副本，所以它不应该要求一个。另请参阅 Andy Prowl 关于如何“正确”获取参数的精彩观点。

于 2013-04-02T08:55:36.610 回答