[C++] Pointeur sur fonction ou foncteur ?

Version imprimable

Bonjour à tous ;).

Je n'ai jamais utilisé de pointeur sur fonction ou de foncteur, seulement je vais en avoir besoin. J'ai lu que les foncteurs étaient bien plus rapides dans la plupart des cas, sauf que les pointeurs sur fonction ont l'air bien plus simple à implémenter et dans mon cas je ne sais pas si cela ferait une vraie différence au niveau du temps d'exécution.

J'ai une classe Ncomputation avec entre autres 3 fonctions membres
Code:

1 2 3 double Ncomputation::f220(double a,double b,double c) const; double Ncomputation::f022(double a,double b,double c) const; double Ncomputation::f220(double a,double b,double c) const;
Dans une autre fonction membre j'ai besoin de choisir quelle fonction membre j'utilise en fonction d'un paramètre.
A première vue, je pensais utiliser :
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 double Ncomputation::calc(unsigned int axis) const { // Initialization double result=0.; double(*f)(double,double,double)=f220; // Select the function switch(axis) { case 1 : f=f022; break; case 2 : f=f202; break; case 3 : f=f220; break; default : f=f220; } // (Ici j'utilise f pour calculer le résultat) // (Ici j'utilise f pour calculer le résultat) // Return return result; }
Déjà est-ce que ma syntaxe d'utilisation d'un pointeur sur fonction est bonne ? Ensuite est-ce que l'utilisation de foncteur aurait un réel intérêt dans mon cas (notamment au niveau du gain de performances) ou absolument aucun (et si oui, pourquoi ?)).

Merci beaucoup :ccool:

13/03/2010, 19h52
Joel F

Attention, un pointeur sur fonction membre n'a pas la meme signature qu'un pointeur de fonction.
Et la pourquoi n'ecris tu pas simplement un appel au f220 et consoeurs qui sont des membres de ta classe ?
13/03/2010, 20h15
Kaluza

Ok, dans ce cas, quelle syntaxe serait correcte ?

Si je pouvais faire un appel "unifié" à f220 et consoeurs en fait ça m'arrangerait bien (ce pourquoi je désire utiliser un pointeur sur fonction membre), parce qu'ensuite ma fonction f (qui est égale soit à f220, f022 ou f202) est impliquée dans des calculs "biens bourrins".

Merci beaucoup.

Citation:

Envoyé par Kaluza

Ok, dans ce cas, quelle syntaxe serait correcte ?

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
double Ncomputation::calc(unsigned int axis) const
{
    // Initialization
    double result=0.;
    double (Ncomputation::*f)(double,double,double)const=&Ncomputation::f220;
 
    // Select the function
    switch(axis)
    {
        case 1 : f=&Ncomputation::f022; break;
        case 2 : f=&Ncomputation::f202; break;
        case 3 : f=&Ncomputation::f220; break;
        default : f=&Ncomputation::f220;
    }
 
    // (Ici j'utilise f pour calculer le résultat)
    (this->*f)(1.,2.,3.);
    // (Ici j'utilise f pour calculer le résultat)
 
    // Return
    return result;
}

Citation:

Envoyé par Kaluza

J'ai lu que les foncteurs étaient bien plus rapides dans la plupart des cas

:koi:

L'avantage des foncteurs c'est qu'en étant plus générique ils facilitent l'évolution.

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
 
stuct Ncomputation
{ 
/* [...] */
template<class foncteur_t_>
double calcul_effectif(foncteur_t_ f_)const
{
    return f_(1.,2.,3.);
}
 
double Ncomputation::calc(unsigned int axis) const
{
    // Initialization
    double result=0.;
    double (Ncomputation::*f)(double,double,double)const=&Ncomputation::f220;
 
    // Select the function
    switch(axis)
    {
        case 1 : f=&Ncomputation::f022; break;
        case 2 : f=&Ncomputation::f202; break;
        case 3 : f=&Ncomputation::f220; break;
        default : f=&Ncomputation::f220;
    }
 
    return calcul_effectif(boost::bind(f,this,_1,_2,_3));
}

Puis un beau jour, apparait :

Code:

double new_function(double,double,double);

Peu de code à modifier :

Code:

1
2
3
4
5
6
    Ncomputation a;
    a.calc(1);
    a.calc(2);
    a.calc(3);
    a.calc(17);
    a.calcul_effectif(new_function);// Ca marche avec une nouvelle fonction !!

13/03/2010, 21h11
Kaluza

Merci mille fois pour cette réponse très détaillée :ccool:
Tout est bcp plus clair maintenant !!!

Bonjour

Je me permet de m'incruster dans ce post pour poser une question concernant ce problème (je ne suis pas spécialiste de la méta programmation)

Dans un tel cas (fonction appelée plusieurs fois dans un gros calcul, nombre de fonctions possible limitées et connues à la compilation), n'est-il pas préférable d'inliner la fonction appelée (en forçant l'inline ?) pour éviter l'appel de fonction et en utilisant les templates pour éviter de devoir réécrire plusieurs fois le même code ?
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 struct F022 { inline double f(double a,double b,double c) const; } struct F220 { inline double f(double a,double b,double c) const; } struct F202 { inline double f(double a,double b,double c) const; } template <typename F> double calc(unsigned int axis) const { // on réalise le calcul en utilisant F::f() } typedef calc<F022> calc022; typedef calc<F202> calc202; typedef calc<F220> calc220;
Peut-on gagner en rapidité avec un tel code en cas de nombreux appels à la fonction ?

Citation:

Envoyé par 3DArchi

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
 
stuct Ncomputation
{ 
/* [...] */
template<class foncteur_t_>
double calcul_effectif(foncteur_t_ f_)const
{
    return f_(1.,2.,3.);
}
 
double Ncomputation::calc(unsigned int axis) const
{
    // Initialization
    double result=0.;
    double (Ncomputation::*f)(double,double,double)const=&Ncomputation::f220;
 
    // Select the function
    switch(axis)
    {
        case 1 : f=&Ncomputation::f022; break;
        case 2 : f=&Ncomputation::f202; break;
        case 3 : f=&Ncomputation::f220; break;
        default : f=&Ncomputation::f220;
    }
 
    return calcul_effectif(boost::bind(f,this,_1,_2,_3));
}

Salut. Pourquoi as-tu ceci ? Pourrais-tu elaborer sur cet appel de boost::bind ? Particulierement ce this ?

19/03/2010, 19h23
3DArchi

Citation:

Envoyé par mailaka

Salut. Pourquoi as-tu ceci ? Pourrais-tu elaborer sur cet appel de boost::bind ? Particulierement ce this ?

Tes fonctions sont des fonctions membres de la classe. Elles ont donc besoin d'un objet de ta classe pour être appelées. Avec boost::bind on construit un foncteur dont le premier argument, l'instance de la classe, est 'lié' au moment de la construction avec this. Ensuite, on peut l'utiliser comme une fonction avec 3 arguments double uniquement.
22/03/2010, 10h28
mailaka

Citation:

Envoyé par 3DArchi

Tes fonctions sont des fonctions membres de la classe. Elles ont donc besoin d'un objet de ta classe pour être appelées. Avec boost::bind on construit un foncteur dont le premier argument, l'instance de la classe, est 'lié' au moment de la construction avec this. Ensuite, on peut l'utiliser comme une fonction avec 3 arguments double uniquement.

Merci. Sur les exemples que j'ai pu voir, les fonctions n'etaient pas des fonctions membres donc pas de specification particuliere pour this. Se retrouve-t-on dans ce cas si la fonction membre etait statique, a priori pas besoin de this ?
22/03/2010, 16h07
3DArchi

Salut,
Dans l'exemple que j'avais proposé, on avait besoin d'un this car f022, f202 et f220 étaient des fonctions membres non statiques de Ncomputation. Si tes fonctions sont des fonctions statiques ou des fonctions libres, alors effectivement tu n'as pas besoin de lier le 'this'.
bind permet de lier d'autres arguments. Si ta fonction accepte plus d'arguments que celle du foncteur que tu veux créer, et si tu connais les arguments au moment de la construction de ton foncteur, et éventuellement si l'ordre n'est pas le même, boost.bind te permet de construire un foncteur qui présentera la signature que tu souhaites.
22/03/2010, 16h09
3DArchi

Citation:

Envoyé par gbdivers

[...]

Je pense que son problème est de choisir la fonction à l'exécution et non sur un paramètre connu à la compilation. S'il s'agit bien d'un dynamisme à l'exécution, inline et template n'apporteront pas d'optimisation particulière sur le choix spécifique de la fonction.
22/03/2010, 16h32
yan

Citation:

Envoyé par 3DArchi

:koi:

L'avantage des foncteurs c'est qu'en étant plus générique ils facilitent l'évolution.

Il permet aussi au compilateur de faire des optimisation. Par exemple inliné le tous et ne plus avoir d'appel de fonction.

C'est ce qui explique la différence entre qsort et std::sort+foncteur.
http://www.tilander.org/aurora/2007/...and-qsort.html
23/03/2010, 01h52
Alp

Citation:

Envoyé par yan

Il permet aussi au compilateur de faire des optimisation. Par exemple inliné le tous et ne plus avoir d'appel de fonction.

C'est ce qui explique la différence entre qsort et std::sort+foncteur.
http://www.tilander.org/aurora/2007/...and-qsort.html

Et encore en plus de cela, un foncteur peut garder et maintenir un état suite à plusieurs appels à son operator(), sans se trimballer une variable globale ou ce genre de pourriture.