为什么 std::vector 需要运算符 =

Question

我有一个关于我们可以存储在向量中的类的问题。 可以存储在向量中的要求是什么？ 似乎这样的类必须有赋值运算符。但我不确定是否仅此而已。

让我举个例子。 A 类具有 const int 成员。如果我不写 operator =，它就不会编译。但是在这个例子中，这个操作符什么都不做。该程序正确显示 10 和 20。看起来 operator = 是必需的，但实际上并未使用。

#include <iostream>
#include <vector>

class A {
 public:
  A(int a) : a_(a) {}
  A& operator =(const A& a2) { return *this;} // Without this, compile fails.
  void print() const {
    std::cerr << a_ << std::endl;
  }
 private:
  const int a_;
};

int main(int argc, char** argv) {
  std::vector<A> v;
  v.push_back(A(10));
  v.push_back(A(20));
  for (const A& a : v) a.print();
}

Answer 1

这可能会让你大吃一惊：

v.push_back(A(20));
v.push_back(A(10));
std::sort(begin(v), end(v));

vector 本身的某些方面需要可分配性，尽管我不知道是哪一个（我无法通过编译您的代码来判断，因为当我删除 operator=() 时我的编译器不会抱怨）。根据Wikipedia（引用'03 标准的相关部分），元素必须是CopyConstructible 和Assignable。

编辑： 一天后回到这一点，当std::vector 需要Assignable 时，它似乎很明显 - 任何时候它必须移动元素。例如，添加对v.insert() 或v.erase() 的调用，编译将失败。

Answer 2

如果我不写 operator =，它就不会编译。

这让我很惊讶，所以我查看了标准并发现：

您的示例具有隐式删除的复制构造函数，但如果手头有符合 C++11 标准的库，则仍应编译。

在您的示例中对vector 使用的类型施加约束的唯一表达式是push_back。

带有分配器A和value_typeT的序列容​​器类型X<T,A>的push_back()方法要求T为：

• CopyInsertable 如果传递了左值或 const 右值引用
• MoveInsertable 如果传递了非常量右值

这意味着它需要一个有效的复制构造函数或（在本例中）一个有效的移动构造函数，它将隐含在您的代码中。因此，在任何具有有效 C++11 标准库的编译器中编译都不应失败。

需要 vector 中包含的类型才能赋值的操作：

辅助条件

typdef std::vector<T> X;
X a,b;
X&& rv;
X::value_type t;
X::value_type&& u;
X::size_type n;
X::const_iterator p,q; // p = valid for a, q = valid and dereferencable
initializer_list<T> il;
[i,j) -> valid iterator-range

悲观*操作列表

如果 X 是 vector，则需要 T 可分配的操作是：

Statement              Requirement on T

a = b;                 CopyInsertable, CopyAssignable
a = rv;                MoveInsertable, MoveAssignable
a = il;                CopyAssignable
a.emplace(p, args);    MoveInsertable, MoveAssignable
a.insert(p, t);        CopyAssignable
a.insert(p, u);        MoveAssignable
a.insert(p, n, t);     CopyInsertable, CopyAssignable
a.insert(p, i, j);     EmplaceConstructible[from *i], MoveInsertable, MoveAssignable
a.insert(p, il);       -> a.insert(p, il.begin(), il.end());
a.erase(q);            MoveAssignable
a.erase(q1,q2)         MoveAssignable
a.assign(i,j);         Assignable from *i
a.assign(il);          -> a.assign(il.begin(), il.end());
a.assign(n,t)          CopyAssignable

* = 悲观的意思是可能存在若干要求实际生效的某些条件。如果您使用上面列出的表达式之一，您的类型 T 可能需要可赋值。

Answer 3

push_back on vector 会使 vector 在内存中增长，这意味着 旧对象需要通过赋值操作符复制到新对象= 因此你需要赋值运算符=。

Answer 4

如果您不创建自己的任何一个，编译器会保证复制构造函数和赋值运算符的可用性。 （虽然默认实现的正确性是另一回事）。在您的示例中，您几乎不必重载 A::opeartor=()。

这里的问题不是“缺少” operator=()，而是不能使用默认的，因为你声明了一个 const 数据成员

const int a_;

默认编译器生成的 operator=() 不能为 const 成员赋值。所以你必须超载自己：

A & A::opeartor=(const A & in)
{
    *const_cast<int*>(&a_) = in.a_; // !!!you are expected to do this.
}

因此，您的 A::operator=() 版本什么都不做，虽然使代码编译，但不会更改左侧操作数的 a_ 值，