• Abstaction des fonctions : les foncteurs

    13.5. Abstraction des fonctions : les foncteurs

    La plupart des algorithmes de la bibliothèque standard, ainsi que quelques méthodes des classes qu'elle fournit, donnent la possibilité à l'utilisateur d'appliquer une fonction aux données manipulées. Ces fonctions peuvent être utilisées pour différentes tâches, comme pour comparer deux objets par exemple, ou tout simplement pour en modifier la valeur.

    Cependant, la bibliothèque standard n'utilise pas ces fonctions directement, mais a plutôt recours à une abstraction des fonctions : les foncteurs. Un foncteur n'est rien d'autre qu'un objet dont la classe définit l'opérateur fonctionnel '()'. Les foncteurs ont la particularité de pouvoir être utilisés exactement comme des fonctions puisqu'il est possible de leur appliquer leur opérateur fonctionnel selon une écriture similaire à un appel de fonction. Cependant, ils sont un peu plus puissants que de simples fonctions, car ils permettent de transporter, en plus du code de l'opérateur fonctionnel, des paramètres additionnels dans leurs données membres. Les foncteurs constituent donc une fonctionnalité extrêmement puissante qui peut être très pratique en de nombreux endroits. En fait, comme on le verra plus loin, toute fonction peut être transformée en foncteur. Les algorithmes de la bibliothèque standard peuvent donc également être utilisés avec des fonctions classiques moyennant cette petite transformation.

    Les algorithmes de la bibliothèque standard qui utilisent des foncteurs sont déclarés avec un paramètre template dont la valeur sera celle du foncteur permettant de réaliser l'opération à appliquer sur les données en cours de traitement. Au sein de ces algorithmes, les foncteurs sont utilisés comme de simples fonctions, et la bibliothèque standard ne fait donc pas d'autre hypothèse sur leur nature. Cependant, il est nécessaire de ne donner que des foncteurs en paramètres aux algorithmes de la bibliothèque standard, pas des fonctions. C'est pour cette raison que la bibliothèque standard définit un certain nombre de foncteurs standards afin de faciliter la tâche du programmeur.

    13.5.1. Foncteurs prédéfinis

    La bibliothèque n'utilise, dans ses algorithmes, que des foncteurs qui ne prennent qu'un ou deux paramètres. Les foncteurs qui prennent un paramètre et un seul sont dits « unaires », alors que les foncteurs qui prennent deux paramètres sont qualifiés de « binaires ». Afin de faciliter la création de foncteurs utilisables avec ses algorithmes, la bibliothèque standard définit deux classes de base qui pour les foncteurs unaires et binaires. Ces classes de base sont les suivantes :

    template <class Arg, class Result>
    struct unary_function
    {
    typedef Arg argument_type;
    typedef Result result_type;
    };

    template <class Arg1, class Arg2, class Result>
    struct binary_function
    {
    typedef Arg1 first_argument_type;
    typedef Arg2 second_argument_type;
    typedef Result result_type;
    };
    Ces classes sont définies dans l'en-tête functional.

    La bibliothèque définit également un certain nombre de foncteurs standards qui encapsulent les opérateurs du langage dans cet en-tête. Ces foncteurs sont les suivants :

    template <class T>
    struct plus : binary_function<T, T, T>
    {
    T operator()(const T &operande1, const T &operande2) const;
    };

    template <class T>
    struct minus : binary_function<T, T, T>
    {
    T operator()(const T &operande1, const T &operande2) const;
    };

    template <class T>
    struct multiplies : binary_function<T, T, T>
    {
    T operator()(const T &operande1, const T &operande2) const;
    };

    template <class T>
    struct divides : binary_function<T, T, T>
    {
    T operator()(const T &operande1, const T &operande2) const;
    };

    template <class T>
    struct modulus : binary_function<T, T, T>
    {
    T operator()(const T &operande1, const T &operande2) const;
    };

    template <class T>
    struct negate : unary_function<T, T>
    {
    T operator()(const T &operande) const;
    };

    template <class T>
    struct equal_to : binary_function<T, T, bool>
    {
    bool operator()(const T &operande1, const T &operande2) const;
    };

    template <class T>
    struct not_equal_to : binary_function<T, T, bool>
    {
    bool operator()(const T &operande1, const T &operande2) const;
    };

    template <class T>
    struct greater : binary_function<T, T, bool>
    {
    bool operator()(const T &operande1, const T &operande2) const;
    };

    template <class T>
    struct less : binary_function<T, T, bool>
    {
    bool operator()(const T &operande1, const T &operande2) const;
    };

    template <class T>
    struct greater_equal : binary_function<T, T, bool>
    {
    bool operator()(const T &operande1, const T &operande2) const;
    };

    template <class T>
    struct less_equal : binary_function<T, T, bool>
    {
    bool operator()(const T &operande1, const T &operande2) const;
    };
    Ces foncteurs permettent d'utiliser les principaux opérateurs du langage comme des fonctions classiques dans les algorithmes de la bibliothèque standard.

    Exemple 13-6. Utilisation des foncteurs prédéfinis

    #include <iostream>
    #include <functional>

    using namespace std;

    // Fonction template prenant en paramètre deux valeurs
    // et un foncteur :
    template <class T, class F>
    T applique(T i, T j, F foncteur)
    {
    // Applique l'opérateur fonctionnel au foncteur
    // avec comme arguments les deux premiers paramètres :
    return foncteur(i, j);
    }

    int main(void)
    {
    // Construit le foncteur de somme :
    plus<int> foncteur_plus;
    // Utilise ce foncteur pour faire faire une addition
    // à la fonction "applique" :
    cout << applique(2, 3, foncteur_plus) << endl;
    return 0;
    }

    Dans l'exemple précédent, la fonction template applique prend en troisième paramètre un foncteur et l'utilise pour réaliser l'opération à faire avec les deux premiers paramètres. Cette fonction ne peut théoriquement être utilisée qu'avec des objets disposant d'un opérateur fonctionnel '()', et pas avec des fonctions normales. La bibliothèque standard fournit donc les adaptateurs suivants, qui permettent de convertir respectivement n'importe quelle fonction unaire ou binaire en foncteur :

    template <class Arg, class Result>
    class pointer_to_unary_function :
    public unary_function<Arg, Result>
    {
    public:
    explicit pointer_to_unary_function(Result (*fonction)(Arg));
    Result operator()(Arg argument1) const;
    };

    template <class Arg1, Arg2, Result>
    class pointer_to_binary_function :
    public binary_function<Arg1, Arg2, Result>
    {
    public:
    explicit pointer_to_binary_function(Result (*fonction)(Arg1, Arg2));
    Result operator()(Arg1 argument1, Arg2 argument2) const;
    };

    template <class Arg, class Result>
    pointer_to_unary_function<Arg, Result>
    ptr_fun(Result (*fonction)(Arg));

    template <class Arg, class Result>
    pointer_to_binary_function<Arg1, Arg2, Result>
    ptr_fun(Result (*fonction)(Arg1, Arg2));
    Les deux surcharges de la fonction template ptr_fun permettent de faciliter la construction d'un foncteur unaire ou binaire à partir du pointeur d'une fonction du même type.

    Exemple 13-7. Adaptateurs de fonctions

    #include <iostream>
    #include <functional>

    using namespace std;

    template <class T, class F>
    T applique(T i, T j, F foncteur)
    {
    return foncteur(i, j);
    }

    // Fonction classique effectuant une multiplication :
    int mul(int i, int j)
    {
    return i * j;
    }

    int main(void)
    {
    // Utilise un adaptateur pour transformer le pointeur
    // sur la fonction mul en foncteur :
    cout << applique(2, 3, ptr_fun(&mul)) << endl;
    return 0;
    }

    Note : En réalité le langage C++ est capable d'appeler une fonction directement à partir de son adresse, sans déréférencement. De plus le nom d'une fonction représente toujours sont adresse, et est donc converti implicitement par le compilateur en pointeur de fonction. Par conséquent, il est tout à fait possible d'utiliser la fonction template applique avec une autre fonction à deux paramètres, comme dans l'appel suivant :

    applique(2, 3, mul);
    Cependant, cette écriture provoque la conversion implicite de l'identificateur mul en pointeur de fonction prenant deux entiers en paramètres et renvoyant un entier, d'une part, et l'appel de la fonction mul par l'intermédiaire de son pointeur sans déréférencement dans la fonction template applique d'autre part. Cette écriture est donc acceptée par le compilateur par tolérance, mais n'est pas rigoureusement exacte.

    La bibliothèque standard C++ définit également des adaptateurs pour les pointeurs de méthodes non statiques de classes. Ces adaptateurs se construisent comme les adaptateurs de fonctions statiques classiques, à ceci près que leur constructeur prend un pointeur de méthode de classe et non un pointeur de fonction normale. Ils sont déclarés de la manière suivante dans l'en-tête functional :

    template <class Result, class Class>
    class mem_fun_t :
    public unary_function<Class *, Result>
    {
    public:
    explicit mem_fun_t(Result (Class::*methode)());
    Result operator()(Class *pObjet);
    };

    template <class Result, class Class, class Arg>
    class mem_fun1_t :
    public binary_function<Class *, Arg, Result>
    {
    public:
    explicit mem_fun1_t(Result (Class::*methode)(Arg));
    Result operator()(Class *pObjet, Arg argument);
    };

    template <class Result, class Class>
    class mem_fun_ref_t :
    public unary_function<Class, Result>
    {
    public:
    explicit mem_fun_ref_t(Result (Class::*methode)());
    Result operator()(Class &objet);
    };

    template <class Result, class Class, class Arg>
    class mem_fun1_ref_t :
    public binary_function<Class, Arg, Result>
    {
    public:
    explicit mem_fun1_ref_t(Result (Class::*methode)(Arg));
    Result operator()(Class &objet, Arg argument);
    };

    template <class Result, class Class>
    mem_fun_t<Result, Class> mem_fun(Result (Class::*methode)());

    template <class Result, class Class, class Arg>
    mem_fun1_t<Result, Class> mem_fun(Result (Class::*methode)(Arg));

    template <class Result, class Class>
    mem_fun_ref_t<Result, Class> mem_fun_ref(Result (Class::*methode)());

    template <class Result, class Class, class Arg>
    mem_fun1_ref_t<Result, Class>
    mem_fun_ref(Result (Class::*methode)(Arg));

    Comme vous pouvez le constater d'après leurs déclarations les opérateurs fonctionnels de ces adaptateurs prennent en premier paramètre soit un pointeur sur l'objet sur lequel le foncteur doit travailler (adaptateurs mem_fun_t et mem_fun1_t), soit une référence sur cet objet (adaptateurs mem_fun_ref_t et mem_fun1_ref_t). Le premier paramètre de ces foncteurs est donc réservé pour l'objet sur lequel la méthode encapsulée doit être appelée.

    En fait, la liste des adaptateurs présentée ci-dessus n'est pas exhaustive. En effet, chaque adaptateur présenté est doublé d'un autre adaptateur, capable de convertir les fonctions membres const. Il existe donc huit adaptateurs au total permettant de construire des foncteurs à partir des fonctions membres de classes. Pour diminuer cette complexité, la bibliothèque standard définit plusieurs surcharges pour les fonctions mem_fun et mem_fun_ref, qui permettent de construire tous ces foncteurs plus facilement, sans avoir à se soucier de la nature des pointeurs de fonction membre utilisés. Il est fortement recommandé de les utiliser plutôt que de chercher à construire ces objets manuellement.

    13.5.2. Prédicats et foncteurs d'opérateurs logiques

    Les foncteurs qui peuvent être utilisés dans une expression logique constituent une classe particulière : les prédicats. Un prédicat est un foncteur dont l'opérateur fonctionnel renvoie un booléen. Les prédicats ont donc un sens logique, et caractérisent une propriété qui ne peut être que vraie ou fausse.

    La bibliothèque standard fournit des prédicats prédéfinis qui effectuent les opérations logiques des opérateurs logiques de base du langage. Ces prédicats sont également déclarés dans l'en-tête functional :

    template <class T>
    struct logical_and :
    binary_function<T, T, bool>
    {
    bool operator()(const T &operande1, const T &operande2) const;
    };

    template <class T>
    struct logical_or :
    binary_function<T, T, bool>
    {
    bool operator()(const T &operande1, const T &operande2) const;
    };
    Ces foncteurs fonctionnent exactement comme les foncteurs vus dans la section précédente.

    La bibliothèque standard définit aussi deux foncteurs particuliers, qui permettent d'effectuer la négation d'un autre prédicat. Ces deux foncteurs travaillent respectivement sur les prédicats unaires et sur les prédicats binaires :

    template <class Predicate>
    class unary_negate :
    public unary_function<typename Predicate::argument_type, bool>
    {
    public:
    explicit unary_negate(const Predicate &predicat);
    bool operator()(const argument_type &argument) const;
    };

    template <class Predicate>
    class binary_negate :
    public binary_function<typename Predicate::first_argument_type,
    typename Predicate::second_argument_type, bool>
    {
    public:
    explicit binary_negate(const Predicate &predicat);
    bool operator()(const first_argument_type &argument1,
    const second_argument_type &argument2) const;
    };

    template <class Predicate>
    unary_negate<Predicate> not1(const Predicate &predicat);

    template <class Predicate>
    binary_negate<Predicate> not2(const Predicate &predicat);
    Les fonctions not1 et not2 servent à faciliter la construction d'un prédicat inverse pour les prédicats unaires et binaires.

    13.5.3. Foncteurs réducteurs

    Nous avons vu que la bibliothèque standard ne travaillait qu'avec des foncteurs prenant au plus deux arguments. Certains algorithmes n'utilisant que des foncteurs unaires, ils ne sont normalement pas capables de travailler avec les foncteurs binaires. Toutefois, si un des paramètres d'un foncteur binaire est fixé à une valeur donnée, celui-ci devient unaire, puisque seul le deuxième paramètre peut varier. Il est donc possible d'utiliser des foncteurs binaires même avec des algorithmes qui n'utilisent que des foncteurs unaires, à la condition de fixer l'un des paramètres.

    La bibliothèque standard définit des foncteurs spéciaux qui permettent de transformer tout foncteur binaire en foncteur unaire à partir de la valeur de l'un des paramètres. Ces foncteurs effectuent une opération dite de réduction car ils réduisent le nombre de paramètres du foncteur binaire à un. Pour cela, ils définissent un opérateur fonctionnel à un argument, qui applique l'opérateur fonctionnel du foncteur binaire à cet argument et à une valeur fixe qu'ils mémorisent en donnée membre.

    Ces foncteurs réducteurs sont déclarés, comme les autres foncteurs, dans l'en-tête fonctional :

    template <class Operation>
    class binder1st :
    public unary_function<typename Operation::second_argument_type,
    typename Operation::result_type>
    {
    protected:
    Operation op;
    typename Operation::first_argument_type value;
    public:
    binder1st(const Operation &foncteur,
    const typename Operation::first_argument_type &valeur);
    result_type operator()(const argument_type &variable) const;
    };

    template <class Operation>
    class binder2nd :
    public unary_function<typename Operation::first_argument_type,
    typename Operation::result_type>
    {
    protected:
    Operation op;
    typename Operation::second_argument_type value;
    public:
    binder2nd(const Operation &foncteur,
    const typename Operation::second_argument_type &valeur);
    result_type operator()(const argument_type &variable) const;
    };

    template <class Operation, class T>
    binder1st<Operation> bind1st(const Operation &foncteur, const T &valeur);

    template <class Operation, class T>
    binder2nd<Operation> bind2nd(const Operation &foncteur, const T &valeur);

    Il existe deux jeux de réducteurs, qui permettent de réduire les foncteurs binaires en fixant respectivement leur premier ou leur deuxième paramètre. Les réducteurs qui figent le premier paramètre peuvent être construits à l'aide de la fonction template bind1st, et ceux qui figent la valeur du deuxième paramètre peuvent l'être à l'aide de la fonction bind2nd.

    Exemple 13-8. Réduction de foncteurs binaires

    #include <iostream>
    #include <functional>

    using namespace std;

    // Fonction template permettant d'appliquer une valeur
    // à un foncteur unaire. Cette fonction ne peut pas
    // être utilisée avec un foncteur binaire.
    template <class Foncteur>
    typename Foncteur::result_type applique(
    Foncteur f,
    typename Foncteur::argument_type valeur)
    {
    return f(valeur);
    }

    int main(void)
    {
    // Construit un foncteur binaire d'addition d'entiers :
    plus<int> plus_binaire;
    int i;
    for (i = 0; i < 10; ++i)
    {
    // Réduit le foncteur plus_binaire en fixant son
    // premier paramètre à 35. Le foncteur unaire obtenu
    // est ensuite utilisé avec la fonction applique :
    cout << applique(bind1st(plus_binaire, 35), i) << endl;
    }
    return 0;
    }

  • Commentaires

    Aucun commentaire pour le moment

    Suivre le flux RSS des commentaires


    Ajouter un commentaire

    Nom / Pseudo :

    E-mail (facultatif) :

    Site Web (facultatif) :

    Commentaire :