std::sort est une fonction extrêmement courante dans la bibliothèque standard C++ pour organiser les éléments d'une séquence. Elle est particulièrement utile avec des conteneurs comme std::vector. ### Configuration de base de std::sort

La forme la plus simple de std::sort permet de trier tous les éléments d'une plage :

std::vector<int> mesDonnees = {5, 2, 8, 1, 9};
std::sort(mesDonnees.begin(), mesDonnees.end()); // Trie du plus petit au plus grand

Vous pouvez également spécifier une sous-plage à trier :

// Trie les éléments de l'indice m à n-1
std::sort(mesDonnees.begin() + m, mesDonnees.begin() + n);

Pour une documentation plus approfondie, vous pouvez consulter la référence C++ API. ### Personnalisation du tri avec un prédicat

Par défaut, std::sort effectue un tri croissant. Pour modifier ce comportement, par exemple pour obtenir un tri décroissant, ou pour trier des types de données complexes, vous pouvez fournir un troisième argument : une fonction de comparaison (un prédicat). Ce prédicat doit être un objet appelable qui prend deux argumetns du type des éléments de la séquence et retourne true si le premier argument doit précéder le second dans l'ordre trié, et false sinon. Voici un exemple de prédicat pour un tri décroissant d'entiers :

bool comparerCroissant(const int& a, const int& b) {
    return a > b; // Retourne vrai si a est plus grand que b
}

std::vector<int> nombres = {5, 2, 8, 1, 9};
std::sort(nombres.begin(), nombres.end(), comparerCroissant); // Trie du plus grand au plus petit

Cette fonctionnalité s'applique à divers types de séquences stockées dans de la mémoire contiguë, y compris les tableaux C-style et les srtuctures personnalisées. Considérons une structure Point :

struct Point {
    int x;
    int y;
};

Point points[100];

// Prédicat pour trier les Points : d'abord par x décroissant, puis par y décroissant si x est égal
bool comparerPoints(const Point& p1, const Point& p2) {
    if (p1.x != p2.x) {
        return p1.x > p2.x; // Trie par x décroissant
    }
    return p1.y > p2.y; // Si x est égal, trie par y décroissant
}

// Utilisation de std::sort avec un tableau et un prédicat personnalisé
std::sort(points, points + 100, comparerPoints);

Cas d'utilisation spécifiques : Tri des éléments d'une std::map

Les std::map trient leurs éléments par défaut en fonction des clés. Si vous souhaitez trier une collection basée sur les valeurs, vous pouvez extraire les paires clé-valeur dans un std::vector puis utiliser std::sort avec un prédicat adapté. Supposons une std::map associant des chaînes de caractères à des entiers. Pour trier ces paires en fonction de la valeur (entière) en ordre décroissant, et en cas d'égalité des valeurs, trier en fonction de la clé (chaîne) en ordre croissant :

bool comparerPaires(const std::pair<std::string, int>& a, const std::pair<std::string, int>& b) {
    if (a.second != b.second) {
        return a.second > b.second; // Trie par valeur décroissante
    }
    return a.first < b.first; // Si les valeurs sont égales, trie par clé croissante
}

std::map<std::string, int> dataMap;
// ... (remplissage de dataMap) ...

std::vector<std::pair<std::string, int>> dataVector;
for (const auto& pair : dataMap) {
    dataVector.push_back(pair);
}

std::sort(dataVector.begin(), dataVector.end(), comparerPaires);