One of the STL containers vector

One of the simplest and most useful containers in STL is the Vector<t> class template, called the vector container, which is one of the sequence type containers.

Container capacity can be modified selectively.
(1) Statement:
Vector<type> v; A capacity of 0 constructs a V object that specifies the element type
Vector<type> v (n); The capacity is n to construct a V object, specifying the element type
Vector<type> V (n, InitValue); The capacity is N construction v object, specifying the element type as type, and all elements are initialized to InitValue;

(2) member functions
V.capacity (); Returns v to store the number of elements before it expands
V.size (); Returns the number of elements (values) currently contained in V, that is, the length of V
V.empty (); Null function if and only if V does not contain any elements (values) that are returned true
V.reserve (n); Grow v so that it has a capacity of N and does not affect the length of V (the number of actual storage worth)
V.push_back (value); The value is added at the tail of V and the length of V is +1
V.pop_back (); Turn out the last element of V and set the length of V-1
V.front (); Returns a reference to the first element of V
V.back (); Returns a reference to the last element of V

The length of V is the number of all data items in the vector object, i.e. v.size ();
The capacity of V is the number of elements that can be stored in a vector object, i.e. v.capacity ();

(3) Subscript operation for Vector objects
V[i]; To access the elements in the V below Table I
V1 = v2; Assign a copy of V2 to V1
V1 = = V2; Returns True when and only if V1 and V2 have the same given value in the same position, that is, the comparison of one element of an element
V1 < v2; Returns True when and only if V1 is less than V2 on the dictionary sort

V can be accessed using subscript and the following table operator operators;
The following table for the first element of V is: 0;
The following table for the last element of V is: v.size ()-1;
The following table of the vector object is mined with the string object and the C-style array below the table operation, but there is also an important difference that the vector object cannot be directly

Increment of the following table operation, and the capacity of V is not specified, or less than the value of the table below, cannot update the capacity of the vector object by the following table operation, such a situation must use

V.push_back (Value) to handle.

(4) Include iterator vector<t> member function
STL Containers basically support an iterator's access method. In essence, "iteration" is a special type of object that can be passed through the storage element

The address "points to" the elements in the container, such as the Vector<t> class container, and the ability to access the values stored at that location and the ability to move from one element to another. Every

An STL container provides a set of its own iterator types and (at least) two ways to return iterators: *begin (): Returns an array of elements positioned in the first element of the container.

Iterator, *end (): Returns an iterator positioned immediately after the last element of the container, next to the element, which actually indicates the data in the container, two member functions

A "Half open area" with two benefits (1) using the iterator's value equals end to represent the end of the iteration, (2) It is convenient to use the BEGIN = = end to determine if the container is

No is empty.

Iterator member functions for vector<t> objects
V.begin (); Above
V.end (); Above
V.rbegin (); Returns the last worthwhile reverse iterator positioned at V
V.rend (); Returns an iterator positioned in front of the first value of V, immediately next to the transformation
V.insert (pos, value); Say value is inserted at the iterator position at V Pos
V.insert (POS, n, value); The N-copy value of value is inserted at the position Pos of the iterator at V
V.erase (POS); Remove the value at the position pos of the iterator at V, the length of V -1,v the capacity of the
V.erase (POS1, Pos2); Remove value from iterator position pos1 to Pos2 in V

Initialization of iterators:vector<t>:: Iterator it = initial value;
Three important actions for iterators:
# it++; Move it forward to the next element of the vector
# it--; Move it backwards to the previous element of the vector
# *it; Accessing the value of an iterator it refers to an element

One of the STL containers vector