Discussion :

[loman02]

Bonjour a tous j'ai (encore) une question:

J'ai une classe ClovisVariable et plusieurs autre classe qui héritent de celle-ci : CString CFloat CInteger ...

J'ai crée une Class Node dont j'ai spécialisé une fonction. voici un bref résumé.

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
 
template <class T>
Class Node{
 
  public:
     Node();
     void getPath();
 
} 
 
template <class T>
T * Node<T>::getPath(){
     std::cout << "Type Inconnu" << std::endl;
     return NULL;
}
 
Node<ClovisVariable> * Node<ClovisVariable>::getPath(CString name){
    std::cout << "clovis variable" << std::endl;
    return NULL;
}

Donc quand je fais ceci:

Code :

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

1
2
3
 
Node<CString> * j = new Node<CString>();
j->getPath();

Il m'affiche type inconnu alors que j'aimerai qu'il m'affiche Clovis Variable

Je ne sais pas quoi faire pour que quand je mets

Code :

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

1
2
3
4
 
Node<CString> * j = new Node<CString>();
Node<CInteger> * i = new Node<CInteger>();
Node<CFloat> * k = new Node<CFLoat>();

a chaque fois que je fais appel à la fonction getPath() il m'affiche Clovis Variable.

Quelqu'un peut il m'eclairer de ses lumières?

[Davidbrcz]

Si je me rappelle bien, ce n'est pas possible.
Avec les spécialisation c'est exactitude totale ou rien.

Je crois savoir que ce sujet à déjà été traité (cas très similaire). Il faut que je recherche pour confirmer.

Edit: 3 solutions :
-cast.C'est assez simple, mais c'est moche.

example :
(code fait par adema)

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
 
#include <iostream>
 
class ClovisVariable
{
};
 
class CInteger : public ClovisVariable
{
};
 
class CString : public ClovisVariable
{
};
 
class CFloat : public ClovisVariable
{
};
 
template <class T>
class Node
{
	public:
		void getPath(T);
};
 
template <class T>
void Node<T>::getPath(T name)
{
	std::cout << "Type Inconnu" << std::endl;
}
 
template <>
void Node<ClovisVariable>::getPath(ClovisVariable name)
{
	std::cout << "clovis variable" << std::endl;
}
 
typedef Node<ClovisVariable> NodeClovis;
 
int main(void)
{
	CString i_string;
	Node<ClovisVariable> * i_node = new Node<ClovisVariable>();
	i_node->getPath(static_cast<ClovisVariable>(i_string));
 
	CInteger j_integer;
	Node<ClovisVariable> * j_node = new Node<ClovisVariable>();
	j_node->getPath(static_cast<ClovisVariable>(j_integer));
 
	CFloat k_float;
	Node<ClovisVariable> * k_node = new Node<ClovisVariable>();
	k_node->getPath(static_cast<ClovisVariable>(k_float));
 
       delete i_node;
        delete j_node
delete k_node;
	return 0;
}

Spécialisation "à la main"
Si le nombre de type est petit, on expliciter toutes les spécialisation.

Spécialisation "automatique"
La on sort la grosse artillerie: la métaprogrammation
Voici un code non testé qui résume mon idée:

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
70
 
#include <iostream>
 
class ClovisVariable
{
};
 
class CInteger : public ClovisVariable
{
};
 
class CString : public ClovisVariable
{
};
 
class CFloat : public ClovisVariable
{
};
 
template <class H, class SousListe> struct ListeType {};
struct ListeFin {};
 
template <class T> class Node;
 
template <class H,class SousListe> class Node< ListeType<H, SousListe> > : public Node<SousListe>
{
public:
    H* getPath(const H& h)
    {
             std::cout << "Type Connu : Clovis" << std::endl;
             return NULL;
    }
};
 
// Spécialisation pour le type de fin de liste
// C'est la super-classe
template <> class Node< ListeFin > 
{
public:
 
    template <class Z> Z* getPath(const Z& z)
    {
             std::cout << "Type Inconnu" << std::endl;
             return NULL;
    }
};
 
typedef ListeType<ClovisVariable, ListeType<CInteger, ListeType<CFloat, ListeType<CString, ListeFin> > > > UneListeClasses;
 
int main()
{
int i;
	CString i_string;
	Node<UneListeClasses> * i_node = new Node<UneListeClasses>();
	i_node->getPath(i_string);
 
	CInteger j_integer;
	Node<UneListeClasses> * j_node = new Node<UneListeClasses>();
	j_node->getPath(j_integer);
 
	CFloat k_float;
	Node<UneListeClasses> * k_node = new Node<UneListeClasses>();
	k_node->getPath(i);
 
        delete i_node;
        delete j_node
delete k_node;
 
	return 0;
}