Discussion :

[Kaluza]

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 :

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

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 :

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

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

[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 ?

[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.

[3DArchi]

Ok, dans ce cas, quelle syntaxe serait correcte ?

Code :

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

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;
}

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

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

Code :

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

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 :

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

double new_function(double,double,double);

Peu de code à modifier :

Code :

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

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 !!

[Kaluza]

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

[gbdivers]

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 :

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

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 ?

[mailaka]

Code :

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

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 ?

[3DArchi]

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.

[yan]

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

[Alp]

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.