Previous fileTop of DocumentContentsIndex pageNext file
Apache C++ Standard Library Reference Guide

vector

Library:  Containers


Does not inherit

Local Index

Members

Non-Members

Summary

A sequence that supports random access iterators

Synopsis

#include <vector>

namespace std {
  template <class T, class Allocator = allocator<T> >
  class vector;
}

Description

vector is a sequence that supports random access iterators. It also supports amortized constant time insert and erase operations at the end (Insert and erase in the middle take linear time.). Storage management is handled automatically. In vector, iterator is a random access iterator referring to T. const_iterator is a constant random access iterator that returns a const T& when dereferenced. A constructor for iterator and const_iterator is guaranteed. size_type is an unsigned integral type. difference_type is a signed integral type.

Any type used for the template parameter T must provide the following (where T is the type, t is a value of T and u is a const value of T):

Special Case

Vectors of bit values, that is boolean 1/0 values, are handled as a special case by the standard library, so that they can be efficiently packed several elements to a word. The operations for a boolean vector, vector<bool>, are a superset of those for an ordinary vector, only the implementation is more efficient.

Two member functions are available to the boolean vector data type. One is flip(), which inverts all the bits of the vector. Boolean vectors also return as reference an internal value that also supports the flip() member function. The other member function specific to vector<bool> is a second form of the swap() function.

Interface

Constructors

explicit vector(const Allocator& alloc = Allocator());
explicit vector(size_type n);
vector(size_type n, const T& value,
const Allocator& alloc = Allocator());
vector(const vector<T, Allocator>& x);
template <class InputIterator>
vector(InputIterator start, InputIterator finish,
const Allocator& alloc = Allocator());

Iterators

iterator 
begin();
const_iterator 
begin() const;
iterator 
end();
const_iterator 
end() const;
reverse_iterator 
rbegin();
const_reverse_iterator 
rbegin() const;
reverse_iterator 
rend();
const_reverse_iterator 
rend() const;

Assignment Operator

vector<T, Allocator>& 
operator=(const vector<T, Allocator>& x);

Allocator

allocator_type 
get_allocator() const;

Reference Operators

reference 
operator[](size_type n);
const_reference 
operator[](size_type n) const;

Member Functions

template <class InputIterator>
void
assign(InputIterator start, InputIterator finish);
void
assign(size_type n, const T& t);
reference 
at(size_type n);
const_reference 
at(size_type) const;
reference 
back();
const_reference 
back() const;
size_type 
capacity() const;
void 
clear() ; 
bool 
empty() const;
iterator
erase(iterator position);
iterator
erase(iterator start, iterator finish);
void
flip();
reference 
front();
const_reference 
front() const;
iterator 
insert(iterator position, const T& x);
void 
insert(iterator position, size_type n, const  T& x);
template <class InputIterator>
void 
insert(iterator position, InputIterator start, 
        InputIterator finish);
size_type 
max_size() const;
void 
pop_back();
void 
push_back(const T& x);
void 
reserve(size_type n);
void 
resize(size_type sz);
void 
resize(size_type sz, T c);
size_type 
size() const;
void 
swap(vector<T, Allocator>& x);
void
swap(reference x, reference y);

Nonmember Operators

template <class T, class Allocator>
bool operator==(const vector<T, Allocator>& x,
                const vector<T, Allocator>& y);
template <class T, class Allocator>
bool operator!=(const vector<T, Allocator>& x,
                const vector<T, Allocator>& y);
template <class T>
bool operator<(const vector<T, Allocator>& x,
               const vector<T, Allocator>& y);
template <class T>
bool operator>(const vector<T, Allocator>& x,
               const vector<T, Allocator>& y);
template <class T>
bool operator<=(const vector<T, Allocator>& x,
                const vector<T, Allocator>& y);
template <class T>
bool operator>=(const vector<T, Allocator>& x,
                const vector<T, Allocator>& y);

Specialized Algorithms

template <class T, class Allocator>void 
swap(vector <T, Allocator>& a, vector <T, Allocator>& b);

Example

Warnings

Member function templates are used in all containers provided by the Standard Template Library. For example, the constructor for vector takes two templatized iterators:

vector also has an insert function of this type. These functions, when not restricted by compiler limitations, allow you to use any type of input iterator as arguments. For compilers that do not support this feature we provide substitute functions that allow you to use an iterator obtained from the same type of container as the one you are constructing (or calling a member function on), or you can use a pointer to the type of element you have in the container.

For example, if your compiler does not support member function templates you can construct a vector in the following two ways:

but not this way:

since the long_vector and first_vector are not the same type.

If your compiler does not support default template parameters, you must supply the Allocator template argument. For instance, you must write :

instead of :

See Also

allocator, Containers, Iterators, lexicographical_compare()

Standards Conformance

ISO/IEC 14882:1998 -- International Standard for Information Systems -- Programming Language C++, Section 23.2.4



Previous fileTop of DocumentContentsIndex pageNext file