Why does std::vector have two assignment operators?

Question

Since 2011, we have both copy and move assignment. However, this answer argues quite convincingly that, for resource managing classes, one needs only one assignment operator. For std::vector, for example, this would look like

vector& vector::operator=(vector other)
{
  swap(other);
  return*this;
}

The important point here is that the argument is taken by value. This means that at the moment the function body proper is entered, much of the work has already been done by the construction of other (by move constructor if possible, otherwise by copy constructor). Hence, this automatically implements both copy and move assignment correctly.

If this is correct, why is (according to this documentation at least) std::vector not implemented in this way?

---

edit to explain how this works. Consider what happens to other in above code in the following examples

void foo(std::vector<bar> &&x)
{
  auto y=x;             // other is copy constructed
  auto z=std::move(x);  // other is move constructed, no copy is ever made.
  // ...
}

Answer 1

If the element type is nothrow copyable, or the container does not honor the strong exception guarantee, then a copy-assignment operator can avoid allocation in the case where the destination object has sufficient capacity:

vector& operator=(vector const& src)
{
    clear();
    reserve(src.size());  // no allocation if capacity() >= src.size()
    uninitialized_copy_n(src.data(), src.size(), dst.data());
    m_size = src.size();
}