[Template][STL] Template de vector et pointeur de fonction

Version imprimable

Salut !

J' essaye de créer en C++ une classe permettant d'utiliser plus facilement les tableaux de pointeurs de fonction. Pour cela, j' ai créer la classe suivante:
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 class REDIRECT { public: typedef void(REDIRECT::* pt2member) (void); void aha(void) { cout << "wcsv" << endl; return; } void add(string occurence, pt2member function); //add an instruction void del(string occurence, pt2member function); //delete an instruction template<class T> void test(string occurence, T myClass); //test all instruction private: vector < pt2member > listINS; //list of all instruction vector < string > listOCC; //list of all occurence };
Aucun problème, ma classe marche sans problème. Mais le seul hic c'est qu' avec cette classe, on ne peut utiliser seulement les mèthodes membres de la dite classe. Pour remedier à cela j' ai essayé de remplacé le type pt2member par des template, mais la classe vector de la STL ne veut pas de template comme type...

Merci d'avance

02/10/2005, 15h50
Laurent Gomila

Essaye de regarder du côté de boost::function. Mais dans tous les cas, je ne sais pas si tu pourras stocker des instances de fonctions membres de classes différentes dans un même conteneur.
02/10/2005, 16h37
legend666

Est-ce que tu aurais des liens pour la doc de cette librairie ? Ou du moins des exemples par ce que j' ai pas trop compris la doc officiel :oops: .

Hum, j' ai reussi à avancé sur le points de vues des templates grace à la page suivante: http://emmanuel-remy.developpez.com/...e/template.htm . La classe est maintenant un template, et je ne sais pour quelle raison, mais la classe vector de la STL n' a rien contre un template "generalisé" de la classe. J' obtiens ainsi le code suivant:
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 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 template < class Type > class REDIRECT { public: typedef void(Type::* pt2member) (void); void add(string occ, pt2member function); template < class T > void test(string occ, T myClass); private: vector < pt2member > listINS; //list of all instruction vector < string > listOCC; //list of all occurenc }; template < class Type > void REDIRECT < Type >::add(string occ, pt2member function) { listOCC.push_back(occ); //add occurence to list listINS.push_back(function); //add function to list return; } template < class T > void test(string occ, T myClass) { int i; for(i = 0; i < listOCC.size(); i++) { if(listOCC[i] == occ) callMemberFunction(myClass, listINS[i]) (); } return; } class AFF { public: void go() { cout << "Hello !" << endl; } }; int main() { REDIRECT<AFF> test; AFF afficher; test.add("go", &AFF::go); test.test("go", test); return 0; }
Mais, comme vous pouvez le voir, j' ai du supprimé un template pour la fonction test, ce qui ammenne bien sur au linkage une erreur car celui ci crois qu' il faut utiliser le template de la classe et nom celui utilisé pour les arguments. :roll: Hum je pense que le message d' erreur du linkeur sera plus clair que moi:
Code:

1 2 "vector.tcc" : /usr/include/c++/3.3/bits/vector.tcc undefined reference to `void REDIRECT<AFF>::test<REDIRECT<AFF> >(std::basic_string<char, std::char_traits<char>, std::allocator<char> >, REDIRECT<AFF>)' en ligne 236
Voila,donc ma question est maintenant: est-ce tout d' abord possible, et si oui, comment, de posseder 2 types de templates dans une classe ?

Merci d' avance

Code:

1
2
3
4
5
6
template < class Type >
template < class T >
void REDIRECT < Type >:: test(string occ, T myClass)
{
    ...
}

:?:

ARGH !

Deux bourde de ma part:

La première, ENORME est l' oubli du "void REDIRECT<T>::" !
La deuxième est que je pasais comme argument a la fonction test une instanciation de redirect !

Donc, au final, voici mon code au complet pour ce que ce pourrait aider:

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
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
 
#include <iostream>
#include <vector>
#include <string>
 
#define callMemberFunction(object,ptrToMember)  ((object).*(ptrToMember))
 
using namespace std;
 
 
 
template < class Type>
class REDIRECT
{
public:
  typedef void(Type::* pt2member) (void);
  void add(string occ, pt2member function);
 
  template <class T>
  void test(string occ, T myClass);
 
private:
  vector < pt2member > listINS; //list of all instruction
  vector < string > listOCC; //list of all occurenc
 
};
 
 
 
template < class Type>
void REDIRECT < Type >::add(string occ, pt2member function)
{
  listOCC.push_back(occ); //add occurence to list
  listINS.push_back(function); //add function to list
 
  return;
}
 
template < class Type >
template < class T >
void REDIRECT < Type >:: test(string occ, T myClass)
{
  int i;
  for(i = 0; i < listOCC.size(); i++)
  {
    if(listOCC[i] == occ)
      callMemberFunction(myClass, listINS[i]) ();
  }
 
  return;
 
}
 
class AFF
{
  public:
    void go() {
      cout << "Hello !" << endl;
    }
};
 
 
int main()
{
  REDIRECT<AFF> test;
  AFF afficher;
 
  test.add("go", &AFF::go);
  test.test("go", afficher);
  return 0;
}

Merci beaucoup !

Par contre tu devrais utiliser un std::map, étant donné que tes pointeurs de fonctions sont associés à des chaînes. Cela t'évitera de devoir gérer en parallèle deux vecteurs.

Tu devrais aussi passer ton paramètre de type T par référence, car là tu vas appeler des fonctions membres sur des copies. Je ne pense pas que ce soit ce que tu veux.

Enfin, pour pinailler, je doute de l'utilité de ta macro d'appel de fonction membre. D'autant plus qu'elle n'apparaitra qu'une fois dans le code, puisque le but de ta classe est justement d'encapsuler les appels de fonctions membres.
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 map<string, pt2member> listINS; template < class Type> void REDIRECT < Type >::add(const string& occ, pt2member function) { listINS[occ] = function; } template < class Type > template < class T > void REDIRECT < Type >:: test(const string& occ, T& myClass) { (myClass.*listINC[occ])(); }
Après on peut ajouter divers tests, ou encore une surcharge pour les fonctions / instances constantes...

[edit] Question à 3 sous : pourquoi introduire un type T différent de Type, dans la fonction de test ? C'est pour gérer les objets polymorphiques ?

02/10/2005, 23h05
legend666

Ok, merci pour tes conseils :D , mais je ne comprends ce que tu veux dire par gerer les objets polymorphique: c-à-d pour les constructeur des objets ?! (hum je crois que je suis fatiqué là bonne nuit)

Je voulais parler de ça :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
struct Base
{
    virtual void Do();
};
 
struct Derivee : Base
{
    virtual void Do();
};
 
int main()
{
    REDIRECT<Base> test;
    Derivee d;
 
    test.add("Do", &Base::Do);
    test.test("Do", d);
 
    return 0;
}

Mais tu n'as pas répondu à la question :P

03/10/2005, 09h55
legend666

Hum heuh non je n' y avais pas pensé ! :roll:

Bon tant mieux on va dire...
03/10/2005, 11h05
Laurent Gomila

Du coup on sait toujours pas pourquoi tu avais fait ça, alors. C'est pas pour t'embêter hein, c'est juste que ça m'intéresse.
03/10/2005, 14h12
legend666

Hum, soyons honnête, j' avais fait ca un peu au pif quand j' obtenais l' erreur de template, j' avais essayé cette methode, sans resultat. Et puis j' ai oublié de l' enlever.... :oops:
03/10/2005, 14h29
Laurent Gomila

OK :D

N'oublie pas de cliquer sur :resolu: si c'est bien le cas.

Ok. Donc après les "optimisation":

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
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
 
#include <iostream>
#include <string>
#include <map>
 
using namespace std;
 
template < class Type>
class REDIRECT
{
public:
  typedef void(Type::* pt2member) (void);
  void add(const string& occ, pt2member function);
  void test(const string& occ, Type& myClass);
 
private:
  map<string, pt2member> listINS;
 
};
 
template < class Type>
void REDIRECT < Type >::add(const string& occ, pt2member function)
{
  listINS[occ] = function;
 
  return;
}
 
template < class Type >
void REDIRECT < Type >:: test(const string& occ, Type& myClass)
{
  if(listINS.find(occ) != listINS.end())
    (myClass.*listINS[occ])();
 
 
  return;
}
 
class AFF
{
  public:
    void go() {
      cout << "Hello !" << endl;
    }
};
 
 
int main()
{
  REDIRECT<AFF> test;
  AFF afficher;
 
  test.add("go45", &AFF::go);
  test.test("go", afficher);
 
  cout << "END !" << endl;
  return 0;
}

Merci encore !