Explication sur les foncteurs, problème de syntaxe

Bonjour,

je rôdais sur la FAQ lorsque j'ai vu les foncteurs. J'en ai pas particulièrement besoin je regarde souvent la FAQ pour ma culture personnelle.
Je me suis arrêté sur un petit problème, dans la FAQ ici on définit un objet foncteur de cette manière :

Code:

---

1 2 3 4 5 6 7 8

// Définition du foncteur servant à trier nos objets selon le nombre struct SortByNumber { bool operator ()( const A & a1, const A & a2 ) const { return a1.Number < a2.Number; } };

---

Puis, dans l'exemple ici, l'appel est fait de cette manière :

Code:

---

std::sort(v.begin(), v.end(), SortByNumber());

---

. Dans cette version y'a SortByNumber() les parenthèses.

Un peu plus loin dans le même exemple :

Code:

---

std::set<A, SortByString> s;

---

là y'a plus les parenthèses.

Du coup j'ai pas tout pigé la syntaxe, alors je vais voir un autre exemple sur cplusplus.com ici et là y'a un exemple où ça utilise une fonction comme ça :

Code:

---

sort (myvector.begin()+4, myvector.end(), myfunction)

---

Mais ce n'est pas tout, le second exemple utilise carrément un objet :

Code:

---

sort (myvector.begin(), myvector.end(), myobject);

---

avec myobject étant définit comme suit :

Code:

---

1 2 3

struct myclass { bool operator() (int i,int j) { return (i<j);} } myobject;

---

Alors là je pige pas. Dans la première situation, on ne fait que déclarer un objet SortByNumber et on définit l'opérateur (). On est bien d'accord que il n'existe aucune "instance" de cette structure en mémoire contrairement à myobjet qui lui existe bien en mémoire ?
Enfin bref, parenthèses, pas parenthèses, nom d'objet, nom de structure, ... je suis embrouillé là, j'ai dû oublier un ou deux concepts, pouvez-vous m'éclaircir ?

Un argument foncteur est un objet, quand on le passe a une fonction il a donc une adresse(à la limite un temporaire est créé).
Dans certain de tes exemples l'argument passé est un pointeur vers une fonction libre.

La syntaxe de définition d'une instance est parfois un peu étrange :

Code:

---

1 2 3 4

A a; // Construit un objet de type A en appellant son constructeur par défaut B b(); // Attention !! déclare une fonction b qui renvoit un B par copie C c(3); // Construit un objet de type C en appelant son constructeur qui prend un entier f( A() ); //Appelle f en lui passant un objet de type A créé temporairement avec son constructeur par défaut

---

Pour le passage d'argument
- soit on passe une instance déjà créé plus tôt, (ou alors il s'agit d'un pointeur de fonction libre)

Code:

---

sort (myvector.begin()+4, myvector.end(), myfunction)

---

- soit on créé un temporaire (cela n'est possible que par copie ou référence constante)

Code:

---

std::sort(v.begin(), v.end(), SortByNumber());

---

Citation:

---

Envoyé par MacPro

dans la FAQ ici on définit un objet foncteur de cette manière :

Code:

---

1 2 3 4 5 6 7 8

// Définition du foncteur servant à trier nos objets selon le nombre struct SortByNumber { bool operator ()( const A & a1, const A & a2 ) const { return a1.Number < a2.Number; } };

---

Puis, dans l'exemple ici, l'appel est fait de cette manière :

Code:

---

std::sort(v.begin(), v.end(), SortByNumber());

---

. Dans cette version y'a SortByNumber() les parenthèses.

Un peu plus loin dans le même exemple :

Code:

---

std::set<A, SortByString> s;

---

là y'a plus les parenthèses.

Du coup j'ai pas tout pigé la syntaxe

---

Si j'ai bien suivi, pour cette partie, c'est juste que dans le premier exemple, on utilise le foncteur, et dans le second, on attribue le type SortByString au deuxième paramètre template de la classe std::set

Pas sur de bien t'avoir aidé, ça fait quelques mois que j'ai pas touché à C++, n'hésite pas à dire si je n'ai pas été clair

Salut,

Lorsque l'on décide d'instancier une classe template, il faut que l'on précise... un type pour les différents paramètres template à définir, ou pour préciser les paramètres templates pour lesquels un type par défaut a été spécifié.

C'est pour cela que la syntaxe d'un std::set est

Code:

---

std::set<monType, LessByNum> leset;

---

Par contre, pour sort, il faut passer une instance valide du foncteur.

Il est donc possible de créer cette instance en dehors de la fonction sort, et de le passer à sort, sous une forme proche de

Code:

---

1 2 3

functor f; /*...*/ std::sort(tab.begin(),tab.end(),f);

---

mais, il s'agit alors d'une instance que l'on va se "trainer" sur l'ensemble de la portée dans laquelle il est défini, ce qui est peut être dommage dans le sens où l'on n'en a besoin que... pour la fonction sort.

Je ne dois sans doute pas te rappeler qu'une saine pratique consiste à ne déclarer des variables que pour la durée minimale durant laquelle on en a besoin ;)

Si décide de ne créer une instance que pour la seule durée de l'exécution de sort, il faut donc... appeler explicitement le constructeur du foncteur.

C'est pour cela qu'apparaissent les parenthèses sous la forme de

Code:

---

std::sort<tab.begin(),tab.end(),functor());

