Home - News ( United States | United Kingdom | Italy | Germany ) - Football scores

Showing content from http://en.cppreference.com/w/cpp/string/basic_string/../../error/../container/map/at.html below:

std::map<Key,T,Compare,Allocator>::at - cppreference.com

T& at( const Key& key );

const T& at( const Key& key ) const;

template< class K >
T& at( const K& x );

template< class K >
const T& at( const K& x ) const;

Returns a reference to the mapped value of the element with specified key. If no such element exists, an exception of type std::out_of_range is thrown.

1,2) The key is equivalent to key.

3,4) The key compares equivalent to the value x. The reference to the mapped value is obtained as if by expression this->find(x)->second.

The expression this->find(x) must be well-formed and have well-defined behavior, otherwise the behavior is undefined.

These overloads participate in overload resolution only if

is

. It allows calling this function without constructing an instance of

.

A reference to the mapped value of the requested element.

if the container does not have an element with the specified

.

if the container does not have the specified element, that is, if

is

.

Logarithmic in the size of the container.

#include <cassert>
#include <iostream>
#include <map>
 
struct LightKey { int o; };
struct HeavyKey { int o[1000]; };
 
// The container must use std::less<> (or other transparent Comparator) to
// access overloads (3,4). This includes standard overloads, such as
// comparison between std::string and std::string_view.
bool operator<(const HeavyKey& x, const LightKey& y) { return x.o[0] < y.o; }
bool operator<(const LightKey& x, const HeavyKey& y) { return x.o < y.o[0]; }
bool operator<(const HeavyKey& x, const HeavyKey& y) { return x.o[0] < y.o[0]; }
 
int main()
{
    std::map<int, char> map{{1, 'a'}, {2, 'b'}};
    assert(map.at(1) == 'a');
    assert(map.at(2) == 'b');
    try
    {
        map.at(13);
    }
    catch(const std::out_of_range& ex)
    {
        std::cout << "1) out_of_range::what(): " << ex.what() << '\n';
    }
 
#ifdef __cpp_lib_associative_heterogeneous_insertion
    // Transparent comparison demo.
    std::map<HeavyKey, char, std::less<>> map2{{{1}, 'a'}, {{2}, 'b'}};
    assert(map2.at(LightKey{1}) == 'a');
    assert(map2.at(LightKey{2}) == 'b');
    try
    {
        map2.at(LightKey{13});
    }
    catch(const std::out_of_range& ex)
    {
        std::cout << "2) out_of_range::what(): " << ex.what() << '\n';
    }
#endif
}

Possible output:

1) out_of_range::what(): map::at:  key not found
2) out_of_range::what(): map::at:  key not found

The following behavior-changing defect reports were applied retroactively to previously published C++ standards.

RetroSearch is an open source project built by @garambo | Open a GitHub Issue

Search and Browse the WWW like it's 1997 | Search results from DuckDuckGo

HTML: 3.2 | Encoding: UTF-8 | Version: 0.7.4