Discussion :

[Traxsilver]

Bonjour,

Je voudrais créer une planificateur de tache pour cela j'ai imaginé une classe qui vérifie l'heure toutes les 30 secondes, et qui comporte des objets event composé d'une chaine de caractère l'heure, et d'un pointeur de fonction sur la fonction a lancé a telle heure, mais j'arrive pas a faire un template de pointeur de fonction membre ... voici mon code :
dans le .H

Code :

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

1
2
 
template <class T> bool AjouterTache(AnsiString lhoraire, void( T::*levent)() );

dans le .cpp

Code :

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

1
2
3
4
5
 
template <class T> bool TPlanification ::  AjouterTache(AnsiString lhoraire, void( T::*levent)() )
{
   ...
}

l'erreur du compilateur est : 'TPlanification::AjouterTache(AnsiString,void (struct::*)())' is not a member of 'TPlanification'

d'apres la faq l'éditeur de lient a du mal a trouver les .cpp de template, ben meme si je met le code de la fonction dans le .H le compilateur m'affiche la meme erreur.

ai je fait une erreur de syntaxe ? ou ne peut on pas faire de template de pointeur sur fonction membre d'une classe ? car suivant la classe employé le pointeur de fonction change de prototype :

Code :

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

1
2
3
4
5
 
//pour la classe A
 void (A::* levent)() ;
//et pour la classe B
 void (B::* levent)() ;

donc mon code n'est pas portatif c'est pourquoi je voudrais faire un template qui change suivant la classe d'appartenance de la fonction que je veux lancé a telle heure.

Merci d'avance.

[say]

suis pas au top en template...mais l'erreur semble claire et porte sur la résolution de portée :

TPlanification :: AjouterTache

cela suppose que AjouterTache soit une fonction membre de la classe TPlanification, ce qui ne doit pas être le cas...

[Traxsilver]

sisi mais j'avais pas collé toute la classe :

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
 
class TPlanification
{
     private :
             TTimer *TimerPlanification ;
             void __fastcall TimerPlanificationTimer(TObject *Sender);
             AnsiString horaire[10] ;
             int *ad[10] ;
             void (*event[10]) () ;
             int nbrevent ;
     public :
             __fastcall  TPlanification() ;
             __fastcall  ~TPlanification() ;
             template <class T> bool AjouterTache(AnsiString lhoraire, void( T::*levent)() );
 
};

[Patrick Seuret]

Pourquoi dois-tu passer par un template?

Moi j'aurais simplement fait appel à une fonction de classe (qui peut être différente pour chaque appel à AjouterTache), éventuellement en jouant sur une classe abstraite pour des paramètres ou des valeurs de retour, mais tu n'en as même pas.

Code :

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

1
2
3
4
5
class TPlanification {
  public:
    typedef void (*levent)();  // éventuellement ajouter "__closure" pour utiliser une fonction contenue dans une classe
    bool AjouterTache(AnsiString lhoraire, levent delegate);
}

Et tu appelles ta fonction comme ça:

Code :

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

1
2
3
4
5
6
7
8
class TFoo {
  public: 
    void CallBack();
}
 
TFoo myFoo;
TPlanification myPlanification;
myPlanification.AjouterTache("Hello",myFoo.CallBack);

PS: C'est du code écrit comme ça, sans tester et donc à vérifier

[Patrick Seuret]

J'ai craqué et j'ai fait le test. voici un code qui fonctionne:

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
class TPlanification {
  public:
    typedef void (__closure *levent)();
    bool AjouterTache(AnsiString lhoraire, levent delegate) {
      if (delegate) delegate();
    };
};
 
class TFoo {
  public:
    void CallBack() {
      ShowMessage("Hello");
    }
};
 
//---------------------------------------------------------------------------
void __fastcall TForm1::Button1Click(TObject *Sender)
{
 
  TFoo myFoo;
  TPlanification myPlanification;
  myPlanification.AjouterTache("Message",myFoo.CallBack);
 
}

[Traxsilver]

Je voulais passer par un template pour que n'importe quelle fonction de n'importe quelle classe de mon projet puisse avoir une tache planifié. Et le prototype d'un pointeur de fonction change selon la classe d'appartenance de la fonction.

Code :

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

1
2
3
4
5
 
//pour la classe A
 void (A::* levent)() ;
//et pour la classe B
 void (B::* levent)() ;

je ne connaissais pas l'instruction __closure ( je suis débutant ) mais en lisant la doc de Borland ce mot clef reglerais en effet mon probleme. Merci pour ta réponse je la code ce soir

[Patrick Seuret]

Salut,

Oui, dans Borland, c'est le mot-clé "__closure" qui va indiquer que la fonction (voir aussi délégué, delegate et callback) fait partie d'une classe. Le prototype est toujours le même (même liste de paramètre, même type de retour) mais le delegate peut appartenir à des classes différentes.

Tu pourrais aussi utiliser des functors comme dans la STL.

Dis-moi si ça fonctionne.

[Traxsilver]

Grand merci a vous le programme fonctionne