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

Question

我有以下课程：

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

在这段代码中

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。

Answer 2

看来你需要把 f 改成

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

然后这样称呼它：

f(c);

请看：similar example

注意：我尚未对其进行测试，但请参阅其他线程的答案以获得解释。