std::multimap::lower_bound

iterator lower_bound( const Key& key ); (1) const_iterator lower_bound( const Key& key ) const; (1) template< class K > iterator lower_bound(const K& x); (2) (since C++14) template< class K > const_iterator lower_bound(const K& x) const; (2) (since C++14) 1) Returns an iterator pointing to the first element that is not less than key. 2) Returns an iterator pointing to the first element that compares not less to the value x. This overload

std::multimap::key_comp

key_compare key_comp() const; Returns the function object that compares the keys, which is a copy of this container's constructor argument comp. Parameters (none). Return value The key comparison function object. Complexity Constant. See also value_comp returns the function that compares keys in objects of type value_type (public member function)

std::multimap::insert

iterator insert( const value_type& value ); (1) template< class P > iterator insert( P&& value ); (2) (since C++11) iterator insert( value_type&& value ); (2) (since C++17) (3) iterator insert( iterator hint, const value_type& value ); (until C++11) iterator insert( const_iterator hint, const value_type& value ); (since C++11) template< class P > iterator insert( const_iterator hint, P&& value ); (4) (since C++11

std::multimap::get_allocator

allocator_type get_allocator() const; Returns the allocator associated with the container. Parameters (none). Return value The associated allocator. Complexity Constant.

std::multimap::find

iterator find( const Key& key ); (1) const_iterator find( const Key& key ) const; (2) template< class K > iterator find( const K& x ); (3) (since C++14) template< class K > const_iterator find( const K& x ) const; (4) (since C++14) 1,2) Finds an element with key equivalent to key. If there are several elements with key in the container, any of them may be returned. 3,4) Finds an element with key that compares equivalent to the value x. Th

std::multimap::erase

(1) void erase( iterator pos ); (until C++11) iterator erase( iterator pos ); (since C++17) iterator erase( const_iterator pos ); (since C++11) (2) void erase( iterator first, iterator last ); (until C++11) iterator erase( const_iterator first, const_iterator last ); (since C++11) size_type erase( const key_type& key ); (3) Removes specified elements from the container. 1) Removes the element at pos. 2) Removes the elements in the range [first; last),

std::multimap::equal_range

std::pair<iterator,iterator> equal_range( const Key& key ); (1) std::pair<const_iterator,const_iterator> equal_range( const Key& key ) const; (2) template< class K > std::pair<iterator,iterator> equal_range( const K& x ); (3) (since C++14) template< class K > std::pair<const_iterator,const_iterator> equal_range( const K& x ) const; (4) (since C++14) Returns a range containing all elements with the given key in the con

std::multimap::end

iterator end(); const_iterator end() const; const_iterator cend() const; (since C++11) Returns an iterator to the element following the last element of the container. This element acts as a placeholder; attempting to access it results in undefined behavior. Parameters (none). Return value Iterator to the element following the last element. Exceptions (none) (until C++11) noexcept specification: noexcept (since C++11) Complexity Constant. See also begin

std::multimap::empty

bool empty() const; Checks if the container has no elements, i.e. whether begin() == end(). Parameters (none). Return value true if the container is empty, false otherwise. Exceptions (none) (until C++11) noexcept specification: noexcept (since C++11) Complexity Constant. Example The following code uses empty to check if a std::multimap<int, int> contains any elements: #include <map> #include <iostream> #include <utility> int main() { st

std::multimap::emplace_hint

template <class... Args> iterator emplace_hint( const_iterator hint, Args&&... args ); (since C++11) Inserts a new element into the container as close as possible to the position just before hint. The element is constructed in-place, i.e. no copy or move operations are performed. The constructor of the element type (value_type, that is, std::pair<const Key, T>) is called with exactly the same arguments as supplied to the function, forwarded with std::forward<Args&