Bibliothèque standard C++ utility
Dans la bibliothèque standard C++,<utility>Le fichier d'en-tête contient quelques classes et fonctions utilitaires pratiques, qui sont très utiles lors de l'écriture de code efficace et lisible.
utilityLa valeur essentielle de la bibliothèque réside dans :
- Fournir des structures de données fondamentales et des fonctions utilitaires
- Simplifier la mise en œuvre des tâches de programmation courantes
- Fournir un support fondamental pour les autres composants de la bibliothèque standard
utilityBien que le fichier d'en-tête soit petit, les outils qu'il fournit sont très pratiques :
| Composants/Fonctions | Objectif | Cas d'utilisation |
|---|---|---|
std::pair |
Stocker deux valeurs liées | Fonctions renvoyant plusieurs valeurs, éléments de map |
std::make_pair |
Créer facilement des paires | Déduction de type de template, simplification du code |
std::swap |
Échanger deux valeurs | Implémentation d'algorithmes, opérations de tri |
std::move |
Activer la sémantique de déplacement | Gestion des ressources, optimisation des performances |
std::forward |
Transfert parfait | Références universelles, programmation par templates |
Explication des composants principaux
std::pair : conteneur de paires clé-valeur
std::pairOuiutilitypair : le composant le plus couramment utilisé de la bibliothèque, servant à combiner deux valeurs en un seul objet.
Syntaxe de base
#include <utility> // 创建 pair 对象的基本方式 std::pair<类型1, 类型2> 变量名(值1, 值2);
Exemple
#include <utility>
#include <string>
int main() {
// Méthode 1 : Initialisation directe
std::pair<int, std::string> student1(101, "Alice");
// Méthode 2 : Utilisation de la fonction make_pair (recommandée)
auto student2 = std::make_pair(102, "Bob");
// Méthode 3 : Guide de déduction pris en charge depuis C++17
std::pair student3(103, "Charlie");
// Accéder aux membres de pair
std::cout << "ID étudiant : " << student1.first << ", Nom : " << student1.second << std::endl;
return 0;
}
Opérations courantes sur pair
Exemple
#include <iostream>
void pairOperations() {
// Créer une paire
std::pair<int, double> p1(10, 3.14);
std::pair<int, double> p2(20, 2.71);
// Opérations de comparaison
if (p1 < p2) {
std::cout << "p1 est inférieur à p2" << std::endl;
}
// Opération d'affectation
p1 = p2;
// Affectation membre à membre prise en charge depuis C++11
int a;
double b;
std::tie(a, b) = p1; // Affecter la valeur de p1 à a et b respectivement
// Liaison structurée C++17 (plus concise)
auto [x, y] = p1;
std::cout << "x = " << x << ", y = " << y << std::endl;
}
std::make_pair: fonction de création pratique
std::make_pairstd::make_pair: une fonction modèle qui peut déduire automatiquement les types, simplifiant le processus de création de paires.
Exemple
#include <iostream>
#include <string>
void demonstrateMakePair() {
// Déduction automatique des types, pas besoin de spécifier explicitement les paramètres de modèle
auto p1 = std::make_pair(42, "Hello");
auto p2 = std::make_pair(3.14, true);
// Particulièrement pratique pour une utilisation dans des conteneurs
std::vector<std::pair<int, std::string>> students;
students.push_back(std::make_pair(101, "Alice"));
students.push_back(std::make_pair(102, "Bob"));
for (const auto& student : students) {
std::cout << "Numéro d'étudiant : " << student.first
<< ", Nom : " << student.second << std::endl;
}
}
Fonctions utilitaires
std::swap : échanger deux valeurs
std::swapUtilisé pour échanger les valeurs de deux objets du même type.
Exemple
#include <iostream>
void demonstrateSwap() {
int a = 10, b = 20;
std::cout << "Avant l'échange : a = " << a << ", b = " << b << std::endl;
std::swap(a, b);
std::cout << "Après l'échange : a = " << a << ", b = " << b << std::endl;
// Peut aussi être utilisé pour des types personnalisés (si la sémantique de déplacement est implémentée)
std::string str1 = "Hello", str2 = "World";
std::swap(str1, str2);
std::cout << "Échange de chaînes : " << str1 << " " << str2 << std::endl;
}
std::move : prise en charge de la sémantique de déplacement
std::moveUtilisé pour convertir un objet en une référence rvalue, permettant la sémantique de déplacement.
Exemple
#include <iostream>
#include <vector>
void demonstrateMove() {
std::vector<int> v1 = {1, 2, 3, 4, 5};
std::vector<int> v2;
std::cout << "Avant le déplacement - taille de v1 : " << v1.size()
<< ", taille de v2 : " << v2.size() << std::endl;
// Utiliser la sémantique de déplacement pour transférer la propriété des ressources
v2 = std::move(v1);
std::cout << "Après le déplacement - taille de v1 : " << v1.size()
<< ", taille de v2 : " << v2.size() << std::endl;
// v1 est maintenant dans un état valide mais non spécifié
// Normalement, v1 ne devrait pas être réutilisé à moins d'être réaffecté
}
std::forward : transmission parfaite
std::forwardUtilisé pour implémenter la transmission parfaite, en préservant la catégorie de valeur des arguments.
Exemple
#include <iostream>
// Fonction ordinaire - ne peut pas préserver la catégorie de valeur
template<typename T>
void normalFunction(T arg) {
std::cout << "Paramètre de fonction ordinaire" << std::endl;
}
// Fonction utilisant la transmission parfaite
template<typename T>
void perfectForwardingFunction(T&& arg) {
// Préserver la catégorie de valeur d'origine du paramètre (lvalue ou rvalue)
normalFunction(std::forward<T>(arg));
}
void demonstrateForward() {
int x = 10;
// Passer une lvalue
perfectForwardingFunction(x);
// Passer une rvalue
perfectForwardingFunction(20);
}
Utilitaires de séquence d'entiers (C++14)
C++14 a introduit des utilitaires de séquence d'entiers, principalement utilisés pour la métaprogrammation de modèles.
std::integer_sequence
Exemple
#include <iostream>
// Utiliser une séquence d'entiers pour afficher chaque valeur de la séquence
template<typename T, T... Ints>
void print_sequence(std::integer_sequence<T, Ints...>) {
// Utiliser une expression de repli (C++17) pour afficher toutes les valeurs
((std::cout << Ints << " "), ...);
std::cout << std::endl;
}
void demonstrateIntegerSequence() {
// Créer une séquence d'entiers
auto seq = std::integer_sequence<int, 1, 2, 3, 4, 5>();
print_sequence(seq);
// Utiliser make_integer_sequence pour générer la séquence
auto seq2 = std::make_integer_sequence<int, 5>();
print_sequence(seq2); // Sortie : 0 1 2 3 4
}
Exemples d'applications concrètes
Exemple 1 : Fonction retournant plusieurs valeurs
Exemple
#include <iostream>
#include <cmath>
// La fonction retourne plusieurs valeurs : résultat du calcul et code d'erreur
std::pair<double, bool> calculateSqrt(double number) {
if (number < 0) {
return std::make_pair(0.0, false); // Cas d'erreur
}
return std::make_pair(std::sqrt(number), true); // Cas de succès
}
void multipleReturnValues() {
auto result1 = calculateSqrt(16.0);
if (result1.second) {
std::cout << "Racine carrée : " << result1.first << std::endl;
} else {
std::cout << "Erreur de calcul : impossible de calculer la racine carrée d'un nombre négatif" << std::endl;
}
auto result2 = calculateSqrt(-4.0);
if (!result2.second) {
std::cout << "Erreur de calcul : impossible de calculer la racine carrée d'un nombre négatif" << std::endl;
}
}
Cas 2 : Application dans les conteneurs STL
Exemple
#include <map>
#include <iostream>
#include <string>
void mapWithPair() {
// Chaque élément de std::map est une std::pair
std::map<int, std::string> studentMap;
// Insérer une paire clé-valeur
studentMap.insert(std::make_pair(101, "Alice"));
studentMap.emplace(102, "Bob"); // Manière plus efficace
// Parcourir la map
for (const auto& [id, name] : studentMap) {
std::cout << "ID étudiant: " << id << ", Nom: " << name << std::endl;
}
// Rechercher l'élément
auto it = studentMap.find(101);
if (it != studentMap.end()) {
std::cout << "Étudiant trouvé: " << it->second << std::endl;
}
}
Exemple 3: Implémentation d'un dictionnaire simple
Exemple
#include <vector>
#include <iostream>
#include <algorithm>
class SimpleDictionary {
private:
std::vector<std::pair<std::string, std::string>> entries;
public:
void addWord(const std::string& word, const std::string& meaning) {
entries.emplace_back(word, meaning);
}
std::pair<bool, std::string> findMeaning(const std::string& word) {
for (const auto& [w, m] : entries) {
if (w == word) {
return std::make_pair(true, m);
}
}
return std::make_pair(false, "");
}
void printAll() {
for (const auto& [word, meaning] : entries) {
std::cout << word << ": " << meaning << std::endl;
}
}
};
void dictionaryExample() {
SimpleDictionary dict;
dict.addWord("pomme", "un fruit");
dict.addWord("livre", "un objet utilisé pour la lecture");
auto result = dict.findMeaning("pomme");
if (result.first) {
std::cout << "Signification : " << result.second << std::endl;
}
}
Bonnes pratiques et considérations
1. Utilisez auto pour simplifier la création de paires
Exemple
auto student = std::make_pair(101, "Alice");
// Non recommandé : spécifier explicitement le type (plus verbeux)
std::pair<int, std::string> student(101, "Alice");
2. Préférer emplace à insert
Exemple
// Recommandé : utiliser emplace (plus efficace)
myMap.emplace(1, "one");
// Non recommandé : utiliser insert (nécessite la construction d'un objet temporaire)
myMap.insert(std::make_pair(1, "one"));
3. Utilisation correcte de la sémantique de déplacement
Exemple
std::string str = "a very large string";
// Correct : utiliser move au retour
return str; // Le compilateur optimisera automatiquement, pas besoin de move explicite
}
void processString(std::string str) {
// Gestion des chaînes
}
void usageExample() {
std::string largeStr = "very large data";
// Correct : utiliser move lors du passage
processString(std::move(largeStr));
// Remarque : largeStr ne doit plus être utilisé
}
4. Utilisation des liaisons structurées
Exemple
std::pair<int, std::string> getStudent() {
return {101, "Alice"};
}
void structuredBindingExample() {
// Méthode traditionnelle
auto student = getStudent();
int id = student.first;
std::string name = student.second;
// Méthode moderne (C++17)
auto [id2, name2] = getStudent(); // Plus concis et clair
}