---

En effet, sort peut également prendre un pointeur sur fonction, et le fait d'avoir appelé explicitement le constructeur du foncteur permet, outre la détermination automatique du type du foncteur utilisé, d'éviter l'ambiguïté avec éventuel pointeur de fonction.

Enfin, on peut noter le fait que les parenthèses peuvent parfaitement ne pas être vide, s'il s'avère intéressant de fournir un constructeur nécessitant des arguments au foncteur:

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15

struct functor { functor(int i); int i; // i intervient dans la logique de comparaison bool operator()(int a, int b) const { /*...*/ } }; void foo(std::vector<int> & tab, int param) { /* du traitement avant */ std::sort(tab.begin(),tab.end(),functor(param)); /* du traitement après */ }

---

RE-bonjour et merci de ces réponses, il cartonne toujours autant ce forum :ccool:

Je vais répondre aux trois :

@MatRem :
Je connais la syntaxe de définition des instances, les 4 que tu as données en exemple me vont très bien (ouf :mouarf:)
J'avais aussi pigé pour l'histoire du pointeur de fonction libre (j'avais fait un tour du côté des callbacks auparant).
Dans ta réponse donc, pour la chose suivante :

Code:

---

std::sort(v.begin(), v.end(), SortByNumber());

---

Cela semble rejoindre ma première intuition : la structure n'ayant pas de constructeur il lui en est attribué un par défaut et donc SortByNumber() réclame bien la construction d'un objet temporaire qui sera alors passé par référence constante, objet foncteur puisque son operator() est redéfinit. C'est bien ça ?

@Oussapik :
Nope pas très clair, mais l'approche des vacances demain cumulé avec mon endormissement du jour ne m'aide pas :mrgreen:

Code:

---

std::set<A, SortByString> s;

---

Cette ligne semble déclarer un objet template pour les types A et SortByString, ça rejoint ce que tu dis je crois ?!

@koala01
Merci d'abord pour la réponse très détaillée !

Citation:

---

Par contre, pour sort, il faut passer une instance valide du foncteur.

---

<-- Là oui, ça rejoint ce que disait MatRem.
Effectivement, j'ai eu tendance à créer des objets directement dans l'appel de fonctions/méthodes mais ça ne plaisait pas à certains collègues qui ne trouvent pas ça lisible. Perso je trouve ça clair et ça évite de se traîner une variable qui ne sert qu'une ou deux fois.
Ton exemple de code est très clair aussi pour le paramètre que ça fait intervenir, j'allais justement poser la question.


A la base, j'ai eu un doute quant au fait que

Code:

---

std::sort(v.begin(), v.end(), SortByNumber());

---

passé en paramètre appelait non pas le constructeur mais l'opérateur () de SortByNumber. Je me demandais comment cela était possible puisque la "méthode bool operator() /*...*/" n'était pas statique et donc pas moyen de s'y référer. Je m'étais dit que c'était quand même plus clair de l'expliciter de la manière suivante

Code:

---

std::sort(v.begin(), v.end(), SortByNumber.operator());

---

mais là encore, ça aurait été magique puisque ce n'est pas statique(1).
Je suppose donc que le code de la fonction sort se charge d'appeler l'opérator() de l'objet passé en paramètre en lui filant les références vers les objets à trier.


(1) : J'entends la chose suivante par méthode statique de l'operator() si jamais cela était possible mais il me semble pas que ça se fasse avec des opérateurs :

Code:

---

1 2 3 4 5 6 7

struct SortByNumber { static bool operator ()( const A & a1, const A & a2 ) const { return a1.Number < a2.Number; } };

---

et donc dans ce cas

Code:

---

std::sort(v.begin(), v.end(), SortByNumber.operator());

---

pourrait peut-être marcher.

Bref, je laisse ouvert le topic encore un peu avant de le passer en résolu.

Citation:

---

Cela semble rejoindre ma première intuition : la structure n'ayant pas de constructeur il lui en est attribué un par défaut et donc SortByNumber() réclame bien la construction d'un objet temporaire qui sera alors passé par référence constante, objet foncteur puisque son operator() est redéfinit. C'est bien ça ?

---

Tout à fait.

Effectivement le constructeur par défaut est défini par le compilateur tant que tu ne définit aucun constructeur, il ne fait qu'initiliaser les membres avec leur constructeur par défaut.
Un constructeur par copie est définit par le compilateur tant que tu ne définit pas toi même le constructeur par copie.

Citation:

---

std::sort(v.begin(), v.end(), SortByNumber.operator());

---

Sort va utiliser ce que tu lui passes en troisième argument pour appeller l'opérateur () dessus directement (sans aucun déréférencement).

Donc tu ne peux passer à sort que:
- un pointeur de fonction libre, une fonction static est libre;
- une instance de foncteur (une classe qui possède l'operateur ( ... ) non static et le plus souvent const);

Donc ton exemple fonctionnerait à ce ci prêt :
l'operateur () ne peut pas être static ;)

ps : la syntaxe pour l'accès au membre static en c++ c'est C::m contrairement à java.

Citation:

---

Envoyé par MacPro

Code:

---

std::set<A, SortByString> s;

---

Cette ligne semble déclarer un objet template pour les types A et SortByString, ça rejoint ce que tu dis je crois ?!

---

Oui, c'est ça.
Dans cette ligne, il n'est pas question de foncteur mais uniquement de déclarer une variable de type std::set. Or ce type est un type template. L'instanciation du type std::set se fait avec deux autre types (A et SortByString dans ton exemple). Il n'y a donc pas de parenthèse car ce n'est pas le foncteur qui est appelé.

Citation:

---

Envoyé par Oussapik

Oui, c'est ça.
Dans cette ligne, il n'est pas question de foncteur mais uniquement de déclarer une variable de type std::set. Or ce type est un type template. L'instanciation du type std::set se fait avec deux autre types (A et SortByString dans ton exemple). Il n'y a donc pas de parenthèse car ce n'est pas le foncteur qui est appelé.

---

Ni le constructeur, d'ailleurs, étant entendu que c'est le constructeur qui est passé comme troisième paramètre à sort.

Ce que l'on utilise pour la déclaration d'un set, c'est bien exclusivement le type du foncteur qui sera utilisé, et non une quelconque instance de celui-ci.

C'est le compilateur qui se chargera de remplacer le type générique par le type du foncteur partout où c'est nécessaire ;) (entre autre, en appelant le constructeur de celui-ci en cas de besoin)

Citation:

---

Envoyé par MatRem

Donc ton exemple fonctionnerait à ce ci prêt :
l'operateur () ne peut pas être static ;)

---

Yep, c'est pour ça que je buggait et que j'ai précisé

Citation:

---

(1) : J'entends la chose suivante par méthode statique de l'operator() si jamais cela était possible mais il me semble pas que ça se fasse avec des opérateurs :

---

Bon hé bien ce sujet me semble clos, tout est dit je pense. Merci les gars et à bientôt.