Expression  Return type  Operational  Assertion/note  Complexity 
semantics  pre/postcondition  
X::value_type  T  compile time  
X::reference  T&  compile time  
X::const_reference  const T&  compile time  
X::iterator  iterator type whose value type is T  any iterator category
that meets the forward iterator requirements. convertible to X::const_iterator.  compile time  
X::const_iterator  constant iterator type whose value type is T  any iterator category
that meets the forward iterator requirements.  compile time  
X::difference_type  signed integer type  is identical to the difference type of X::iterator and X::const_iterator  compile time  
X::size_type  unsigned integer type  size_type can represent any nonnegative value of difference_type  compile time  
X u;  Postconditions: u.empty()  constant  
X()  Postconditions: X().empty()  constant  
X(a)  linear  
X u(a); X u = a;  Postconditions: u == a  linear  
X u(rv); X u = rv;  Postconditions: u shall be equal to the value that rv had before this construction  (Note B)  
a = rv  X&  All existing elements of a are either move assigned to or destroyed  a shall be equal to the value that rv
had before this assignment  linear 
(&a)>~X()  void  the destructor is applied to every element of a; any memory obtained is deallocated.  linear  
a.begin()  iterator; const_iterator for constant a  constant  
a.end()  iterator; const_iterator for constant a  constant  
a.cbegin()  const_iterator  const_cast<X const&>(a).begin();  constant  
a.cend()  const_iterator  const_cast<X const&>(a).end();  constant  
a == b  convertible to bool  == is an equivalence relation. equal(a.begin(), a.end(), b.begin(), b.end())  Requires: T is EqualityComparable  Constant if a.size() != b.size(),
linear otherwise 
a != b  convertible to bool  Equivalent to !(a == b)  linear  
a.swap(b)  void  exchanges the contents of a and b  (Note A)  
swap(a, b)  void  a.swap(b)  (Note A)  
r = a  X&  linear  
a.size()  size_type  distance(a.begin(), a.end())  constant  
a.max_size()  size_type  distance(begin(), end())
for the largest possible container  constant  
a.empty()  convertible to bool  a.begin() == a.end()  constant 
i == j i != j i < j i <= j i >= j i > j i  jwhere i and j denote objects of a container's iterator type, either or both may be replaced by an object of the container's const_iterator type referring to the same element with no change in semantics.
Expression  Return type  Assertion/note  Complexity 
pre/postcondition  
X::reverse_iterator  iterator type whose value type is T  reverse_iterator<iterator>  compile time 
X::const_reverse_iterator  constant iterator type whose value type is T  reverse_iterator<const_iterator>  compile time 
a.rbegin()  reverse_iterator; const_reverse_iterator for constant a  reverse_iterator(end())  constant 
a.rend()  reverse_iterator; const_reverse_iterator for constant a  reverse_iterator(begin())  constant 
a.crbegin()  const_reverse_iterator  const_cast<X const&>(a).rbegin()  constant 
a.crend()  const_reverse_iterator  const_cast<X const&>(a).rend()  constant 
Expression  Return type  Operational  Assertion/note  Complexity 
semantics  pre/postcondition  
a < b  convertible to bool  lexicographical_compare( a.begin(), a.end(), b.begin(), b.end())  < is a total ordering relationship.  linear 
a > b  convertible to bool  b < a  linear  
a <= b  convertible to bool  !(a > b)  linear  
a >= b  convertible to bool  !(a < b)  linear 
allocator_traits<A>::construct(m, p)
allocator_traits<A>::construct(m, p)where p is the address of the uninitialized storage for the element allocated within X.
allocator_traits<A>::construct(m, p, rv)and its evaluation causes the following postcondition to hold: The value of *p is equivalent to the value of rv before the evaluation.
allocator_traits<A>::construct(m, p, v)and its evaluation causes the following postcondition to hold: The value of v is unchanged and is equivalent to *p.
allocator_traits<A>::construct(m, p, args)
allocator_traits<A>::destroy(m, p)
Expression  Return type  Assertion/note  Complexity 
pre/postcondition  
allocator_type  A  compile time  
get_ allocator()  A  constant  
X() X u;  Postconditions: u.empty() returns true, u.get_allocator() == A()  constant  
X(m)  Postconditions: u.empty() returns true,  constant  
X u(m);  u.get_allocator() == m  
X(t, m) X u(t, m);  Postconditions: u == t, u.get_allocator() == m  linear  
X(rv) X u(rv);  Postconditions: u shall have the same elements as rv had before this
construction; the value of u.get_allocator() shall be the same as the
value of rv.get_allocator() before this construction.  constant  
X(rv, m) X u(rv, m);  Postconditions: u shall have the same elements, or copies of the elements, that rv had before this construction, u.get_allocator() == m  constant if m == rv.get_allocator(), otherwise linear  
a = t  X&  Postconditions: a == t  linear 
a = rv  X&  Requires: If allocator_ traits<allocator_type> ::propagate_on_container_ move_assignment::value is false, T is MoveInsertable into X and MoveAssignable. All existing elements of a
are either move assigned to or destroyed.  linear 
a.swap(b)  void  exchanges the contents of a and b  constant 
Expression  Return type  Assertion/note 
pre/postcondition  
X(n, t) X u(n, t);  Postconditions: distance(begin(), end()) == n Constructs a sequence container with n copies of t  
X(i, j) X u(i, j);  For vector, if the iterator does
not meet the forward iterator requirements, T
shall also be
MoveInsertable into X. Each iterator in the range [i, j) shall be dereferenced exactly once. Postconditions: distance(begin(), end()) == distance(i, j) Constructs a sequence container equal to the range [i, j)  
X(il)  Equivalent to X(il.begin(), il.end())  
a = il  X&  All existing
elements of a are either assigned to or destroyed. 
a.emplace(p, args)  iterator  
a.insert(p,t)  iterator  
a.insert(p,rv)  iterator  
a.insert(p,n,t)  iterator  
a.insert(p,i,j)  iterator  For vector and deque, T shall also be
MoveInsertable into X, MoveConstructible, MoveAssignable,
and swappable. Each iterator in the range [i, j) shall be dereferenced exactly once. Inserts copies of elements in [i, j) before p 
a.insert(p, il)  iterator  a.insert(p, il.begin(), il.end()). 
a.erase(q)  iterator  
a.erase(q1,q2)  iterator  
a.clear()  void  Destroys all elements in a. Invalidates all references, pointers, and
iterators referring to the elements of a and may invalidate the pasttheend iterator. 
a.assign(i,j)  void  For vector, if the iterator does not
meet the forward iterator requirements, T
shall also be
MoveInsertable into X. 
a.assign(il)  void  a.assign(il.begin(), il.end()). 
a.assign(n,t)  void 
template <class InputIterator> X(InputIterator first, InputIterator last, const allocator_type& alloc = allocator_type());is called with a type InputIterator that does not qualify as an input iterator, then the constructor shall not participate in overload resolution.
template <class InputIterator> returntype F(const_iterator p, InputIterator first, InputIterator last); // such as insert template <class InputIterator> returntype F(InputIterator first, InputIterator last); // such as append, assign template <class InputIterator> returntype F(const_iterator i1, const_iterator i2, InputIterator first, InputIterator last); // such as replaceare called with a type InputIterator that does not qualify as an input iterator, then these functions shall not participate in overload resolution.
Expression  Return type  Operational semantics  Container 
a.front()  reference; const_reference for constant a  *a.begin()  basic_string,
array,
deque,
forward_list,
list,
vector 
a.back()  reference; const_reference for constant a  { auto tmp = a.end(); tmp; return *tmp; }  basic_string,
array,
deque,
list,
vector 
a.emplace_front(args)  reference  deque,
forward_list,
list  
a.emplace_back(args)  reference  deque,
list,
vector  
a.push_front(t)  void  Prepends a copy of t.  deque,
forward_list,
list 
a.push_front(rv)  void  Prepends a copy of rv.  deque,
forward_list,
list 
a.push_back(t)  void  Appends a copy of t.  basic_string,
deque,
list,
vector 
a.push_back(rv)  void  Appends a copy of rv.  basic_string,
deque,
list,
vector 
a.pop_front()  void  Destroys the first element.  deque,
forward_list,
list 
a.pop_back()  void  Destroys the last element.  basic_string,
deque,
list,
vector 
a[n]  reference; const_reference for constant a  *(a.begin() + n)  basic_string,
array,
deque,
vector 
a.at(n)  reference; const_reference for constant a  *(a.begin() + n)  basic_string,
array,
deque,
vector 
map<K, T, C1, A>  map<K, T, C2, A> 
map<K, T, C1, A>  multimap<K, T, C2, A> 
set<K, C1, A>  set<K, C2, A> 
set<K, C1, A>  multiset<K, C2, A> 
unordered_map<K, T, H1, E1, A>  unordered_map<K, T, H2, E2, A> 
unordered_map<K, T, H1, E1, A>  unordered_multimap<K, T, H2, E2, A> 
unordered_set<K, H1, E1, A>  unordered_set<K, H2, E2, A> 
unordered_set<K, H1, E1, A>  unordered_multiset<K, H2, E2, A> 
template<unspecified> class node_handle { public: // These type declarations are described in Tables 90 and 91. using value_type = see below; // not present for map containers using key_type = see below; // not present for set containers using mapped_type = see below; // not present for set containers using allocator_type = see below; private: using container_node_type = unspecified; using ator_traits = allocator_traits<allocator_type>; typename ator_traits::rebind_traits<container_node_type>::pointer ptr_; optional<allocator_type> alloc_; public: constexpr node_handle() noexcept : ptr_(), alloc_() {} ~node_handle(); node_handle(node_handle&&) noexcept; node_handle& operator=(node_handle&&); value_type& value() const; // not present for map containers key_type& key() const; // not present for set containers mapped_type& mapped() const; // not present for set containers allocator_type get_allocator() const; explicit operator bool() const noexcept; bool empty() const noexcept; void swap(node_handle&) noexcept(ator_traits::propagate_on_container_swap::value  ator_traits::is_always_equal::value); friend void swap(node_handle& x, node_handle& y) noexcept(noexcept(x.swap(y))) { x.swap(y); } };
node_handle(node_handle&& nh) noexcept;
node_handle& operator=(node_handle&& nh);
~node_handle();
value_type& value() const;
key_type& key() const;
mapped_type& mapped() const;
allocator_type get_allocator() const;
explicit operator bool() const noexcept;
bool empty() const noexcept;
void swap(node_handle& nh)
noexcept(ator_traits::propagate_on_container_swap::value 
ator_traits::is_always_equal::value);
template <class Iterator, class NodeType>
struct INSERT_RETURN_TYPE
{
Iterator position;
bool inserted;
NodeType node;
};
Expression  Return type  Assertion/note  Complexity 
pre/postcondition  
X::key_type  Key  compile time  
X::mapped_type (map and multimap only)  T  compile time  
X::value_type (set and multiset only)  Key  Requires: value_type is Erasable from X  compile time 
X::value_type (map and multimap only)  pair<const Key, T>  Requires: value_type is Erasable from X  compile time 
X::key_compare  Compare  compile time  
X::value_compare  a binary predicate type  is the same as key_compare for set and
multiset; is an ordering relation on pairs induced by the
first component (i.e., Key) for map and multimap.  compile time 
X::node_type  a specialization of a node_handle
class template, such that the public nested types are
the same types as the corresponding types in X.  see [container.node]  compile time 
X(c) X u(c);  Effects: Constructs an empty container. Uses a copy of c as a comparison object.  constant  
X() X u;  Uses Compare() as a comparison object  constant  
X(i,j,c) X u(i,j,c);  Effects: Constructs an empty container and inserts elements from the range [i, j) into it; uses c as a comparison object.  in general, where N has the value distance(i, j);
linear if [i, j) is sorted with value_comp()  
X(i,j) X u(i,j);  same as above  
X(il)  same as X(il.begin(), il.end())  same as X(il.begin(), il.end())  
X(il,c)  same as X(il.begin(), il.end(), c)  same as X(il.begin(), il.end(), c)  
a = il  X&  All
existing elements of a are either assigned to or destroyed.  in general, where N has the value il.size() + a.size();
linear if [il.begin(), il.end()) is sorted with value_comp() 
b.key_comp()  X::key_compare  returns the comparison object out of which b was constructed.  constant 
b.value_comp()  X::value_compare  returns an object of value_compare constructed out of the comparison object  constant 
a_uniq.emplace(args)  pair<iterator, bool>  Effects: Inserts a value_type object t constructed with std::forward<Args>(args)... if and only if there is no element in the container with key equivalent to the key of t. The bool component of the returned
pair is true if and only if the insertion takes place, and the iterator
component of the pair points to the element with key equivalent to the
key of t.  logarithmic 
a_eq.emplace(args)  iterator  Effects: Inserts a value_type object t constructed with std::forward<Args>(args)... and returns the iterator pointing to the newly inserted element. If a range containing elements equivalent to t exists in a_eq,
t is inserted at the end of that range.  logarithmic 
a.emplace_hint(p, args)  iterator  Return value is an iterator pointing to the element with the key equivalent
to the newly inserted element. The element is inserted as close as possible to the position just prior
to p.  logarithmic in general, but amortized constant if the element
is inserted right before p 
a_uniq.insert(t)  pair<iterator, bool>  Requires: If t is a nonconst rvalue expression, value_type shall be
MoveInsertable into X; otherwise, value_type shall be
CopyInsertable into X. Effects: Inserts t if and only if there is no element in the container with key equivalent to the key of t. The bool component of
the returned pair is true if and only if the insertion
takes place, and the iterator
component of the pair points to the element with key
equivalent to the key of t.  logarithmic 
a_eq.insert(t)  iterator  Requires: If t is a nonconst rvalue expression, value_type shall be
MoveInsertable into X; otherwise, value_type shall be
CopyInsertable into X. If a range containing elements equivalent to
t exists in a_eq, t
is inserted at the end of that range.  logarithmic 
a.insert(p, t)  iterator  Requires: If t is a nonconst rvalue expression, value_type shall be
MoveInsertable into X; otherwise, value_type shall be
CopyInsertable into X. Effects: Inserts t if and only if there is no element with key equivalent to the key of t in containers with unique keys; always inserts t in containers with equivalent keys. Always
returns the iterator pointing to the element with key equivalent to
the key of t.  
a.insert(i, j)  void  inserts each element from the range [i, j) if and only if there
is no element with key equivalent to the key of that element in containers
with unique keys; always inserts that element in containers with equivalent keys.  , where N has the value distance(i, j) 
a.insert(il)  void  equivalent to a.insert(il.begin(), il.end())  
a_uniq.insert(nh)  insert_return_type  Otherwise, inserts the
element owned by nh if and only if there is no element in the
container with a key equivalent to nh.key(). Otherwise if the insertion took place, inserted is true,
position points to the inserted element, and node is empty;
if the insertion failed, inserted is false,
node has the previous value of nh, and position
points to an element with a key equivalent to nh.key().  logarithmic 
a_eq.insert(nh)  iterator  Otherwise, inserts the element owned by nh and returns an iterator
pointing to the newly inserted element. If a range containing elements with
keys equivalent to nh.key() exists in a_eq, the element is
inserted at the end of that range.  logarithmic 
a.insert(p, nh)  iterator  Otherwise, inserts the element owned by nh if and only if there
is no element with key equivalent to nh.key() in containers with
unique keys; always inserts the element owned by nh in containers
with equivalent keys. Always returns the iterator pointing to the element
with key equivalent to nh.key(). The element is inserted as close
as possible to the position just prior to p.  logarithmic in general, but amortized constant if the element is inserted right
before p. 
a.extract(k)  node_type  removes the first element in the container with key equivalent to k.  log(a.size()) 
a.extract(q)  node_type  removes the element pointed to by q. Returns a node_type owning that element.  amortized constant 
a.merge(a2)  void  In containers with unique keys,
if there is an element in a with key equivalent to the key of an
element from a2, then that element is not extracted from a2. Postconditions: Pointers and references to the transferred elements of a2 refer to those same elements but as members of a. Iterators referring
to the transferred elements will continue to refer to their elements, but
they now behave as iterators into a, not into a2.  
a.erase(k)  size_type  erases all elements in the container with key equivalent to
k. returns the number of erased elements.  
a.erase(q)  iterator  erases the element pointed to by q. Returns an iterator pointing to
the element immediately following q prior to the element being erased. If no such element exists, returns a.end().  amortized constant 
a.erase(r)  iterator  erases the element pointed to by r. Returns an iterator pointing to
the element immediately following r prior to the element being erased. If no such element exists, returns a.end().  amortized constant 
a.erase( q1, q2)  iterator  erases all the elements in the range [q1, q2). Returns an iterator pointing to
the element pointed to by q2 prior to any elements being erased. If no such element
exists, a.end() is returned.  
a.clear()  void  linear in a.size().  
b.find(k)  returns an iterator pointing to an element with the key equivalent
to k, or b.end() if such an element is not found  logarithmic  
a_tran. find(ke)  returns an iterator pointing to an element with key r such that
!c(r, ke) && !c(ke, r), or a_tran.end() if such an element
is not found  logarithmic  
b.count(k)  size_type  returns the number of elements with key equivalent to k  
a_tran. count(ke)  size_type  returns the number of elements with key r such that
!c(r, ke) && !c(ke, r)  
b.lower_bound(k)  returns an iterator pointing to the first element with
key not less than k,
or b.end() if such an element is not found.  logarithmic  
a_tran. lower_bound(kl)  returns an iterator pointing to the first element with
key r such that !c(r, kl),
or a_tran.end() if such an element is not found.  logarithmic  
b.upper_bound(k)  returns an iterator pointing to the first element with
key greater than k,
or b.end() if such an element is not found.  logarithmic  
a_tran. upper_bound(ku)  returns an iterator pointing to the first element with
key r such that c(ku, r),
or a_tran.end() if such an element is not found.  logarithmic  
b.equal_range(k)  equivalent to make_pair(b.lower_bound(k), b.upper_bound(k)).  logarithmic  
a_tran. equal_range(ke)  logarithmic 
value_comp(*j, *i) == false
value_comp(*i, *j) != false
Expression  Return type  Assertion/note  Complexity 
pre/postcondition  
X::key_type  compile time  
X::mapped_type (unordered_map and unordered_multimap only)  T  compile time  
X::value_type (unordered_set and unordered_multiset only)  Key  Requires: value_type is Erasable from X  compile time 
X::value_type (unordered_map and unordered_multimap only)  pair<const Key, T>  Requires: value_type is Erasable from X  compile time 
X::hasher  Hash  compile time  
X::key_equal  Pred  Pred is an equivalence relation.  compile time 
X::local_iterator  An iterator type whose category, value type,
difference type, and pointer and reference types are the same as
X::iterator's.  A local_iterator object may be used to iterate through a
single bucket, but may not be used to iterate across
buckets.  compile time 
X::const_local_iterator  An iterator type whose category, value type,
difference type, and pointer and reference types are the same as
X::const_iterator's.  A const_local_iterator object may be used to iterate through a
single bucket, but may not be used to iterate across
buckets.  compile time 
X::node_type  a specialization of a node_handle
class template, such that the public nested types are
the same types as the corresponding types in X.  see [container.node]  compile time 
X(n, hf, eq) X a(n, hf, eq);  X  Effects: Constructs an empty container with at least n buckets,
using hf as the hash function and eq as the key
equality predicate.  
X(n, hf) X a(n, hf);  X  Effects: Constructs an empty container with at least n buckets, using hf as the hash function and key_equal() as the key equality predicate.  
X(n) X a(n);  X  Effects: Constructs an empty container with at least n buckets, using hasher() as the hash function and key_equal() as the key equality predicate.  
X() X a;  X  Effects: Constructs an empty container with an unspecified number of buckets, using hasher() as the hash function and key_equal() as the key equality predicate.  constant 
X(i, j, n, hf, eq) X a(i, j, n, hf, eq);  X  Effects: Constructs an empty container with at least n buckets, using hf as the hash function and eq as the key equality predicate, and inserts elements from [i, j) into it.  Average case (N is distance(i, j)), worst case

X(i, j, n, hf) X a(i, j, n, hf);  X  Effects: Constructs an empty container with at least n buckets, using hf as the hash function and key_equal() as the key equality predicate, and inserts elements from [i, j) into it.  Average case (N is distance(i, j)), worst case

X(i, j, n) X a(i, j, n);  X  Effects: Constructs an empty container with at least n buckets, using hasher() as the hash function and key_equal() as the key equality predicate, and inserts elements from [i, j) into it.  Average case (N is distance(i, j)), worst case

X(i, j) X a(i, j);  X  Effects: Constructs an empty container with an unspecified number of buckets, using hasher() as the hash function and key_equal() as the key equality predicate, and inserts elements from [i, j) into it.  Average case (N is distance(i, j)), worst case

X(il)  X  Same as X(il.begin(), il.end()).  
X(il, n)  X  Same as X(il.begin(), il.end(), n).  
X(il, n, hf)  X  Same as X(il.begin(), il.end(), n, hf).  
X(il, n, hf, eq)  X  Same as X(il.begin(), il.end(), n, hf, eq).  
X(b) X a(b);  X  Copy constructor.  Average case linear in b.size(), worst case quadratic. 
a = b  X&  Copy assignment operator.  Average case linear in b.size(), worst case quadratic. 
a = il  X&  All
existing elements of a are either assigned to or destroyed.  Same as a = X(il). 
b.hash_function()  hasher  Returns b's hash function.  constant 
b.key_eq()  key_equal  Returns b's key equality predicate.  constant 
a_uniq. emplace(args)  pair<iterator, bool>  Effects: Inserts a value_type object t constructed with std::forward<Args>(args)... if and only if there is no element in the container with key equivalent to the key of t. The bool component of the returned
pair is true if and only if the insertion takes place, and the iterator
component of the pair points to the element with key equivalent to the
key of t.  
a_eq.emplace(args)  iterator  Effects: Inserts a value_type object t constructed with std::forward<Args>(args)... and returns the iterator pointing to the newly inserted element.  
a.emplace_hint(p, args)  iterator  Return value is an iterator pointing to the element with the key equivalent
to the newly inserted element. Implementations are
permitted to ignore the hint.  
a_uniq.insert(t)  pair<iterator, bool>  Requires: If t is a nonconst rvalue expression, value_type shall be
MoveInsertable into X; otherwise, value_type shall be
CopyInsertable into X. Effects: Inserts t if and only if there is no element in the container with key equivalent to the key of t. The bool
component of the returned pair indicates whether the insertion
takes place, and the iterator component points to the element
with key equivalent to the key of t.  
a_eq.insert(t)  iterator  Requires: If t is a nonconst rvalue expression, value_type shall be
MoveInsertable into X; otherwise, value_type shall be
CopyInsertable into X.  
a.insert(p, t)  iterator  Requires: If t is a nonconst rvalue expression, value_type shall be
MoveInsertable into X; otherwise, value_type shall be
CopyInsertable into X. insert(t). Return value is an iterator pointing
to the element with the key equivalent to that of t. The
iterator p is a hint pointing to where the search should
start. Implementations are permitted to ignore the hint.  
a.insert(i, j)  void  Worst case .  
a.insert(il)  void  Same as a.insert(il.begin(), il.end()).  
a_uniq. insert(nh)  insert_return_type  Otherwise, inserts the
element owned by nh if and only if there is no element in the
container with a key equivalent to nh.key(). Otherwise if the insertion took place, inserted is true,
position points to the inserted element, and node is empty;
if the insertion failed, inserted is false,
node has the previous value of nh, and position
points to an element with a key equivalent to nh.key().  
a_eq. insert(nh)  iterator  Otherwise, inserts the element owned by nh and returns an iterator
pointing to the newly inserted element.  
a.insert(q, nh)  iterator  Otherwise, inserts the element owned by nh if and only if there
is no element with key equivalent to nh.key() in containers with
unique keys; always inserts the element owned by nh in containers
with equivalent keys. Always returns the iterator pointing to the element
with key equivalent to nh.key(). The iterator q is a hint
pointing to where the search should start. Implementations are permitted
to ignore the hint.  
a.extract(k)  node_type  Removes an element in the container with key equivalent to k.  
a.extract(q)  node_type  Removes the element pointed to by q. Returns a node_type owning that element.  
a.merge(a2)  void  Attempts to extract each element in a2 and insert it into a using the hash function and key equality predicate of a. In containers with unique keys, if there is an element in a with
key equivalent to the key of an element from a2, then that
element is not extracted from a2.
Postconditions: Pointers and references to the transferred elements of a2
refer to those same elements but as members of a. Iterators referring
to the transferred elements and all iterators referring to a will
be invalidated, but iterators to elements remaining in a2 will
remain valid.  Worst case . 
a.erase(k)  size_type  Erases all elements with key equivalent to k. Returns
the number of elements erased.  Average case . Worst case
. 
a.erase(q)  iterator  Erases the element pointed to by q. Returns the
iterator immediately following q prior to the erasure.  
a.erase(r)  iterator  Erases the element pointed to by r. Returns the
iterator immediately following r prior to the erasure.  
a.erase(q1, q2)  iterator  Erases all elements in the range [q1, q2). Returns
the iterator immediately following the erased elements prior to the
erasure.  
a.clear()  void  Erases all elements in the container.  Linear in a.size(). 
b.find(k)  Returns an iterator pointing to an element with key equivalent to
k, or b.end() if no such element exists.  
b.count(k)  size_type  Returns the number of elements with key equivalent to k.  
b.equal_range(k)  Returns a range containing all elements with keys equivalent to
k. Returns make_pair(b.end(), b.end()) if
no such elements exist.  Average case . Worst case
.  
b.bucket_count()  size_type  Returns the number of buckets that b contains.  Constant 
b.max_bucket_count()  size_type  Returns an upper bound on the number of buckets that b might
ever contain.  Constant 
b.bucket(k)  size_type  Returns the index of the bucket in which elements with keys equivalent to k would be found, if any such element existed.  Constant 
b.bucket_size(n)  size_type  Returns the number of elements in the bucket.  
b.begin(n)  b.begin(n) returns an iterator referring to the
first element in the bucket. If the bucket is empty, then
b.begin(n) == b.end(n).  Constant  
b.end(n)  b.end(n) returns an iterator which is the pasttheend
value for the bucket.  Constant  
b.cbegin(n)  const_local_iterator  Constant  
b.cend(n)  const_local_iterator  Constant  
b.load_factor()  float  Returns the average number of elements per bucket.  Constant 
b.max_load_factor()  float  Returns a positive number that the container attempts to keep the load factor
less than or equal to. The container automatically increases the
number of buckets as necessary to keep the load factor below this
number.  Constant 
a.max_load_factor(z)  void  May change the container's maximum load factor, using z as a hint.  Constant 
a.rehash(n)  void  Average case linear in a.size(), worst case quadratic.  
a.reserve(n)  void  Average case linear in a.size(), worst case quadratic. 