std::vector::vector

explicit vector (const allocator_type& alloc = allocator_type());

explicit vector (size_type n);
         vector (size_type n, const value_type& val,
                 const allocator_type& alloc = allocator_type());

template <class InputIterator>
  vector (InputIterator first, InputIterator last,
          const allocator_type& alloc = allocator_type());

vector (const vector& x);
vector (const vector& x, const allocator_type& alloc);

vector (vector&& x);
vector (vector&& x, const allocator_type& alloc);

vector (initializer_list<value_type> il,
       const allocator_type& alloc = allocator_type());

Constructs a vector, initializing its contents depending on the constructor version used:

Parameters
参数说明：

alloc

Allocator object.
The container keeps and uses an internal copy of this allocator.
分配器对象
容器使用并保持一个内在的复制分配器。

Member type allocator_type is the internal allocator type used by the container, defined in vector as an alias of its second
template parameter (Alloc).
allocator_type是一种容器使用的内在的分配器类型，作为vector模板参数里面的第二个参数。

If allocator_type is an instantiation of the default allocator (which has no state), this is not relevant.

//这句不太会翻译
如果allocator_type是默认的实例化分配器(没有状态),这是不相关的。

n

Initial container size (i.e., the number of elements in the container at construction).
Member type size_type is an unsigned integral type.
容器最初的大小，（即最开始容器存放的元素数目）
n是一个无符号整形类型。

val

Value to fill the container with. Each of the n elements in the container will be initialized to a copy of this value.
Member type value_type is the type of the elements in the container, defined in vector as an alias of its first template
parameter (T).

容器初始化时里面每一个元素的初始化值。

val的值类型必须和模板参数里面的参数《T》一致

first, last

Input iterators to the initial and final positions in a range. The range used is [first,last),
which includes all the elements between first and last, including the element pointed by first but not the element pointed bylast.
The function template argument InputIterator shall be an input iterator type that points to elements of a type from
which value_type objects can be constructed.

输入迭代器开始和结束的范围。这是一个开区间的范围[first,last),包括first–end里面的所有元素，包括first，但是不包括last

x

Another vector object of the same type (with the same class template arguments T and Alloc),
whose contents are either copied or acquired.

另一个同类型（T和Alloc）vector数组的名称

il

An initializer_list object.
These objects are automatically constructed from initializer list declarators.
Member type value_type is the type of the elements in the container, defined in vector as an alias of its first template
parameter (T).

一个初始化列表对象。

Example

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

// constructing vectors
#include <iostream>
#include <vector>

int main ()
{
  unsigned int i;

  // constructors used in the same order as described above:
  std::vector<int> first;                                // empty vector of ints
  std::vector<int> second (4,100);                       // four ints with value 100
  std::vector<int> third (second.begin(),second.end());  // iterating through second
  std::vector<int> fourth (third);                       // a copy of third

  // the iterator constructor can also be used to construct from arrays:
  int myints[] = {16,2,77,29};
  std::vector<int> fifth (myints, myints + sizeof(myints) / sizeof(int) );

  std::cout << "The contents of fifth are:";
  for (std::vector<int>::iterator it = fifth.begin(); it != fifth.end(); ++it)
    std::cout << ' ' << *it;
  std::cout << '\n';

  return 0;
}

Output:

The contents of fifth are: 16 2 77 29 

Complexity

Constant for the default constructor (1), and for the move constructors (5) (unless alloc is different from x‘s allocator).除了默认的构造器和移动构造器
For all other cases, linear in the resulting container size.其他的情况下，生成容器都在线性时间内。
Additionally, if InputIterator in the range constructor (3) is not at least of a forward iterator category
(i.e., it is just an input iterator), the new capacity cannot be determined beforehand and the construction incurs in additional
logarithmic complexity in size (reallocations while growing).

Iterator validity

The move constructors (5), invalidate all iterators, pointers and references related to x if the elements are moved.
迭代器的有效性：

Data races

All copied elements are accessed.
The move constructors (5) modify x.

Exception safety

Strong guarantee: no effects in case an exception is thrown.
If allocator_traits::construct is not supported with the appropriate arguments for the element constructions,
or if the range specified by [first,last) is not valid, it causes undefined behavior.

std::vector::~vector

~vector();

Destroys the container object.

Complexity

Linear in vector::size (destructors).

Iterator validity

All iterators, pointers and references are invalidated.

Data races

The container and all its elements are modified.

Exception safety

No-throw guarantee: never throws exceptions.