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 <iostream>
#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 <utility>
#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 <utility>
#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 <utility>
#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 <utility>
#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 <utility>
#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 <utility>
#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 <utility>
#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 <utility>
#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 <utility>
#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

// Recommandé : utilisez auto et make_pair
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

std::map<int, std::string> myMap;

// 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 createString() {
    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

// Liaisons structurées prises en charge depuis C++17
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
}
autres extensions