C++ Academy · Leçon

Comparateurs personnalisés

Contrôler l’ordre

Comparateurs personnalisés est une leçon C++ Academy gratuite sur CoddyKit. Ceci est la leçon 4 sur 4. Tu peux lire la leçon complète ci-dessous gratuitement — puis la pratiquer en direct dans le navigateur avec un éditeur de code intégré et un tuteur IA 24/7. Elle fait partie du parcours d'apprentissage C++ Academy, et ta progression se synchronise sur le web et l'application CoddyKit. Le cours C++ Academy comprend 4 leçons au total.

Pourquoi utiliser des comparateurs personnalisés ?

Par défaut, les conteneurs ordonnés effectuent le tri avec std::less (dans l’ordre croissant). Un comparateur personnalisé vous permet de modifier cet ordre, par exemple pour trier dans l’ordre décroissant ou selon un champ précis.

#include <iostream>
#include <set>

int main() {
    std::set<int> ascending{3, 1, 2};
    for (int x : ascending) std::cout << x << ' ';
    std::cout << '\n';
    return 0;
}

Ordre décroissant avec std::greater

Le comparateur personnalisé le plus simple est le foncteur standard std::greater, qui effectue un tri dans l’ordre décroissant.

#include <iostream>
#include <set>
#include <functional>

int main() {
    std::set<int, std::greater<int>> s{3, 1, 2};
    for (int x : s) std::cout << x << ' ';
    std::cout << '\n';
    return 0;
}

Comparateur d’une map

Le comparateur est le troisième paramètre de modèle de std::map. Ici, les clés sont triées de la plus grande à la plus petite.

#include <iostream>
#include <map>
#include <functional>

int main() {
    std::map<int, std::string, std::greater<int>> m{
        {1, "one"}, {3, "three"}, {2, "two"}
    };
    for (const auto& [k, v] : m) std::cout << k << ':' << v << ' ';
    std::cout << '\n';
    return 0;
}

Fonctionnement des comparateurs

Un comparateur est une fonction appelable qui reçoit deux arguments et renvoie true si le premier doit apparaître avant le second. Il doit définir un ordre faible strict.

#include <iostream>

struct Less {
    bool operator()(int a, int b) const { return a < b; }
};

int main() {
    Less cmp;
    std::cout << std::boolalpha << cmp(2, 5) << '\n';
    std::cout << cmp(5, 2) << '\n';
    return 0;
}

Un comparateur sous forme de structure personnalisée

Définissez votre propre structure de foncteur avec operator(), puis transmettez son type comme comparateur.

#include <iostream>
#include <set>

struct ByAbs {
    bool operator()(int a, int b) const {
        return (a < 0 ? -a : a) < (b < 0 ? -b : b);
    }
};

int main() {
    std::set<int, ByAbs> s{-5, 3, -1, 4};
    for (int x : s) std::cout << x << ' ';
    std::cout << '\n';
    return 0;
}

Trier des chaînes par longueur

Les comparateurs peuvent comparer n’importe quelle propriété. Ici, les chaînes sont ordonnées par longueur, puis par ordre alphabétique pour départager les égalités.

#include <iostream>
#include <set>
#include <string>

struct ByLen {
    bool operator()(const std::string& a, const std::string& b) const {
        if (a.size() != b.size()) return a.size() < b.size();
        return a < b;
    }
};

int main() {
    std::set<std::string, ByLen> s{"bbb", "a", "cc", "dd"};
    for (const auto& x : s) std::cout << x << ' ';
    std::cout << '\n';
    return 0;
}

Pourquoi les critères de départage sont importants

Si votre comparateur indique qu’aucun des deux éléments ne doit apparaître avant l’autre, le conteneur les considère comme égaux. Dans un set, cela signifie que l’un des deux est supprimé comme doublon.

#include <iostream>
#include <set>
#include <string>

struct LenOnly {
    bool operator()(const std::string& a, const std::string& b) const {
        return a.size() < b.size();
    }
};

int main() {
    std::set<std::string, LenOnly> s{"ab", "cd", "x"};
    std::cout << s.size() << " elements\n";
    return 0;
}

Les lambdas comme comparateurs

