c++ - 移动值/对象包装器的构造函数？

Question

考虑以下类：

template <typename Type>
class Wrapper
{
    public:
        Wrapper(const Type& x) : _data(x) {;}
        Wrapper<Type>& operator=(const Type& x) {_data = x; return *this;}
    protected:
        Type _data;
};

此类的移动构造函数Wrapper(Type&& x)和移动赋值运算符的定义是什么operator=(Type&& x)？

Answer 1

Wrapper(Type&& x) : _data(std::move(x)) {}
Wrapper& operator=(Type&& x) {_data = std::move(x); return *this;}

Answer 2

用 C++11 编写此代码的一种有趣方式是：

template<typename A, typename B, typename T=void*>
using IfSameBaseType = std::enable_if<
  typename std::is_same<
    typename std::remove_cv<A>::type,
    typename std::remove_cv<B>::type
  >::type,
  T
>::type;

template <typename T>
class Wrapper
{
  public:
    template<typename U, typename unused>
    Wrapper(U&& u, unused* do_not_use=(IfSameBaseType<T,U>*)nullptr) :
      data_( std::forward(u) )
    {}
    template<typename U>
    IfSameBaseType<T,U,Wrapper<Type>>& operator=(U&& x) {
      data_ = std::forward(x);
      return *this;
    }
  protected:
    T data_;
};

在这里，我&&在类型推导上下文中使用为 l 和 r 值引用提供单个覆盖，然后我通过std::forward. 这些IsSameBaseType东西只是确保我只为该类型编写构造函数T——我可以扩展它并说“可隐式转换为 T”，而不是IsSameBaseType没有那么多麻烦。

这样做的好处是我们有更少的重复方法。缺点是模板愚蠢可能会分散某人的注意力。