如何通过移动语义移动多个参数？

Question

假设我有一个 Object MeasurementValues，它有 n 个不同的指针（这个例子只显示了指向原始类型的指针，但也可能出现指向其他复杂对象的指针）。

class MesaurementValues {
   private:
     int *measurement_1;
     double *measurement_2;
     long long *measurement_3;
     //..
     float *measurement_n;

     int noPointer;
}

我知道，无论如何，这个例子可能有点做作。我尝试在我的代码中填写Rule of Five。

我必须这样做吗

this.measurement_x = old.measurement_x ;// for all x = {1,..,n} ?

Answer 1

首先请注意，对于普通旧数据类型 (POD) 成员，移动语义比复制语义没有任何优势，但是当您的类包含其他类对象和/或数组时，它肯定会这样做。当你实现移动语义时，这意味着你有一个“移动构造函数”和/或一个“移动赋值运算符”，在你的类中看起来像这样：

class MesaurementValues { private:
     int *measurement_1;
     double *measurement_2;
     long long *measurement_3;
     //..
     float *measurement_n;

     int noPointer; 

     //a couple different objects
     someObject*       pObj1;
     differentObject*  pObj2;

 public:
  MeasurementValues( MeasurementValues&& move );  //move-constructor
  MeasurementValues& operator= (MeasurementValues&& move); //move-assignment
}

-假设你的类有 POD 数据和类对象，并且 -假设有很多变量需要移动：

MeasurementValues::MeasurementValues( MeasurementValues&& old) {
    //copy plain-old-data over
    measurement_1 = old.measurement_1;
    measurement_2 = old.measurement_2;

    //copy over values of the pointers
    pObj1 = old.pObj1;
    pObj2 = old.pObj2;
}

请记住，正如其他发布者所说，移动语义只有在您的数据成员是其他 可移动 对象或动态分配的内存时才有优势。

编辑：

指针必须变为“无效”，因为它们已被移动。因此，我会将它们设置为 null 以防止出现意外行为：

MeasurementValues::MeasurementValues( MeasurementValues&& old) 
: measurement_1() //null...
  //,...
{
  //Swapping null into old...
  std::swap(measurement_1, old.measurement_1);
  //...
}

Answer 2

Do I have to
this.measurement_x = old.measurement_x ;// for all x = {1,..,n} ?

我会依赖 pimpl 习惯用法，并使用类似唯一指针的东西。下面是一个详细的例子。请注意，您只需使用 Impl，并依赖其默认值（因为它不包含指针）。

#include <iostream>
#include <memory>

struct Moveable
{
  public:
    Moveable();
    ~Moveable();

    Moveable(const Moveable& m);
    Moveable& operator=(const Moveable& m);

    Moveable(Moveable&& m);
    Moveable& operator=(Moveable&& m);

    int foo() const;


  private:
    struct Impl;
    std::unique_ptr<Impl> pimpl_;
};

//Moveable.cpp
struct Moveable::Impl
{
  Impl(): a(1), b(2), c(3), buffer(){}
  int a, b, c;
  char buffer[10000]; //Make it worth our while...
};

int Moveable::foo() const{ return pimpl_->a+pimpl_->b+pimpl_->c;}

Moveable::Moveable()
: pimpl_(new Impl)
{
  std::cout << "Default " << (void*)this << std::endl;
}

Moveable::~Moveable()
{
  std::cout << "Destruct " << (void*)this << std::endl;
  //automagically...
}

Moveable::Moveable(const Moveable&m)
: pimpl_(new Impl(*m.pimpl_))
{
  std::cout << "Copying " << &m << " to " << (void*)this << std::endl;
}

Moveable& Moveable::operator=(const Moveable& m)
{
  std::cout << "Copy assign " << (void*)&m << " to " << (void*)this << std::endl;
  *pimpl_ = *m.pimpl_; //Relying on their defaults...
}

Moveable::Moveable(Moveable&& m)
: pimpl_(move(m.pimpl_))
{
  std::cout << "Moving " << (void*)&m << " to " << (void*)this << std::endl;
}

Moveable& Moveable::operator=(Moveable&& m)
{
  pimpl_ = move(m.pimpl_);
  std::cout << "Move assigning " << &m << " to " << (void*)this << std::endl;
}

int main() 
{
  Moveable x;
  Moveable y(x); //Copying...
  y = x; //Copying assign

  y = Moveable(); //Default construct, then move assignment, destruct temp
  Moveable z(std::move(y));
  std::cout << "Calling foo " << z.foo() << std::endl;

  return 0;
}