std::map<Key,T,Compare,Allocator>::find

iterator find( const Key& key );	(1)
const_iterator find( const Key& key ) const;	(2)
template< class K > iterator find( const K& x );	(3)	(начиная с C++14)
template< class K > const_iterator find( const K& x ) const;	(4)	(начиная с C++14)

1,2) Находит элемент с ключом, эквивалентным key.

3,4) Находит элемент с ключом, который сравнивается как эквивалентный значению x. Эта перегрузка участвует в разрешении перегрузки, только если квалифицированный идентификатор Compare::is_transparent является корректным и обозначает тип. Она позволяет вызывать эту функцию без создания экземпляра Key.

Параметры

key	-	значение ключа элемента, который требуется найти
x	-	значение любого типа, которое можно прозрачно сравнить с ключом

Возвращаемое значение

Итератор на запрошенный элемент. Если такой элемент не найден, возвращается итератор за концом (см. end()).

Сложность

Логарифмическая относительно размера контейнера.

Примечания

Макрос проверки поддержки возможности	Значение	Стандарт	Возможность
`__cpp_lib_generic_associative_lookup`	`201304L`	(C++14)	Гетерогенный поиск с использованием сравнения в ассоциативных контейнерах; перегрузки (3,4)

Пример

#include <iostream>
#include <map>

struct LightKey
{
    int x;
};

struct FatKey
{
    int x;
    int data[1000]; // a heavy blob
};

// As detailed above, the container must use std::less<> (or other transparent
// Comparator) to access these overloads. This includes standard overloads,
// such as comparison between std::string and std::string_view.
bool operator<(const FatKey& fk, const LightKey& lk) { return fk.x < lk.x; }
bool operator<(const LightKey& lk, const FatKey& fk) { return lk.x < fk.x; }
bool operator<(const FatKey& fk1, const FatKey& fk2) { return fk1.x < fk2.x; }

int main()
{
    // Simple comparison demo.
    std::map<int, char> example{{1, 'a'}, {2, 'b'}};

    if (auto search = example.find(2); search != example.end())
        std::cout << "Found " << search->first << ' ' << search->second << '\n';
    else
        std::cout << "Not found\n";

    // Transparent comparison demo.
    std::map<FatKey, char, std::less<>> example2{{{1, {}}, 'a'}, {{2, {}}, 'b'}};

    LightKey lk = {2};
    if (auto search = example2.find(lk); search != example2.end())
        std::cout << "Found " << search->first.x << ' ' << search->second << '\n';
    else
        std::cout << "Not found\n";

    // Obtaining const iterators.
    // Compiler decides whether to return iterator of (non) const type by way of
    // accessing map; to prevent intentional modification, one of the simplest
    // options is to access the map via a constant reference.
    const auto& example2ref = example2;
    if (auto search = example2ref.find(lk); search != example2.end())
    {
        std::cout << "Found " << search->first.x << ' ' << search->second << '\n';
    //  search->second = 'c'; // error: assignment of member
                              // 'std::pair<const FatKey, char>::second'
                              // in read-only object
    }
}

Вывод:

Found 2 b
Found 2 b
Found 2 b

См. также

at	доступ к указанному элементу с проверкой границ (открытая функция-член)
operator[]	доступ к указанному элементу или его вставка (открытая функция-член)
count	возвращает количество элементов с указанным ключом (открытая функция-член)
equal_range	возвращает диапазон элементов с указанным ключом (открытая функция-член)

© cppreference.com
Licensed under the Creative Commons Attribution-ShareAlike Unported License v3.0.
https://en.cppreference.com/cpp/container/map/find