Les foncteurs (ou objets fonction) sont des composants clés pour personnaliser le comportement des conteneurs standards comme std::priority_queue. Ils permettent de définir des règles de comparaison complexes et efficaces.

Principes fondamentaux d'un foncteur de comparaison

Un foncteur est une classe qui surcharge l'opérateur operator(). Dans le contexte d'une file de priorité, il détermine la relation d'ordre entre les éléments, influençant directement la structure du tas sous-jacent.

Exemple d'implémentation pour un tas min (le plus petit élément en tête) :

struct ComparateurMin {
    bool operator()(int gauche, int droite) const {
        return gauche > droite; // Retourne vrai si gauche doit être enfoui
    }
};

// Déclaration de la file de priorité avec le comparateur personnalisé
std::priority_queue<int, std::vector<int>, ComparateurMin> file_min;

file_min.push(30);
file_min.push(5);
file_min.push(15);

// Accès à l'élément prioritaire (5)
std::cout << file_min.top(); // Affiche: 5

Les foncteurs standards courants sont std::less pour un tas max et std::greater pour un tas min. Tout foncteur utilisé doit respecter un ordre strict faible (strict weak ordering).

Stratégies avancées de conception

Utilisation efficace des références et du const

Pour éviter des copies coûteuses des objets comparés, les paramètres du foncteur devraient typiquement être des références constantes.

struct CompareParId {
    bool operator()(const Entite& a, const Entite& b) const {
        return a.identifiant < b.identifiant;
    }
};

Foncteurs template et techniques de compilation conditionnelle

Les foncteurs peuvent être templatés pour une réutilisation générique. L'utilisation de std::enable_if permet de restreindre les types acceptés au moment de la compilation.

#include <type_traits>

template<typename T>
struct ComparaisonMultiple {
    // Activation conditionnelle: ne compile que pour les types arithmétiques
    auto operator()(const T& a, const T& b) const -> typename std::enable_if<std::is_arithmetic<T>::value, bool>::type {
        return (a % 10) < (b % 10); // Comparaison sur le dernier chiffre
    }
};

Intégration avec les types intelligents et la gestion de la mutabilité

Lorsque la priorité d'un élément peut changer dynamiquement, l'utilisation de std::shared_ptr associée à un foncteur qui accède à la valeur courante est une approche courante.

struct Tache {
    int priorite;
    std::string description;
};

// Le foncteur compare la priorité pointée par le shared_ptr
struct ComparateurPrioriteVariable {
    bool operator()(const std::shared_ptr<Tache>& t1, const std::shared_ptr<Tache>& t2) const {
        return t1->priorite > t2->priorite; // Créé un tas max sur la priorité
    }
};

Optimisation et sélection des approches

Le choix entre foncteurs nommés, fonctions statiques et expressions lambda dépend du contexte :

• Foncteurs nommés : Offrent une réutilisabilité et une lisibilité accrues. Ils peuvent stocker des états configurationnles complexes.
• Fonctions statiques : Légères et sans état, elles bénéficient souvent d'une meilleure optimisation par le compilateur (inlining).
• Expressions Lambda : Concises pour une utilisation locale. Leur état (variables capturées) est moins explicite qu'avec un foncteur à membres nommés.

Exemple de foncteur avec un mode configurable :

struct CompareChaines {
    enum Mode { PAR_LONGUEUR, PAR_LEXICOGRAPHIQUE };
    Mode mode;

    CompareChaines(Mode m) : mode(m) {}

    bool operator()(const std::string& s1, const std::string& s2) const {
        switch(mode) {
            case PAR_LONGUEUR: return s1.length() < s2.length();
            case PAR_LEXICOGRAPHIQUE: return s1 < s2;
            default: return false;
        }
    }
};

Application dans un système d'événements

Les foncteurs se prêtent bien aux modèles de programmation événementielle, où ils peuvent être injectés comme des processeurs configurables.

// Processus d'événement défini comme foncteur
struct TraitementEvenement {
    int& compteur_evenements;
    TraitementEvenement(int& compteur) : compteur_evenements(compteur) {}

    void operator()(const Evenement& evt) {
        if (estEvenementCritique(evt)) {
            traiterCritique(evt);
            ++compteur_evenements;
        }
    }
};

// Utilisation avec un algorithme STL
std::for_each(debutEvenements, finEvenements, TraitementEvenement(nbTraites));

Cette approche encapsule l'état (le compteur) et le logiciel de traitement de manière cohérente, tout en permettant une intégration native avec les algorithmes de la bibliothèque standard.