使用C ++ 11 copy＆amp; amp;时避免代码重复。移动

Question

C ++ 11“移动”是一个很好的功能，但我发现当与“复制”同时使用时，很难避免代码重复（我们都讨厌这个）。下面的代码是我实现的一个简单的循环队列（不完整），两个push（）方法几乎相同，除了一行。

我遇到过很多类似的情况。任何想法如何避免这种代码重复而不使用宏？

===编辑===

在这个特定的例子中，重复的代码可以重构并放入一个单独的函数中，但有时这种重构是不可用的或者不能轻易实现。

#include <cstdlib>
#include <utility>

template<typename T>
class CircularQueue {
public:
    CircularQueue(long size = 32) : size{size} {
        buffer = std::malloc(sizeof(T) * size);
    }

    ~CircularQueue();

    bool full() const {
        return counter.in - counter.out >= size;
    }

    bool empty() const {
        return counter.in == counter.out;
    }

    void push(T&& data) {
        if (full()) {
            throw Invalid{};
        }
        long offset = counter.in % size;
        new (buffer + offset) T{std::forward<T>(data)};
        ++counter.in;
    }

    void push(const T& data) {
        if (full()) {
            throw Invalid{};
        }
        long offset = counter.in % size;
        new (buffer + offset) T{data};
        ++counter.in;
    }

private:
    T* buffer;
    long size;
    struct {
        long in, out;
    } counter;
};

Answer 1

这里最简单的解决方案是使参数成为转发参考。这样你就可以只使用一个函数：

template <class U>
void push(U&& data) {
    if (full()) {
        throw Invalid{};
    }
    long offset = counter.in % size;
    // please note here we construct a T object (the class template)
    // from an U object (the function template)
    new (buffer + offset) T{std::forward<U>(data)};
    ++counter.in;
}

虽然方法有缺点：

• 它不是通用的，也就是说它不能总是这样做（以微不足道的方式）。例如，当参数不像T那样简单时（例如SomeType<T>）。

• 您可以延迟参数的类型检查。当使用错误的参数类型调用push时，可能会出现长且看似无关的编译器错误。

顺便说一句，在您的示例中，T&&不是转发引用。这是一个右值参考。那是因为T不是函数的模板参数。这是类，因此在实例化类时已经推断出它。所以编写代码的正确方法是：

void push(T&& data) {
    ...
    ... T{std::move(data)};
    ...
}

void push(const T& data) {
   ... T{data};
   ...
}

Answer 2

使用转发参考的解决方案是一个很好的解决方案。在某些情况下，它变得困难或烦人。作为第一步，使用接受显式类型的接口包装它，然后在cpp文件中将它们发送到模板实现。

现在有时第一步也会失败：如果有N个不同的参数都需要转发到容器中，这需要一个大小为2 ^ N的接口，并且可能需要跨越多层接口才能获得实施。

为此，我们可以携带或采取特定类型，而不是携带或采取特定类型。在最外层接口，我们将任意类型转换为那些/那些动作。

template<class T>
struct construct {
  T*(*action)(void* state,void* target)=nullptr;
  void* state=nullptr;
  construct()=default;
  construct(T&& t):
    action(
      [](void*src,void*targ)->T*{
        return new(targ) T( std::move(*static_cast<T*>(src)) );
      }
    ),
    state(std::addressof(t))
  {}
  construct(T const& t):
    action(
      [](void*src,void*targ)->T*{
        return new(targ) T( *static_cast<T const*>(src) );
      }
    ),
    state(const_cast<void*>(std::addressof(t)))
  {}
  T*operator()(void* target)&&{
    T* r = action(state,target);
    *this = {};
    return r;
  }
  explicit operator bool()const{return action;}
  construct(construct&&o):
    construct(o)
  {
    action=nullptr;
  }
  construct& operator=(construct&&o){
    *this = o;
    o.action = nullptr;
    return *this;
  }
private:
  construct(construct const&)=default;
  construct& operator=(construct const&)=default;
};

拥有construct<T> ctor对象之后，您可以通过T构建std::move(ctor)(location)的实例，其中location是一个正确对齐的指针，用于存储具有足够存储空间的T

constructor<T>可以从右值或左值T隐式转换。它也可以通过emplace支持进行增强，但这需要更多的样板才能正确完成（或者更容易实现开销）。

Live example。该模式是相对简单的类型擦除。我们将操作存储在函数指针中，并将数据存储在void指针中，并从存储的动作函数指针中的void指针重建数据。

上述类型擦除/运行时概念技术的成本适中。

我们也可以这样实现：

