[Débutant] Fonction membre et handler

Version imprimable

Bonsoir,
Je m'exprimerais mieux en vous donnant le code qu'en formulant des phrases en Français, donc voici le code :
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 std::string chaine_calculee = ....; void appele_fonction(void (*fonction)(string)) { fonction(chaine_calculee); } class Test { .... void traite_les_infos (std::string les_infos) { Affiche les informations } void fonction_beta() { appele_fonction( traite_les_infos); } }; Test t(); t.fonction_beta();
Seulement là il me sort une erreur car il attend une fonction et non une méthode membre d'une classe. Comment contourner ce problème au niveau de la classe ?

Je vous remercie.

14/01/2007, 12h41
JolyLoic

Pour accéder à la fonction globale qui est cachée par une fonction membre de ta classe, tu peux indiquer son "chemin d'accès" depuis le namespace global. Ici, ça veut dire ::appele_fonction mais si elle était dans le namespace toto, tu aurais pu écrire toto::appele_fonction ou ::toto::appele_fonction.
14/01/2007, 17h25
Laurent Gomila

Le type de ta fonction membre est void (Test::*fonction)(string), c'est incompatible avec le paramètre que tu attends.

Tu peux utiliser boost.function et boost.bind pour faire quelque chose de générique, ou encore les équivalents dans la bibliothèque standard si tu ne veux pas de boost.

Je vous remercie pour vos réponses.
Est ce que ceci serait une bonne solution ?
util.h

Code:

1
2
3
4
5
6
7
8
9
10
 
void appele_fonction_n(int n, void (*fonction)(string))
{
   string chaine_calculee;
   for(int i=0; i<n; i++)
   {
      chaine_calculee = "calcul_en_fonction_de_n";
      fonction(chaine_calculee);
   }
}

Test.h

Code:

1
2
3
4
5
6
7
8
9
10
class Test {
private:
      int n_call;
      string results*;
public:
      Test();
      void fonction_beta();
      friend void traite_les_infos (string les_infos);
};

Test.cpp

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
 
#include "Test.h"
#include "util.h"
Test* global;
Test::Test(int c)
{
   n_call = c;
   results = new string[n_call];
   global = this;
}
void traite_les_infos (string les_infos)
{
     static int cpt=0;
     global->results[cpt++] = les_infos;
}
void Test::fonction_beta() 
{
     appele_fonction_n(n_call, traite_les_infos);
}

main.cpp

Code:

1
2
3
4
5
6
7
8
 
#include "Test.h'
int main()
{
     Test t();
     t.fonction_beta();
     return 0;
}

21/01/2007, 03h46
loufoque

Citation:

string results*;

J'imagine que tu voulais écrire string *results; ?

C'est mauvais, et ceci pour plusieurs raisons.
- Ton pointeur global qui n'est initialisé qu'à la construction d'un Test c'est inutile et dangereux. Ce n'est rien de plus qu'un hack.
- T'as une fuite mémoire
- T'utilises pas les initaliseurs des constructeurs
- T'arrêtes pas de faire des copies de chaîne pour rien
- Deux types de bonnes solutions t'ont été données (fixer le type pour une fonction membre d'une classe particulière ou utiliser des foncteurs polymorphiques) et tu n'en as appliqué aucune. Il y en a aussi une troisième qui est bonne et qui utilise des templates, ce qui te permet d'avoir encore plus de flexibilité que les foncteurs polymorphiques tout en ayant de meilleures performances mais ne permet pas un type unique et a d'autres désavantages propres à l'utilisation de templates.
21/01/2007, 04h23
peaceinpal

Je te remercie pour ta réponse.

En fait, sur le terrain j'ai mofifié le type de pointeur sur fonction qu'attend en entrée ma méthode appele_fonction_n, en m'inspirant de la remarque Laurent Gomila (2 ème post).

Seulement je me demandais que faire dans le cas suivant :
Supposons que ma fonction appel_fonction_n appartienne à une librairie qui serait appelée par des programmes autres que les miens, et peut être même des programmes C. La solution des espaces de nom est donc non générique.
Ta solution de template est tout aussi intéressante mais ma fonction ne pourra être invoquée que par du code C++.
Pour mieux comprendre mon "souci", suppose que la fonction en question soit une fonction C, par exemple la fonction de gestion de signaux "signal" à laquelle il faut passer un handler qui sera appelé à chaque réception d'un certain signal. Mon but serait donc par exemple de passer dans "signal" une méthode de classe.
Puis je eviter de passer par boost ? D'ailleurs que fait boost quand j'appèle bind ou function ?
Suis-je contraint de hacker dans ce cas là car je mixe du C et du C++ ?

Merci.
21/01/2007, 05h25
loufoque

Citation:

Supposons que ma fonction appel_fonction_n appartienne à une librairie qui serait appelée par des programmes autres que les miens, et peut être même des programmes C. La solution des espaces de nom est donc non générique.

C'est pour ça qu'il y a les deux autres possibilités.

Citation:

Ta solution de template est tout aussi intéressante mais ma fonction ne pourra être invoquée que par du code C++.

Pouvoir être invoquée par du code C est un tout autre problème. Le meilleur moyen est probablement de faire une fonction à part qui enrobe la fonction principale pour le cas spécial du C.

De toutes manières, si tu veux faire une interface C, il faut que tous les paramètres soient en C.
Ça impose des limitations évidentes.

Soit tu fais une interface C, qui sera mauvaise du point de vue du C++, soit tu fais une interface C++, inutilisable en C.

Dans le cas de l'interface C, généralement on permet un argument additionnel de type void* pour permettre à la fonction de conserver des informations (comme ici, ton instance de Test).

Citation:

En fait, sur le terrain j'ai mofifié le type de pointeur sur fonction qu'attend en entrée ma méthode appele_fonction_n, en m'inspirant de la remarque Laurent Gomila (2 ème post).

Je me demande si tu as vraiment bien fait cela.
Il te faut aussi un objet en plus de ce pointeur de fonction.

Citation:

Puis je eviter de passer par boost ?

Si tu veux réecrire de manière moins génériques les composants de boost, libre à toi.

Citation:

D'ailleurs que fait boost quand j'appèle bind ou function ?

Ces composants ne sont pas uniquement dans boost mais aussi dans TR1 et dans le prochain standard C++.
bind est un outil assez puissant pour créer facilement des foncteurs à partir d'autres foncteurs ou fonctions, en fournissant par exemples objets ou paramètres.
function est un foncteur polymorphique, qui peut donc contenir n'importe quel type de foncteur du moment qu'il répond à une signature donnée. Cela empêche du coup la surcharge et la généricité du foncteur.