Vous pouvez utiliser une lambda en transmettant son type avec decltype et la lambda elle-même au constructeur.

#include <iostream>
#include <set>

int main() {
    auto cmp = [](int a, int b) { return a > b; };
    std::set<int, decltype(cmp)> s(cmp);
    s.insert(1);
    s.insert(3);
    s.insert(2);
    for (int x : s) std::cout << x << ' ';
    std::cout << '\n';
    return 0;
}

Comparateurs dans priority_queue

Les comparateurs permettent également de configurer std::priority_queue. Avec std::greater, celle-ci devient un tas-min.

#include <iostream>
#include <queue>
#include <vector>
#include <functional>

int main() {
    std::priority_queue<int, std::vector<int>, std::greater<int>> pq;
    pq.push(5); pq.push(1); pq.push(3);
    while (!pq.empty()) { std::cout << pq.top() << ' '; pq.pop(); }
    std::cout << '\n';
    return 0;
}

Comparer des paires

Pour trier un ensemble de paires selon le second élément, écrivez un comparateur qui examine .second.

#include <iostream>
#include <set>
#include <utility>

struct BySecond {
    bool operator()(const std::pair<int,int>& a, const std::pair<int,int>& b) const {
        return a.second < b.second;
    }
};

int main() {
    std::set<std::pair<int,int>, BySecond> s{{1, 9}, {2, 3}, {3, 6}};
    for (const auto& p : s) std::cout << p.first << ':' << p.second << ' ';
    std::cout << '\n';
    return 0;
}

Comparateurs transparents

L’utilisation de std::less<> (avec des chevrons vides) permet la recherche hétérogène en C++14 et évite les conversions temporaires de clés.

#include <iostream>
#include <set>
#include <functional>

int main() {
    std::set<int, std::less<>> s{1, 2, 3};
    std::cout << (s.find(2) != s.end() ? "found" : "no") << '\n';
    return 0;
}

Vérification rapide

Vérifiez votre compréhension de la manière dont les comparateurs définissent l’égalité.

Récapitulatif

Vous avez appris que les comparateurs personnalisés :

modifient l’ordre via le paramètre de modèle du comparateur du conteneur
peuvent être std::greater, une structure de foncteur ou une lambda (via decltype)
définissent l’égalité par équivalence ; incluez donc toujours un critère de départage pour éviter de perdre des éléments distincts

Prochain cours : effectuer des recherches rapides à l’aide du hachage avec std::unordered_map.

Questions Fréquemment Posées

La leçon « Comparateurs personnalisés » est-elle gratuite ?

Oui — le texte complet de « Comparateurs personnalisés » est gratuit à lire ici sur le web. Pour la pratiquer de manière interactive (un éditeur de code intégré et un tuteur IA 24/7) et déverrouiller le reste du cours C++ Academy, passe à CoddyKit PRO. Le cours C++ Academy comprend 4 leçons au total.

Qu'est-ce que j'apprendrai dans « Comparateurs personnalisés » ?

Contrôler l’ordre Tu pratiques C++ Academy avec du code pratique que tu exécutes directement dans le navigateur, et un tuteur IA 24/7 répond à tes questions au fur et à mesure que tu avances dans la leçon.

Dois-je avoir de l'expérience pour commencer C++ Academy ?

Aucune expérience préalable n'est requise. C++ Academy sur CoddyKit est structuré pour les débutants jusqu'aux apprenants avancés, donc tu peux commencer ici ou depuis le début et avancer à ton rythme. Ceci est la leçon 4 sur 4.

Combien de temps prend la leçon « Comparateurs personnalisés » ?

La plupart des leçons CoddyKit prennent environ 5–10 minutes. Chacune est courte et interactive, tu progresses régulièrement et tu repiques exactement où tu t'es arrêté sur le web et l'app.

Peux-tu écrire et exécuter du code dans cette leçon C++ Academy ?

Oui. Chaque leçon C++ Academy inclut un éditeur de code intégré, tu écris et exécutes du vrai code directement dans ton navigateur et tu reçois des retours IA instantanés — aucune configuration locale requise.

Toutes les leçons de ce cours

std::map
std::set
multimap et multiset
Comparateurs personnalisés

← Retour à C++ Academy