组合或继承

对于由其他类组成的类（通过组合或继承），可以使用 boost::move 函数轻松编写移动构造函数和移动赋值函数。

class Base
{
   BOOST_COPYABLE_AND_MOVABLE(Base)

   public:
   Base(){}

   Base(const Base &/*x*/) {/**/}            // Copy ctor

   Base(BOOST_RV_REF(Base) /*x*/) {/**/}     // Move ctor

   Base& operator=(BOOST_RV_REF(Base) /*x*/)
   {/**/ return *this;}                      // Move assign

   Base& operator=(BOOST_COPY_ASSIGN_REF(Base) /*x*/)
   {/**/ return *this;}                      // Copy assign

   virtual Base *clone() const
   {  return new Base(*this);  }

   virtual ~Base(){}
};

class Member
{
   BOOST_COPYABLE_AND_MOVABLE(Member)

   public:
   Member(){}

   // Compiler-generated copy constructor...

   Member(BOOST_RV_REF(Member))  {/**/}      // Move ctor

   Member &operator=(BOOST_RV_REF(Member))   // Move assign
   {/**/ return *this;  }

   Member &operator=(BOOST_COPY_ASSIGN_REF(Member))   // Copy assign
   {/**/ return *this;  }
};

class Derived : public Base
{
   BOOST_COPYABLE_AND_MOVABLE(Derived)
   Member mem_;

   public:
   Derived(){}

   // Compiler-generated copy constructor...

   Derived(BOOST_RV_REF(Derived) x)             // Move ctor
      : Base(BOOST_MOVE_BASE(Base, x)),
        mem_(boost::move(x.mem_)) { }

   Derived& operator=(BOOST_RV_REF(Derived) x)  // Move assign
   {
      Base::operator=(BOOST_MOVE_BASE(Base, x));
      mem_ = boost::move(x.mem_);
      return *this;
   }

   Derived& operator=(BOOST_COPY_ASSIGN_REF(Derived) x)  // Copy assign
   {
      Base::operator=(x);
      mem_  = x.mem_;
      return *this;
   }
   // ...
};

	重要提示
	由于仿真代码的限制，在移动基类部分之前需要将其强制转换为 `Base &`，并调用基类的移动构造函数而不是复制构造函数。

每个子对象现在都将被单独处理，调用 move 来绑定到子对象的移动构造函数和移动赋值运算符。 Member 已编写了移动操作（就像我们之前的 clone_ptr 示例一样），这将完全避免成本高得多的复制操作。

Derived d;
Derived d2(boost::move(d));
d2 = boost::move(d);

请注意，上面将参数 x 视为左值引用。这就是为什么在传递给基类时需要使用 move(x) 而不是直接使用 x。这是移动语义的一个关键安全特性，旨在防止意外地从命名变量中移动两次。所有从左值进行的移动都显式发生。

Boost C++ 库

组合或继承