重载复合赋值运算符的规范方法是什么？

Question

这似乎是一个棘手的问题，因为您无法向向量添加新的成员函数。这种形式避免了最少的副本：

std::vector<T>& operator+=(std::vector<T>& lhs, const std::vector<T>& rhs)

但自分配失败，因此唯一适用于自分配的是：

template <typename T>
std::vector<T>& operator+=(std::vector<T>& lhs, std::vector<T> rhs)
{
    lhs.insert(lhs.end(), rhs.begin(), rhs.end());
    return lhs;
}

但这需要额外的副本。这样做的正确方法是什么？

在我的问题中，上述形式“不起作用”是模棱两可的，因为它们似乎适用于整数（尽管不适用于 std::strings）。有人指出这是因为它是未定义的行为。

Answer 1

问题：

template <typename T>
std::vector<T>& operator+=(std::vector<T>& lhs, const std::vector<T>& rhs)
{
    lhs.insert(lhs.end(), rhs.begin(), rhs.end());
    return lhs;
}

不是签名，它会将迭代器传递给insert，这些迭代器在插入完成之前变得无效。

只需使用the correct technique for appending a vector to itself，无需额外复制。

template <typename T>
void concat_in_place(std::vector<T>& lhs, const std::vector<T>& rhs)
{
    auto left_count = lhs.size();
    auto right_count = rhs.size();
    lhs.resize(left_count + right_count);
    std::copy_n(rhs.begin(), right_count, lhs.begin() + left_count);
}

Answer 2

根据政策，您不应该在两个不同的std 类型之间使用运算符重载它们。可能是未定义的行为：标准不明确。

如果您想在 std 容器上使用运算符语法，我建议使用命名运算符。它也更清楚，因为向量上的运算符可以是容器运算符或元素运算符，这就是默认情况下缺少它们的原因。 v +append= v2; 显然是附加的。 （创建一个静态追加对象，并用你的向量重载它的 lhs 和 rhs 运算符，并在中间步骤中使用表达式模板）

// mini named operator library.  Only supports + for now:
template<class Kind>
struct named_operator {};
template<class OP, class LHS> struct plus_ {
  LHS lhs;
  template<class RHS>
  decltype(auto) operator=(RHS&&rhs)&&{
    return plus_assign(std::forward<LHS>(lhs), OP{}, std::forward<RHS>(rhs));
  }
  template<class RHS>
  decltype(auto) operator+(RHS&&rhs)&&{
    return plus(std::forward<LHS>(lhs), OP{}, std::forward<RHS>(rhs));
  }
};
template<class Tag, class LHS>
plus_<Tag,LHS> operator+( LHS&& lhs, named_operator<Tag> ) {
  return {std::forward<LHS>(lhs)};
}

// creating a named operator:
static struct append_tag:named_operator<append_tag> {} append;

// helper function, finds size of containers and arrays:
template<class T,std::size_t N>
constexpr std::size_t size( T(&)[N] ) { return N; }
template<class C>
constexpr auto size(C&& c)->decltype(c.size()) { return c.size(); }

// implement the vector +append= range:
template<class T, class A, class RHS>
std::vector<T,A>& plus_assign(std::vector<T,A>&lhs, append_tag, RHS&& rhs) {
  auto rhs_size = size(rhs);
  lhs.reserve(lhs.size()+rhs_size);
  using std::begin; using std::end;
  copy_n( begin(rhs), rhs_size, back_inserter(lhs) );
  return lhs;
}
// implement container +append+ range:
template<class LHS, class RHS>
LHS plus( LHS lhs, append_tag, RHS&& rhs ) {
  using std::begin; using std::end; using std::back_inserter;
  copy_n( begin(rhs), size(rhs), back_inserter(lhs) );
  return std::move(lhs);
}

live example

请注意，std::vector<int> +append= std::list<int> +append+ std::array<double, 3> 与上述代码一起使用。