récupérer un string dans une macro
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:
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:
1
2
|
void read_TypeData(TypeData data); |
voici ce que j'ai jusqu'a present :
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
|
#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:
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:
1
2
3
4
5
|
void run()
{
_pComponent->read_type();
} |
avoir (dans le cas d'un type template DebugVal) :
Code:
1
2
3
4
5
|
void run()
{
_pComponent->read_DebugVal();
} |
