Bonjour a tous,

Je souhaiterai savoir si il est possible dans une classe template d'avoir une macro capable de créer une méthode de classe sous la forme void read_[Type template] du template. Elle serait utilisé par des méthodes du template.
Je précise que je suis tout a fait d'accord avec le fait qu'une classe template avec une méthode template ferait très bien l'affaire: en effet puisque en fonction du type passé en paramètre j'aurais une fois mon template instancier une méthode avec un nom généric associé a mon type template du genre :

Code : Sélectionner tout - Visualiser dans une fenêtre à part
1
2
 
template<typename T> void read(T data);
L'idée étant que l'utilisateur qui utilise la classe Composant déclare des méthodes read_[Type] qui soient appelées dans la classe template dataTest dans la méthode run.

Code : Sélectionner tout - Visualiser dans une fenêtre à part
1
2
 
void read_TypeData(TypeData data);
voici ce que j'ai jusqu'a present :

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
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
 
#include <string>
#include <typeinfo>
#include <iostream>
#include <algorithm>
 
  class DebugVal
  {
    public:
      DebugVal(){};
      ~DebugVal(){};
  };
 
  class Component
  {
    public:
      Component(){};
      ~Component(){};
 
      void read_DebugVal();
 
  };
 
  template<class C, typename T>
  class dataTest
  {
    public:
      dataTest(C* pComponent): _pComponent(pComponent){};
      ~dataTest(){};
 
      static std::string GetName()
      {
        std::string nameOfType(typeid(T).name());
        nameOfType.erase(std::remove_if(nameOfType.begin(), nameOfType.end(), &isdigit),nameOfType.end());
        return nameOfType;
      }
 
      #define type dataTypeName
      #define MAKE_SIGNATURE_FUNCTION_NAME(x) void read_##x()
      #define SIGNATURE_FUNCTION_FROM_TYPE(type) MAKE_SIGNATURE_FUNCTION_NAME(type)
      #define MAKE_BODY_FUNCTION_NAME(x) read_##x()
      #define BODY_FUNCTION_FROM_TYPE(type) MAKE_BODY_FUNCTION_NAME(type)
 
      MAKE_SIGNATURE_FUNCTION_NAME(type)
      {
          return;
      }
 
      C* _pComponent;
 
 
      void run()
      {
        _pComponent->MAKE_BODY_FUNCTION_NAME(type);
      }
 
 
 
  };
 
 
int main(int argc, char **argv) {
 
  Component component;
  dataTest<Component, DebugVal> test(&component);
  test.MAKE_BODY_FUNCTION_NAME(DebugVal);
 
	return 0;
}
et voici ce que la sortie préprocesseur me donne :

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
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
 
 
 class DebugVal
  {
    public:
      DebugVal(){};
      ~DebugVal(){};
  };
 
  class Component
  {
    public:
      Component(){};
      ~Component(){};
 
      void read_DebugVal();
 
  };
 
  template<class C, typename T>
  class dataTest
  {
    public:
      dataTest(C* pComponent): _pComponent(pComponent){};
      ~dataTest(){};
 
      static std::string GetName()
      {
        std::string nameOfType(typeid(T).name());
        nameOfType.erase(std::remove_if(nameOfType.begin(), nameOfType.end(), &isdigit),nameOfType.end());
        return nameOfType;
      }
 
      void read_type()
      {
      }
 
      C* _pComponent;
 
 
      void run()
      {
        _pComponent->read_type();
      }
 
 
 
  };
 
 
 
 
int main(int argc, char **argv) {
 
  Component component;
  dataTest<Component, DebugVal> test(&component);
  test.read_DebugVal();
 
 return 0;
}
Ce que je souhaite c'est qu'a la place d'avoir

Code : Sélectionner tout - Visualiser dans une fenêtre à part
1
2
3
4
5
 
      void run()
      {
        _pComponent->read_type();
      }
avoir (dans le cas d'un type template DebugVal) :

Code : Sélectionner tout - Visualiser dans une fenêtre à part
1
2
3
4
5
 
      void run()
      {
        _pComponent->read_DebugVal();
      }