Discussion :

[khaledmoez]

bonjour ,je debute avec les foncteurs ; je voudrais en construire un qui prend deux valeurs x et y et qui permet de verifier si un entier est compris entre ces deux valeurs.merci

[koala01]

Salut, et bienvenue sur le forum.

En fait, il me semble peut être intéressant de commencer par expliquer ce qu'est un foncteur...:

Il s'agit, ni plus ni moins, d'un type d'objet (donc, nous pouvons parler aussi bien de structure que de classe) qui va agir comme s'il s'agissait d'une fonction.

Or, ce qui permet au langage de comprendre qu'il a affaire à une fonction, ce n'est, ni plus ni moins, qu'une paire de parenthèses "(" et ")".

En plus de cela, il faut savoir qu'il existe, justement, un opérateur "()" que l'on peut décider de définir pour n'importe quelle structure (ou classe) de notre cru.

Un opérateur se définit exactement comme n'importe quelle autre fonction de ton cru, à ceci près que le nom de la fonction sera d'office "operator" suivi du symbole que tu souhaite utiliser.

il "suffit" donc, comme pour toute définition de fonction, d'indiquer un type de retour, suivi du nom de la fonction que l'on souhaite définir (ici, il s'agira de operator () )suivi enfin de la liste des arguments, séparés par une virgule, que l'on doit passer à la fonction entre parenthèses

Au final, la définition d'un foncteur prendra donc une forme proche de

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
struct MonFoncteur // on pourrait utiliser class, mais il faudra alors penser
                   // que la visibilité par défaut d'une classe est... private:
{
    type_de_retour operator() (/* listes d'arguments */) const
    {
        /* ce qui doit être fait */
    }
};

Le mot clé const qui suit la liste d'arguments indique que la fonction s'engage à ne pas modifier l'objet (de type MonFoncteur) en cours, ce qui sera, normalement, quasiment toujours le cas, et permet d'utiliser le foncteur dans un contexte de constance (car seules les fonctions membres constantes peuvent être appelées sur un objet constant)

Il est éventuellement possible, si tu souhaites pouvoir adapter "facilement" le foncteur avec les différents algorithmes de la STL, de le faire hériter de std::unary_function ou de std::binary_function.

Au final, l'implémentation "simple" du foncteur que tu souhaites créer sera proche de

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
struct InInterval
{
    /* le constructeur, nécessaire pour pouvoir avoir la
     * valeur à tester
     */
    InInterval(int test):test_(test){}
    bool operator()(int min, int max)
    {
        return test>min && test_<max;
    }
    private:
        int test_;
};

et pourrait être utilisé sous une forme proche de

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
 
void test(int min, int max)
{
    /* soit tab est un std::vector<int> contenant différentes valeurs à tester
     */
    for(size_t i=0;i<tab.size();++i)
        std::cout<<std::boolalpha<< InInterval(tab[i])(min,max)<<std::endl;
}

où la première paire de parenthèse représente le constructeur de l'objet de type InInterval et la seconde représente l'appel à l'opérateur ()