调用复制构造函数而不是移动构造函数

Question

我有以下 class :

class Component {
  public:
    // Constructor
    explicit Component(const void* data, size_t size)
      : _size(size),
        _data(new int[_size]) {
          (void)memcpy(_data, data, _size);
    }

    // Destructor
    ~Component() {
      delete[] _data;
    }

    // Copy-ctor.
    Component(const Component& o)
      : _size(o._size),
        _data(new uint8_t[_size]) {
     (void)memcpy(_data, o._data, _size);
   }

   // Assignment operator
   Component& operator=(const Component& o) {
     if (this != &o) {
       delete[] _data;
       _size = o.getSize();
       _data = new uint8_t[_size];
       (void)memcpy(_data, o.getData(), _size);
     }
     return *this;
   }

   // Move-constructor
   Component(Component&& o)
     : _size(o._size),
       _data(o._data) {
     o._data = nullptr;
   }

   // Move assignment
   Component& operator=(Component&& o) {
     if (this != &o) {
       delete[] _data;
       _size = o._size;
       _data = o._data;
       o._data = nullptr;
     }
     return *this;
   }

   private:
    size_t _size;
    int _data;
};

我想测试我的移动构造函数。所以我尝试这样做：

void f(Component&& c) {
  Component c2 = c; // Expect to use move-constructor
}
int data[] = { 0, 1 };
Component c{&data[0], sizeof(data)};
f(std::move(c)); // getting a rvalue reference from lvalue reference

但后来我看到调用的是我的复制构造函数，而不是移动构造函数。你知道为什么吗？

Answer 1

看来您需要将 f 更改为

void f(Component&& c) {
    Component c2 = std::move(c);
}

并这样称呼它：

f(c);

请看：

注意：我还没有测试过，但请参阅其他线程的答案以获得解释。

Answer 2

在此代码中

void f(Component&& c)
{
    Component c2 = c; // Expect to use move-constructor
}

c 是左值。这就是让您在 f.

中多次使用它的原因

&& 参数表示调用者不再需要该对象，您可以随意拾取它。但是现在你的函数在概念上是所有者......你调用的子程序不应该掠夺你的对象，除非你依次授予它们权限。

使 c 成为右值会破坏许多用例，例如：

void f(string&& s)
{
    string inputfilename = s + ".in";
    string outputfilename = s + ".out";
    // use s in some other ways
}

要允许子程序获取您的参数，请使用 std::move。

调用复制构造函数而不是移动构造函数

copy-constructor called instead of move-constructor

c++

copy-constructor

move-constructor

c++11