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;  Ensures: u.empty()  constant  
X()  Ensures: X().empty()  constant  
X(a)  linear  
X u(a); X u = a;  Ensures: u == a  linear  
X u(rv); X u = rv;  Ensures: u is 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  Ensures: a is equal to the value that rv
had before this assignment  linear 
a.~X()  void  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  
i <=> j  strong_ordering
if X::iterator meets the random access iterator requirements,
otherwise strong_equality  constant  
a == b  convertible to bool  == is an equivalence relation. equal(a.begin(), a.end(), b.begin(), b.end())  Expects: T meets the Cpp17EqualityComparable requirements  Constant if a.size() != b.size(),
linear otherwise 
a != b  convertible to bool  Equivalent to !(a == b)  linear  
a.swap(b)  void  Effects: exchanges the contents of a and b  (Note A)  
swap(a, b)  void  Equivalent to 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 <=> 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  synththreewayresult<value_type>  lexicographical_compare_three_way(a.begin(), a.end(),
b.begin(), b.end(), synththreeway)  Expects:
Either <=> is defined for values of type (possibly const) T,
or < is defined for values of type (possibly const) T and
< is a total ordering relationship.  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;  Ensures: u.empty() returns true, u.get_allocator() == A()  constant  
X(m)  Ensures:
u.empty() returns true,  constant  
X u(m);  u.get_allocator() == m  
X(t, m) X u(t, m);  Ensures: u == t, u.get_allocator() == m  linear  
X(rv) X u(rv);  Ensures: u has the same elements as rv had before this
construction; the value of u.get_allocator() is the same as the
value of rv.get_allocator() before this construction.  constant  
X(rv, m) X u(rv, m);  Ensures: u has 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&  Ensures: a == t  linear 
a = rv  X&  Expects: If allocator_ traits<allocator_type> ::propagate_on_container_ move_assignment::value is false, T is Cpp17MoveInsertable into X and Cpp17MoveAssignable.  linear 
a.swap(b)  void  Effects: exchanges the contents of a and b  constant 
Expression  Return type  Assertion/note 
pre/postcondition  
X(n, t) X u(n, t);  Ensures: distance(begin(), end()) == n Effects: 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 Cpp17ForwardIterator requirements ([forward.iterators]), T
is also
Cpp17MoveInsertable into X. Ensures: distance(begin(), end()) == distance(i, j) Effects: 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 is also
Cpp17MoveInsertable into X, Cpp17MoveConstructible, Cpp17MoveAssignable,
and swappable ([swappable.requirements]). 
a.insert(p, il)  iterator  a.insert(p, il.begin(), il.end()). 
a.erase(q)  iterator  
a.erase(q1,q2)  iterator  
a.clear()  void  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 ([forward.iterators]), T
is also
Cpp17MoveInsertable into X. Invalidates all references, pointers and iterators
referring to the elements of a. 
a.assign(il)  void  a.assign(il.begin(), il.end()). 
a.assign(n,t)  void  Invalidates all references, pointers and iterators
referring to the elements of a. 
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  deque,
forward_list,
list  
a.push_front(rv)  void  deque,
forward_list,
list  
a.push_back(t)  void  basic_string,
deque,
list,
vector  
a.push_back(rv)  void  basic_string,
deque,
list,
vector  
a.pop_front()  void  Effects: Destroys the first element.  deque,
forward_list,
list 
a.pop_back()  void  Effects: 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 nodehandle { public: // These type declarations are described in Tables 78 and 79. 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::template rebind_traits<container_node_type>::pointer ptr_; optional<allocator_type> alloc_; public: // [container.node.cons], constructors, copy, and assignment constexpr nodehandle() noexcept : ptr_(), alloc_() {} nodehandle(nodehandle&&) noexcept; nodehandle& operator=(nodehandle&&); // [container.node.dtor], destructor ~nodehandle(); // [container.node.observers], observers 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; [[nodiscard]] bool empty() const noexcept; // [container.node.modifiers], modifiers void swap(nodehandle&) noexcept(ator_traits::propagate_on_container_swap::value  ator_traits::is_always_equal::value); friend void swap(nodehandle& x, nodehandle& y) noexcept(noexcept(x.swap(y))) { x.swap(y); } };
nodehandle(nodehandle&& nh) noexcept;
nodehandle& operator=(nodehandle&& nh);
~nodehandle();
value_type& value() const;
key_type& key() const;
mapped_type& mapped() const;
allocator_type get_allocator() const;
explicit operator bool() const noexcept;
[[nodiscard]] bool empty() const noexcept;
void swap(nodehandle& nh)
noexcept(ator_traits::propagate_on_container_swap::value 
ator_traits::is_always_equal::value);
template<class Iterator, class NodeType> struct insertreturntype { Iterator position; bool inserted; NodeType node; };
Expression  Return type  Assertion/note  Complexity 
pre/postcondition  
Key  compile time  
T  compile time  
Key  Expects: value_type is Cpp17Erasable from X  compile time  
X::value_type (map and multimap only)  pair<const Key, T>  Expects: value_type is Cpp17Erasable from X  compile time 
Compare  compile time  
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  
a specialization of a nodehandle
class template, such that the public nested types are
the same types as the corresponding types in X.  see [container.node]  compile time  
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() 
X::key_compare  constant  
X::value_compare  Returns: an object of value_compare constructed out of the comparison object  constant  
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 
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  
pair<iterator, bool>  Expects: If t is a nonconst rvalue, value_type is
Cpp17MoveInsertable into X; otherwise, value_type is
Cpp17CopyInsertable 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  Expects: If t is a nonconst rvalue, value_type is
Cpp17MoveInsertable into X; otherwise, value_type is
Cpp17CopyInsertable 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  Expects: If t is a nonconst rvalue, value_type is
Cpp17MoveInsertable into X; otherwise, value_type is
Cpp17CopyInsertable 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  Effects: 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. 
node_type  log(a.size())  
a.extract(q)  node_type  amortized constant  
void  Effects: Attempts to extract each element in a2 and insert it into a using the comparison object 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. Ensures: 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.  
size_type  
a.erase(q)  iterator  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  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  If no such element
exists, a.end() is returned.  
void  linear in a.size().  
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  
size_type  
a_tran. count(ke)  size_type  Returns: The number of elements with key r such that
!c(r, ke) && !c(ke, r)  
bool  Effects: Equivalent to: return b.find(k) != b.end();  logarithmic  
a_tran. contains(ke)  bool  Effects: Equivalent to: return a_tran.find(ke) != a_tran.end();  logarithmic 
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  
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  
Effects: Equivalent to: return make_pair(b.lower_bound(k), b.upper_bound(k));  logarithmic  
a_tran. equal_range(ke)  Effects: Equivalent to: return make_pair( a_tran.lower_bound(ke), a_tran.upper_bound(ke));  logarithmic 
value_comp(*j, *i) == false
value_comp(*i, *j) != false
Expression  Return type  Assertion/note  Complexity 
pre/postcondition  
Key  compile time  
T  compile time  
Key  Expects: value_type is Cpp17Erasable from X  compile time  
X::value_type (unordered_map and unordered_multimap only)  pair<const Key, T>  Expects: value_type is Cpp17Erasable from X  compile time 
Hash  compile time  
Hash::transparent_key_equal if such a qualifiedid
is valid and denotes a type ([temp.deduct]);
otherwise, Pred.  Pred is an equivalence relation.  compile time  
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  
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  
a specialization of a nodehandle
class template, such that the public nested types are
the same types as the corresponding types in X.  see [container.node]  compile time  
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). 
hasher  constant  
key_equal  constant  
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.  
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.  
pair<iterator, bool>  Expects: If t is a nonconst rvalue, value_type is
Cpp17MoveInsertable into X; otherwise, value_type is
Cpp17CopyInsertable 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  Expects: If t is a nonconst rvalue, value_type is
Cpp17MoveInsertable into X; otherwise, value_type is
Cpp17CopyInsertable into X.  
a.insert(p, t)  iterator  Expects: If t is a nonconst rvalue, value_type is
Cpp17MoveInsertable into X; otherwise, value_type is
Cpp17CopyInsertable into X. 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  
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.  
node_type  
a.extract(q)  node_type  
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.
Ensures: 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.  
size_type  
a.erase(q)  iterator  
a.erase(r)  iterator  
a.erase(q1, q2)  iterator  
void  Effects: Erases all elements in the container. Ensures: a.empty() is true  Linear in a.size().  
Returns: An iterator pointing to an element with key equivalent to
k, or b.end() if no such element exists.  
a_tran.find(ke)  Returns: An iterator pointing to an element with key equivalent to
ke, or a_tran.end() if no such element exists.  
size_type  
a_tran.count(ke)  size_type  
bool  Effects: Equivalent to b.find(k) != b.end()  
a_tran.contains(ke)  bool  Effects: Equivalent to a_tran.find(ke) != a_tran.end()  
Returns make_pair(b.end(), b.end()) if
no such elements exist.  
a_tran.equal_range(ke)  Returns make_pair(a_tran.end(), a_tran.end()) if
no such elements exist.  
size_type  Constant  
size_type  Constant  
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  
size_type  
If the bucket is empty, then
b.begin(n) == b.end(n).  Constant  
Constant  
const_local_iterator  If the bucket is empty, then
b.cbegin(n) == b.cend(n).  Constant  
const_local_iterator  Returns: An iterator which is the pasttheend
value for the bucket.  Constant  
float  Returns: The average number of elements per bucket.  Constant  
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 
void  Average case linear in a.size(), worst case quadratic.  
void  Average case linear in a.size(), worst case quadratic. 