[ STL ] vector Reference

vector

class template

<vector>

Vector

Vectors are a kind of sequence containers. As such, their elements are ordered following a strict linear sequence.

Vector containers are implemented as dynamic arrays; Just as regular arrays, vector containers have their elements stored in contiguous storage locations, which means that their elements can be accessed not only using iterators but also using offsets on regular pointers to elements.

But unlike regular arrays, storage in vectors is handled automatically, allowing it to be expanded and contracted as needed.

Vectors are good at:

• Accessing individual elements by their position index (constant time).
• Iterating over the elements in any order (linear time).
• Add and remove elements from its end (constant amortized time).

Compared to arrays, they provide almost the same performance for these tasks, plus they have the ability to be easily resized. Although, they usually consume more memory than arrays when their capacity is handled automatically (this is in order to accomodate for extra storage space for future growth).

Compared to the other base standard sequence containers (deques and lists), vectors are generally the most efficient in time for accessing elements and to add or remove elements from the end of the sequence. For operations that involve inserting or removing elements at positions other than the end, they perform worse than deques and lists, and have less consistent iterators and references than lists.

Internally, vectors -like all containers- have a size, which represents the amount of elements contained in the vector. But vectors, also have a capacity, which determines the amount of storage space they have allocated, and which can be either equal or greater than the actual size. The extra amount of storage allocated is not used, but is reserved for the vector to be used in the case it grows. This way, the vector does not have to reallocate storage on each occasion it grows, but only when this extra space is exhausted and a new element is inserted (which should only happen in logarithmic frequence in relation with its size).

Reallocations may be a costly operation in terms of performance, since they generally involve the entire storage space used by the vector to be copied to a new location. Therefore, whenever large increases in size are planned for a vector, it is recommended to explicitly indicate a capacity for the vector using member function vector::reserve.

In their implementation in the C++ Standard Template Library vectors take two template parameters:

template < class T, class Allocator = allocator<T> > class vector;

Where the template parameters have the following meanings:

• T: Type of the elements.
• Allocator: Type of the allocator object used to define the storage allocation model. By default, the allocator class template for type T is used, which defines the simplest memory allocation model and is value-independent.

In the reference for the vector member functions, these same names are assumed for the template parameters.

Member functions

(constructor)

Construct vector (public member function)

(destructor)

Vector destructor (public member function)

operator=

Copy vector content (public member function)

Iterators:

begin

Return iterator to beginning (public member type)

end	Return iterator to end (public member function)

rbegin

Return reverse iterator to reverse beginning (public member function)

rend	Return reverse iterator to reverse end (public member function)

Capacity:

size	Return size (public member function)

max_size

Return maximum size (public member function)

resize

Change size (public member function)

capacity

Return size of allocated storage capacity (public member function)

empty

Test whether vector is empty (public member function)

reserve

Request a change in capacity (public member function)

Element access:

operator[]

Access element (public member function)

at	Access element (public member function)

front

Access first element (public member function)

back	Access last element (public member function)

Modifiers:

assign

Assign vector content (public member function)

push_back

Add element at the end (public member function)

pop_back

Delete last element (public member function)

insert

Insert elements (public member function)

erase

Erase elements (public member function)

swap	Swap content (public member function)

clear

Clear content (public member function)

Allocator:

get_allocator

Get allocator (public member function)

Member types

of template <class T, class Allocator=allocator<T> > class vector;

member type	definition
reference	Allocator::reference
const_reference	Allocator::const_reference
iterator	Random access iterator
const_iterator	Constant random access iterator
size_type	Unsigned integral type (usually same as size_t)
difference_type	Signed integral type (usually same as ptrdiff_t)
value_type	T
allocator_type	Allocator
pointer	Allocator::pointer
const_pointer	Allocator::const_pointer
reverse_iterator	reverse_iterator<iterator>
const_reverse_iterator	reverse_iterator<const_iterator>

Vector specialization: vector<bool>

The vector class template has a special template specialization for the bool type.

This specialization is provided to optimize for space allocation: In this template specialization, each element occupies only one bit (which is eight times less than the smallest type in C++: char).

The references to elements of a bool vector returned by the vector members are not references to bool objects, but a special member type which is a reference to a single bit, defined inside the vector<bool> class specialization as:

class vector<bool>::reference { friend class vector; reference(); // no public constructor public: ~reference(); operator bool () const; // convert to bool reference& operator= ( const bool x ); // assign from bool reference& operator= ( const reference& x ); // assign from bit void flip(); // flip bit value. }

For a similar container class to contain bits, but with a fixed size, see bitset.