Discussion :

[Davidbrcz]

Bonjour à tous.
je possède une super classe A dont dérive les classes B, C et D.
Je souhaite qu'une fonction de la classe Info m'affiche connu si l'objet qu'on lui passe est du type A ou dérivé de A ou sinon inconnu.
Pour cela j'utilise donc la métaprogrammation en m'inspirant de cette page de wikipedia .
Voici le code :

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
 
#include <iostream>
 
class A{};
class B : public A{};
class C : public A{};
class D : public A{};
 
template <class H, class SousListe> struct ListeType {};
struct ListeFin {};
 
template <class T> class Node;
 
// Spécialisation pour le type de fin de liste
// C'est la super-classe
template <> class Node< ListeFin > 
{
public:
 
    template <class Z> void getPath(const Z& z)
    {
             std::cout << " inconnu" << std::endl;
    }
};
 
template <class H,class SousListe> class Node< ListeType<H, SousListe> > : public Node<SousListe>
{
public:
        template <> void getPath(const H& h){             
        std::cout << "connu" << std::endl;
             }
};
 
/*
template <class H,class SousListe> template <> void Node< ListeType<H, SousListe> >::getPath(const H& h)
    {
             std::cout << " connu" << std::endl;
    }
*/
typedef ListeType<A, ListeType<B, ListeType<C, ListeType<D, ListeFin> > > > UneListeClasses;
 
int main()
{
        int i;
	A a;
	Node<UneListeClasses> node;
        node.getPath(a);
 
	B b;
	node.getPath(b);
 
	C c;
	node.getPath(c);
 
	return 0;
}

Avec ce code, j'obtient l'erreur

explicit specialization in non-namespace ‘class Node<ListeType<H, SousListe> >’ scope.

D'apres mes recherches, je n'ai pas le droit de specialiser dans la classe.
Je comment donc la fonction dans la classe et je créer ce qui est commenté dans le code.

Mais ca ne compile pas, l'erreur est:

essaimetaprog.cpp:35: error: invalid explicit specialization before ‘>’ token
essaimetaprog.cpp:35: error: enclosing class templates are not explicitly specialized
essaimetaprog.cpp:35: error: no member function ‘getPath’ declared in ‘Node<ListeType<H, SousListe> >’

Une idée ?

Merci.

[loufoque]

Code :

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

1
2
3
4
5
6
7
8
9
10
11
template<typename T>
typename enable_if<is_base_of_<A, T>, void>::type f(T t)
{
    std::cout << "type dérivé de A" << std::endl;
}
 
template<typename T>
typename disable_if<is_base_of_<A, T>, void>::type f(T t)
{
    std::cout << "type non dérivé de A" << std::endl;
}

[Alp]

En effet, il faut utiliser Boost.TypeTraits (combiné à Boost.MPL), cf mon article sur les classes de traits

[Davidbrcz]

Ca me permet de déterminer si un objet de type A ou dériver mais je dois encore le passer à la bonne fonction après.
Or vace ce système, je souhaite que le passage soit automatique.

PS: prenez aussi ce code comme étant un exo sur la métaprog.

[Montag]

Salut,

Voilà ce que je propose pour que ton idée puisse fonctionner :

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
#include <iostream>
#include <typeinfo>
 
class A{};
class B : public A{};
class C : public A{};
class D : public A{};
 
template<class H, class SousListe> struct ListeType{};
struct ListeFin{};
 
template<class T> class Node;
 
// Spécialisation pour le type de fin de liste
// C'est la super-classe
template <>
class Node<ListeFin> 
{
public:
	template<class Z>
	void getPath(const Z& z)
	{
		std::cout << "inconnu" << std::endl;
	}
};
 
template <class H,class SousListe>
class Node<ListeType<H, SousListe> > : public Node<SousListe>
{
public:
	using Node<SousListe>::getPath; //sinon le getPath de Node<SousListe> est masqué par le getPath défini en-dessous
 
	void getPath(const H& h)
	{   
		std::cout << typeid(H).name() << std::endl; //ça c'est juste pour savoir quelle fonction est appelée
		std::cout << "connu" << std::endl;
	}
};
 
typedef ListeType<A, ListeType<B, ListeType<C, ListeType<D, ListeFin> > > > UneListeClasses;
 
int main()
{
	A a;
	Node<UneListeClasses> node;
	node.getPath(a);
 
	B b;
	node.getPath(b);
 
	C c;
	node.getPath(c);
 
	D d;
	node.getPath(d);
 
	int i;
	node.getPath(i);
 
	return 0;
}

[Davidbrcz]

Hum, je n'avais pas envisagé ca comme ca mais ca marche.
Merci.