取以下代码：
std::vector<int> a;
a.reserve(65536);
std::vector<int> b(a); //NOTE: b is constructed from a
a.reserve(65536); // no reallocation
b.reserve(65536);
容量是否被复制？最后一行会重新分配吗？标准对此有任何说明还是保持沉默？
【问题讨论】：
容量是否被复制？
实际上，没有。我在Clang and 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);
【讨论】：
reserve 调用将导致重新分配。
swap 对分配器的行为由 allocator_traits<Alloc>::propagate_on_container_swap 自定义。
不，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 的大小；虽然这不能保证。
【讨论】：
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;
}
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);
}
【讨论】：