template<class T>
struct construct :
  private std::function< T*(void*) >
{
  using base = std::function< T*(void*) >;
  construct() = default;
  construct(T&& t):base(
    [&](void* target)mutable ->T* {
      return new(target) T(std::move(t));
    }
  ) {}
  construct(T const& t):base(
    [&](void* target)->T* {
      return new(target) T(t);
    }
  ) {}
  T* operator()(void* target)&&{
    T* r = base::operator()(target);
    (base&)(*this)={};
    return r;
  }
  explicit operator bool()const{
    return (bool)static_cast<base const&>(*this);
  }
};

依赖std::function为我们做类型擦除。

由于这只是为了工作一次（我们从源头移动），我强制一个右值上下文并消除我的状态。我还隐藏了我是std :: function的事实，因为它不符合这些规则。

Answer 3

<强>前言

在向界面添加移动语义支持时引入代码重复非常烦人。对于每个函数，您必须创建两个几乎相同的实现：从参数复制的实现，以及从参数移动的实现。如果一个函数有两个参数，它甚至不能代码重复它的代码四倍：

void Func(const TArg1  &arg1, const TArg2  &arg2); // copies from both arguments
void Func(const TArg1  &arg1,       TArg2 &&arg2); // copies from the first, moves from the second
void Func(      TArg1 &&arg1, const TArg2  &arg2); // moves from the first, copies from the second
void Func(      TArg1 &&arg1,       TArg2 &&arg2); // moves from both

在一般情况下，您必须为一个函数补充2 ^ N次重载，其中N是参数的数量。在我看来，这使得移动语义几乎无法使用。这是C ++ 11最令人失望的功能。

问题可能发生得更早。我们来看看以下代码：

void Func1(const T &arg);
T Func2();

int main()
{
    Func1(Func2());
    return 0;
}

将一个临时对象传递给接受引用的函数是很奇怪的。临时对象甚至可能没有地址，例如它可以缓存在寄存器中。但是C ++允许传递临时值，其中接受const（并且只有const）引用。在这种情况下，临时的寿命会延长到参考寿命结束。如果没有这个规则，我们就必须在这里做两个实现：

void Func1(const T& arg);
void Func1(T arg);

我不知道为什么允许传递接受引用的临时值的规则被创建（好吧，如果没有这个规则，我们将无法调用复制构造函数来制作临时对象的副本，所以Func1(Func2()) Func1 void Func1(T arg)无论如何都不会起作用:)），但是根据这条规则，我们不必对函数进行两次重载。

解决方案＃1：完美转发

不幸的是，没有这样的简单规则可以使得不必实现同一函数的两个重载：一个采用const左值引用，另一个采用rvalue引用。而是设计了完美转发

template <typename U>
void Func(U &&param) // despite the fact the parameter has "U&&" type at declaration,
                     // it actually can be just "U&" or even "const U&", it’s due to
                     // the template type deducing rules
{
    value = std::forward<U>(param); // use move or copy semantic depending on the 
                                    // real type of param
}

它可能看起来像允许避免重复的简单规则。但它并不简单，它使用了不明显的模板＆＃34;魔法＆＃34;为了解决这个问题，这个解决方案还有一些缺点，即使用完美转发的功能必须模板化：

• 该功能的实现必须位于标题中。
• 它打破了二进制大小，因为对于每个使用的参数类型组合（复制/移动），它会生成单独的实现（您在源代码中有单个实现，同时您最多有2 ^ N个实现）二进制）。
• 没有类型检查参数。您可以将任何类型的值传递给函数（因为函数接受模板类型）。实际检查将在实际使用参数的点完成。这可能会产生难以理解的错误消息，并导致一些意想不到的后果。

最后一个问题可以通过为完美转发函数创建非模板包装器来解决：

public:
    void push(      T &&data) { push_fwd(data); }
    void push(const T  &data) { push_fwd(data); }

private:
    template <typename U>
    void push_fwd(U &&data)
    {
        // actual implementation
    }

当然，只有当函数具有很少的参数（一个或两个）时，它才能在实践中使用。否则你必须制作太多的包装（最多2 ^ N，你知道）。

解决方案＃2：运行时检查可移动性

最终我认为检查movablity的参数不应该在编译时但是在运行时完成。我创建了一些带有构造函数的reference-wrapper类，它们采用了两种类型的引用（rvalue和const lvalue）。该类将传递给构造函数的引用存储为const左值引用，另外它存储了标志，传递的引用是否为rvalue。 然后你可以在运行时检查原始引用是否是rvalue，如果是，你只需将存储的引用转换为rvalue-reference。

