Емкость копируется в вектор?

Емкость копируется?

На практике нет. Я тестировал его онлайн в Clang и GCC, а также MSVC, и ни один из них не копирует емкость.

Будет ли перераспределение на последней строке?

Если емкость меньше аргумента для резервирования (т. е. она не копируется), то да.

В стандарте что-то об этом сказано или умалчивается?

В vector.cons нет определений конструктора копирования. Вместо этого нам нужно взглянуть на container.requirements.

X обозначает класс-контейнер, содержащий объекты типа T, a и b обозначают значения типа X, u обозначает идентификатор, r обозначает неконстантное значение типа X, а rv обозначает неконстантное значение типа X.

X u(a)

X u = a;

Требуется: T вместо CopyInsertable превращается в X (см. ниже).

сообщение: u == a

Теперь, что означает, что два контейнера равны?

a == b

== является отношением эквивалентности. equal(a.begin(), a.end(), b.begin(), b.end())

Другими словами, поскольку при сравнении не требуется, чтобы capacity было равным, нет причин копировать capacity.

Стандарт ничего не говорит о сохранении емкости при вызове конструктора копирования. Так что никаких гарантий по этому поводу у вас нет.

Но вы можете сделать следующий трюк, который меняет местами состояния a и b, если вам нужно сохранить емкость только в копии:

 std::vector<int> a;
 a.reserve(65536);
 std::vector<int> b(a);
 b.swap(a); // now b has a's state
 assert(b.capacity() == 65536); 

Нет, емкость не гарантируется при использовании vector копии.

Вы можете сделать это следующим образом:

vector<int> b;
b.reserve( a.capacity() );
b = a;

Лучше инкапсулировать в функцию.

Итак, простая проверка, подобная следующей, показывает, что емкость не скопирована:

std::vector<int> a;
a.reserve(65536);
cout << "a.capacity is " << a.capacity() << endl; // prints 65536

std::vector<int> b(a);  //NOTE: b is constructed from a
cout << "b.capacity is " << b.capacity() << endl; // prints 0

Я считаю, что при копировании вектора a в b емкость b устанавливается равной размеру a в большинстве компиляторов; хотя это не гарантируется.

1. Как показано ниже, исходный код вектора SGI STL, operator= зарезервирует место ровно для n элементов, т. е. _M_end_of_storage = _M_start + __xlen;.

    template <class _Tp, class _Alloc>
    vector<_Tp,_Alloc>&
    vector<_Tp,_Alloc>::operator=(const vector<_Tp, _Alloc>& __x)
    {
      if (&__x != this) {
        const size_type __xlen = __x.size();
        if (__xlen > capacity()) {
          iterator __tmp = _M_allocate_and_copy(__xlen, __x.begin(), __x.end());
          destroy(_M_start, _M_finish);
          _M_deallocate(_M_start, _M_end_of_storage - _M_start);
          _M_start = __tmp;
          _M_end_of_storage = _M_start + __xlen;
        }
        else if (size() >= __xlen) {
          iterator __i = copy(__x.begin(), __x.end(), begin());
          destroy(__i, _M_finish);
        }
        else {
          copy(__x.begin(), __x.begin() + size(), _M_start);
          uninitialized_copy(__x.begin() + size(), __x.end(), _M_finish);
        }
        _M_finish = _M_start + __xlen;
      }
      return *this;
    }

2. Как показано ниже, исходный код вектора SGI STL, векторный конструктор копирования зарезервирует место ровно для n элементов, т. е. _M_end_of_storage = _M_start + __n;.

      template <class _InputIterator>
      vector(_InputIterator __first, _InputIterator __last,
             const allocator_type& __a = allocator_type()) : _Base(__a) {
        typedef typename _Is_integer<_InputIterator>::_Integral _Integral;
        _M_initialize_aux(__first, __last, _Integral());
      }

      template <class _Integer>
      void _M_initialize_aux(_Integer __n, _Integer __value, __true_type) {
        _M_start = _M_allocate(__n);
        _M_end_of_storage = _M_start + __n;
        _M_finish = uninitialized_fill_n(_M_start, __n, __value);
      }