SequenceContainer

X(n, t) X a(n, t).

?

Constructs the sequence container holding n copies of t

T CopyInsertable into X

std::distance(begin(),end()) == n

X(i, j) X a(i, j).

?

Constructs the sequence container equal, element-wise, to the range [i,j)

T is EmplaceConstructible from *i into X (only for std::vector) If the iterators are not ForwardIterators, T must be CopyInsertable.

std::distance(begin(),end()) == std::distance(i,j)

X(il)

?

X(il.begin(), il.end())

?

?

a = il

X&

Assigns the range represented by il into a1

T CopyInsertable and CopyAssignable

Existing elements of a are destroyed or assigned to

a.emplace(p,args)

iterator

Insert an object of type T, constructed with std::forward<Args>(args) before p

T CopyInsertable (for std::vector and std::deque) T MoveAssignable and MoveInsertable.

Returned iterator points at the element constructed from args into a

a.insert(p,t)

iterator

Inserts a copy of t before p

T CopyInsertable (for std::vector and std::deque) T CopyAssignable or MoveAssignable.

Returned iterator points at the copy of t inserted into a

a.insert(p,rv)

iterator

Inserts a copy of rv before p, possibly using move semantics

T MoveInsertable (for std::vector and std::deque) T MoveAssignable.

Returned iterator points at the copy of rv inserted into a

a.insert(p,n,t)

iterator

Inserts n copies of t before p

T CopyInsertable and CopyAssignable

Returned iterator points at the copy of the first element inserted into a or is p for n==0

a.insert(p,i,j)

iterator

Inserts copies of elements in [i, j) before p

T EmplaceConstructible and i and j are not in a (only for std::vector) If the iterators are not ForwardIterators, T must be MoveInsertable and MoveAssignable.

Each iterator in [i,j) is dereferenced once. Returned iterator points at the copy of the first element inserted into a or is p for i==j

a.insert(p, il)

iterator

a.insert(p,il.begin(),il.end())

?

Returned iterator points at the copy of the first element inserted into a or is p if il is empty.

a.erase(q)

iterator

Erases the element pointed to by q

(std::deque, std::vector) T MoveAssignable

Returned iterator points at the element that was immediately following q prior to erasure, or a.end() if no such element exists.

a.erase(q1,q2)

iterator

Erases elements in [p,q)

(std::deque, std::vector) T MoveAssignable

Returned iterator points at the element that was pointed by q2 prior to any erasure, or a.end() if no such element exists.

a.clear()

void

Destroys all elements in a

?

All references, pointers, and iterators are invalidated, including the end iterator. a.empty() == true.

a.assign(i,j)

void

Replaces elements in a with a copy of [i, j)

T EmplaceConstructible and i, j not in a (std::vector) If not ForwardIterator. T MoveInsertable.

Each iterator in [i,j) is dereferenced once

a.assign(il)

void

a.assign(il.begin(),il.end())

?

?

a.assign(n,t)

void

Replaces elements in a with n copies of t

T CopyInsertable and CopyAssignable

?

a.front()

reference const_reference for const a.

Equivalent to *a.begin()

?

(all)

a.back()

reference const_reference for const a.

Equivalent to { auto tmp = a.end(); --tmp; return *tmp; }

?

std::basic_string std::array std::deque std::list std::vector

a.emplace_front(args)

void

Prepends a T constructed with std::forward<Args>(args)...

T EmplaceConstructible into X from args

std::deque std::forward_list std::list

a.emplace_back(args)

void

Appends a T constructed with std::forward<Args>(args)...

T EmplaceConstructible into X from args (std::vector only) T MoveInsertable into X.

std::deque std::list std::vector

a.push_front(t)

void

Prepends a copy of t

T CopyInsertable into X

std::deque std::forward_list std::list

a.push_front(rv)

void

Prepends a copy of rv, possibly using move semantics

T MoveInsertable into X

std::deque std::forward_list std::list

a.push_back(t)

void

Appends a copy of t

T CopyInsertable into X

std::basic_string std::deque std::list std::vector

a.push_back(rv)

void

Appends a copy of rv, possibly using move semantics

T MoveInsertable into X

std::basic_string std::deque std::list std::vector

a.pop_front()

void

Destroys the first element.

a.empty() == false

std::deque std::forward_list std::list

a.pop_back()

void

Destroys the last element

a.empty() == false

std::basic_string std::deque std::list std::vector

an

reference const_reference for const a.

Equivalent to *(n + a.begin())

?

std::basic_string std::array std::deque std::vector

a.at(n)

reference const_reference for const a.

Equivalent to *(n + a.begin()), except that out_of_range is thrown if n>=size()

?

std::basic_string std::array std::deque std::vector

array (since C++11)

static contiguous array (class template)

vector

dynamic contiguous array (class template)

deque

double-ended queue (class template)

forward_list (since C++11)

singly-linked list (class template)

list

doubly-linked list (class template)

std::vector

Fast access but mostly inefficient insertions/deletions

std::liststd::forward_list

Efficient insertion/deletion in the middle of the sequence

std::deque

Efficient insertion/deletion at the beginning and at the end of the sequence