不出所料，其他人在我面前得到了这个想法。他将此命名为＆＃34;在成语＆＃34; （我称之为＆＃34; pmp＆＃34; - 可能是可移动的参数）。您可以在详细信息here和here中阅读有关此成语的信息（关于＆＃34的原始页面;＆＃34;成语，如果您对问题真的感兴趣，我建议阅读文章的所有3部分，文章深入回顾了这个问题。）

简而言之，成语的实现如下：

template <typename T> 
class in
{
public:
  in (const T& l): v_ (l), rv_ (false) {}
  in (T&& r): v_ (r), rv_ (true) {}

  bool rvalue () const {return rv_;}

  const T& get () const {return v_;}
  T&& rget () const {return std::move (const_cast<T&> (v_));}

private:
  const T& v_; // original reference
  bool rv_;    // whether it is rvalue-reference
};

（完全实现还包含特殊情况，当某些类型可以隐式转换为T时）

使用示例：

class A
{
public:
  void set_vec(in<std::vector<int>> param1, in<std::vector<int>> param2)
  {
      if (param1.rvalue()) vec1 = param1.rget(); // move if param1 is rvalue
      else                 vec1 = param1.get();  // just copy otherwise
      if (param2.rvalue()) vec2 = param2.rget(); // move if param2 is rvalue
      else                 vec2 = param2.get();  // just copy otherwise
  }
private:
  std::vector<int> vec1, vec2;
};

＆＃34;＆＃34;的实施缺乏复制和移动构造函数。

class in
{
  ...
  in(const in  &other): v_(other.v_), rv_(false)     {} // always makes parameter not movable
                                                        // even if the original reference
                                                        // is movable
  in(      in &&other): v_(other.v_), rv_(other.rv_) {} // makes parameter movable if the
                                                        // original reference was is movable
  ...
};

现在我们可以这样使用它：

void func1(in<std::vector<int>> param);
void func2(in<std::vector<int>> param);

void func3(in<std::vector<int>> param)
{
    func1(param); // don't move param into func1 even if original reference
                  // is rvalue. func1 will always use copy of param, since we
                  // still need param in this function

    // some usage of param

    // now we don’t need param
    func2(std::move(param)); // move param into func2 if original reference
                             // is rvalue, or copy param into func2 if original
                             // reference is const lvalue
}

我们还可以重载赋值运算符：

template<typename T>
T& operator=(T &lhs, in<T> rhs)
{
    if (rhs.rvalue()) lhs = rhs.rget();
    else              lhs = rhs.get();
    return lhs;
}

之后我们不需要每次检查ravlue，我们可以这样使用它：

   vec1 = std::move(param1); // moves or copies depending on whether param1 is movable
   vec2 = std::move(param2); // moves or copies depending on whether param2 is movable

但不幸的是，C ++不允许将operator=重载为全局函数（https://stackoverflow.com/a/871290/5447906）。但我们可以将此函数重命名为assign：

template<typename T>
void assign(T &lhs, in<T> rhs)
{
    if (rhs.rvalue()) lhs = rhs.rget();
    else              lhs = rhs.get();
}

并像这样使用它：

    assign(vec1, std::move(param1)); // moves or copies depending on whether param1 is movable
    assign(vec2, std::move(param2)); // moves or copies depending on whether param2 is movable

这也不适用于构造函数。我们不能只写：

std::vector<int> vec(std::move(param));

这需要标准库来支持此功能：

class vector
{
    ...
public:
    vector(std::in<vector> other); // copy and move constructor
    ...
}

但标准对我们的＆＃34; in＆＃34;一无所知。类。在这里，我们无法将解决方法与assign类似，因此＆＃34;的使用与＃34}相同。上课是有限的。

<强>后记

T，const T&，T&&参数对我来说太多了。停止介绍做同样的事情（好吧，几乎一样）。 T就够了！

我更愿意这样写：

// The function in ++++C language:
func(std::vector<int> param) // no need to specify const & or &&, param is just parameter.
                             // it is always reference for complex types (or for types with
                             // special qualifier that says that arguments of this type
                             // must be always passed by reference).
{
    another_vec = std::move(param); // move parameter if it's movable.
                                    // compiler hides actual rvalue-ness
                                    // of the arguments in its ABI
}

我不知道标准委员会是否考虑过这种移动语义实现，但是在C ++中进行此类更改可能为时已晚，因为它们会使编译器的ABI与以前的版本不兼容。此外，它还增加了一些运行时开销，可能还有其他一些我们不知道的问题。