Vérifier si une clé existe dans une carte en C++

Jinku Hu 12 octobre 2023
  1. Utilisez la fonction std::map::find pour vérifier si la clé existe dans une carte C++
  2. Utilisez la fonction std::map::count pour vérifier si la clé existe dans une carte C++
  3. Utilisez la fonction std::map::contains pour vérifier si la clé existe dans une carte C++
Vérifier si une clé existe dans une carte en C++

Cet article présentera comment vérifier si une clé existe dans une carte en C++.

Utilisez la fonction std::map::find pour vérifier si la clé existe dans une carte C++

Le conteneur std::map est une structure de données associative de paires clé-valeur stockées triées, et chaque élément a une clé unique. D’autre part, STL fournit également une version non triée du même conteneur nommée std::unordered_map. Ces deux conteneurs prennent en charge les méthodes de recherche de clé décrites ci-dessous.

find est l’une des fonctions intégrées du conteneur std::map qui prend un seul argument de la valeur de clé correspondante à rechercher. La fonction renvoie un itérateur à l’élément avec la valeur-clé donnée, sinon, l’itérateur au-delà de la fin. Dans l’exemple suivant, nous initialisons la map des types std::pair<string, string> puis prenons la valeur clé de l’entrée utilisateur passée à la fonction find. L’exemple de programme renvoie la chaîne affirmative au flux cout.

#include <iostream>
#include <map>

using std::cin;
using std::cout;
using std::endl;
using std::map;
using std::string;

int main() {
  string key_to_find;
  std::map<string, string> lang_map = {{
                                           "j",
                                           "Julia",
                                       },
                                       {
                                           "p",
                                           "Python",
                                       },
                                       {
                                           "m",
                                           "MATLAB",
                                       },
                                       {
                                           "o",
                                           "Octave",
                                       },
                                       {
                                           "s",
                                           "Scala",
                                       },
                                       {
                                           "l",
                                           "Lua",
                                       }};

  for (const auto& [key, value] : lang_map) {
    cout << key << " : " << value << endl;
  }

  cout << "Enter the key to search for: ";
  cin >> key_to_find;

  if (lang_map.find(key_to_find) != lang_map.end()) {
    cout << "Key Exists!" << endl;
  }

  return EXIT_SUCCESS;
}

Production:

j : Julia
l : Lua
m : MATLAB
o : Octave
p : Python
s : Scala
Enter the key to search for: l
Key Exists!

Utilisez la fonction std::map::count pour vérifier si la clé existe dans une carte C++

Alternativement, on peut utiliser la fonction intégrée count du conteneur std::map pour vérifier si une clé donnée existe dans un objet carte. Notez que la fonction count récupère le nombre d’éléments qui ont la valeur de clé donnée. Si aucun élément n’est trouvé avec la clé 0, la valeur est retournée. Ainsi, nous pouvons utiliser l’appel de fonction count comme condition if pour produire la chaîne d’affirmation lorsque la clé donnée existe dans un objet map.

#include <iostream>
#include <map>

using std::cin;
using std::cout;
using std::endl;
using std::map;
using std::string;

int main() {
  string key_to_find;
  std::map<string, string> lang_map = {{
                                           "j",
                                           "Julia",
                                       },
                                       {
                                           "p",
                                           "Python",
                                       },
                                       {
                                           "m",
                                           "MATLAB",
                                       },
                                       {
                                           "o",
                                           "Octave",
                                       },
                                       {
                                           "s",
                                           "Scala",
                                       },
                                       {
                                           "l",
                                           "Lua",
                                       }};

  cout << "Enter the key to search for: ";
  cin >> key_to_find;

  if (lang_map.count(key_to_find)) {
    cout << "Key Exists!" << endl;
  }

  return EXIT_SUCCESS;
}

Production:

Enter the key to search for: l
Key Exists!

Utilisez la fonction std::map::contains pour vérifier si la clé existe dans une carte C++

contains est une autre fonction intégrée qui peut être utilisée pour trouver si la clé existe dans une map. Cette fonction renvoie une valeur booléenne si l’élément avec la clé donnée existe dans l’objet. Notez que les trois fonctions répertoriées dans cet article ont une complexité logarithmique.

#include <iostream>
#include <map>

using std::cin;
using std::cout;
using std::endl;
using std::map;
using std::string;

int main() {
  string key_to_find;
  std::map<string, string> lang_map = {{
                                           "j",
                                           "Julia",
                                       },
                                       {
                                           "p",
                                           "Python",
                                       },
                                       {
                                           "m",
                                           "MATLAB",
                                       },
                                       {
                                           "o",
                                           "Octave",
                                       },
                                       {
                                           "s",
                                           "Scala",
                                       },
                                       {
                                           "l",
                                           "Lua",
                                       }};

  cout << "Enter the key to search for: ";
  cin >> key_to_find;

  if (lang_map.contains(key_to_find)) {
    cout << "Key Exists!" << endl;
  }

  return EXIT_SUCCESS;
}

Production:

Enter the key to search for: l
Key Exists!
Auteur: Jinku Hu
Jinku Hu avatar Jinku Hu avatar

Founder of DelftStack.com. Jinku has worked in the robotics and automotive industries for over 8 years. He sharpened his coding skills when he needed to do the automatic testing, data collection from remote servers and report creation from the endurance test. He is from an electrical/electronics engineering background but has expanded his interest to embedded electronics, embedded programming and front-/back-end programming.

LinkedIn Facebook

Article connexe - C++ Map