Namespaces
Variants

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

From cppreference.net

C++
Containers library
std::multimap
Member functions
Non-member functions
Deduction guides (C++17)
iterator find ( const Key & key ) ;
(1) (constexpr depuis C++26)
const_iterator find ( const Key & key ) const ;
(2) (constexpr depuis C++26)
template < class K >
iterator find ( const K & x ) ;
(3) (depuis C++14)
(constexpr depuis C++26)
template < class K >
const_iterator find ( const K & x ) const ;
(4) (depuis C++14)
(constexpr depuis C++26)
1,2) Trouve un élément dont la clé est équivalente à key . Si plusieurs éléments avec la clé demandée sont présents dans le conteneur, n'importe lequel d'entre eux peut être retourné.
3,4) Trouve un élément dont la clé est équivalente à x .
Cette surcharge participe à la résolution de surcharge uniquement si Compare est transparent . Elle permet d'appeler cette fonction sans construire une instance de Key .

Table des matières

Paramètres

key - valeur clé de l'élément à rechercher
x - une valeur de type quelconque pouvant être comparée de manière transparente avec une clé

Valeur de retour

Un itérateur vers l'élément demandé. Si aucun élément correspondant n'est trouvé, un itérateur past-the-end (voir end() ) est retourné.

Complexité

Logarithmique par rapport à la taille du conteneur.

Notes

Macro de test de fonctionnalité Valeur Norme Fonctionnalité
__cpp_lib_generic_associative_lookup 201304L (C++14) Recherche de comparaison hétérogène dans les conteneurs associatifs ; surcharges ( 3,4 )

Exemple

Exécuter ce code 
#include <iostream>
#include <map>
struct LightKey
{
    int x;
};
struct FatKey
{
    int x;
    int data[1000]; // un bloc lourd
};
// Comme détaillé ci-dessus, le conteneur doit utiliser std::less<> (ou autre
// comparateur transparent) pour accéder à ces surcharges. Cela inclut les surcharges
// standards, telles que la comparaison entre std::string et 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()
{
    // Démonstration simple de comparaison.
    std::multimap<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";
    // Démonstration de comparaison transparente.
    std::multimap<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";
    // Obtention d'itérateurs constants.
    // Le compilateur décide de retourner un itérateur de type (non) const selon
    // la manière d'accéder à la map ; pour empêcher une modification intentionnelle,
    // l'une des options les plus simples est d'accéder à la map via une référence constante.
    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'; // erreur : assignation du membre
                              // 'std::pair<const FatKey, char>::second'
                              // dans un objet en lecture seule
    }
}

Sortie : 

Found 2 b
Found 2 b
Found 2 b

Voir aussi

renvoie le nombre d'éléments correspondant à une clé spécifique
(fonction membre publique)
renvoie la plage d'éléments correspondant à une clé spécifique
(fonction membre publique)