Discussion :

[3uclide]

Bonjour, je cherche un moyen propre de vérifier si mon objet est de tel ou tel type. typeid ne peut pas fonctionner car ces objets héritent du même.

[poukill]

Une solution : implémenter une fonction virtuelle GetTypeName() const qui renvoie le nome de la classe.
Avec une macro qui va bien, pour simplifier, ça peut donner ça :

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
 
#define DECLARE_TYPE(Class) \
	virtual std::string GetTypeName() const {return #Class; }
 
 
 
//-----------------------------------------------------------
// IObject : Base class
//-----------------------------------------------------------
 
struct IObject
{
	IObject() {}
	virtual ~IObject() {}
 
	// Fonction to get the real type of the Class.
	virtual std::string			GetTypeName	() const = 0;
 
	// Polymorphic copy the object
	virtual boost::shared_ptr<IObject>	Clone		() const
	{
		throw std::exception("This object is no clonable");
	}
 
};

A +

[Emmanuel Deloget]

Bonjour, je cherche un moyen propre de vérifier si mon objet est de tel ou tel type. typeid ne peut pas fonctionner car ces objets héritent du même.

dynamic_cast<> devrait permettre ça (s'il s'agit juste de comparer deux types entre eux). C'est notamment le cas si les objets sont de la même hierachie.

Code :

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

1
2
3
4
5
6
7
8
9
10
 
class A { };
class B : public A { };
class C : public A { };
class D : public B { };
 
A* a;
...
D* d = dynamic_cast<D*>(a); // d == NULL si a n'est pas un objet du type D
C* c = dynamic_cast<C*>(a); // c == NULL si c n'est pas un objet du type C

RTTI doit être activé (ce n'est pas le cas dans les settings par défaut sous Visual Studio, mais c'est le cas avec g++).

Ou es-ce que j'ao manqué quelque chose dans ta question ?

[Luc Hermitte]

Ou es-ce que j'ai manqué quelque chose dans ta question ?

Il demande un moyen propre ... "pourquoi faire ?" me parait être la meilleure réponse à sa question. S'il vient du Java il risque d'être habitué aux void*^WObject et non au typage bien plus strict des templates, plus les cas comme le double-dispatching qui peuvent-être résolu avec un pattern visiteur, ou encore le fait que le C++ dispose d'une meilleure sémantique de valeur ce qui lui permet d'esquiver les prises de choux que la communauté Java expérimente avec des fonctions comme equals (qui est un double dispatching dégénéré qui se résout avec les templates et 0 héritage en C++).

[3DArchi]

Bonjour,
type_id retourne le type dynamique de l'objet si le type statique est polymorphe :

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
#include<typeinfo>
#include <iostream>
 
struct polymorphic_base
{
   virtual ~polymorphic_base(){}
};
struct polymorphic_derived : public polymorphic_base
{
};
 
struct non_polymorphic_base
{
   ~non_polymorphic_base(){}
};
struct non_polymorphic_derived : public non_polymorphic_base
{
};
 
 
template<class derivee, class base>
void dump()
{
   base b;
   derivee d;
   base &rb=b;
   base &rd=d;
   std::cout<<typeid(b).name()<<"\n";
   std::cout<<typeid(d).name()<<"\n";
   std::cout<<typeid(rb).name()<<"\n";
   std::cout<<typeid(rd).name()<<"\n";
}
 
int main()
{
   std::cout<<"polymorphe : \n";
   dump<polymorphic_derived,polymorphic_base>();
   std::cout<<"non polymorphe : \n";
   dump<non_polymorphic_derived,non_polymorphic_base>();
 
   return 0;
}

Sortie :

polymorphe :
struct polymorphic_base
struct polymorphic_derived
struct polymorphic_base
struct polymorphic_derived
non polymorphe :
struct non_polymorphic_base
struct non_polymorphic_derive
struct non_polymorphic_base
struct non_polymorphic_base

[EDIT] la réponse de Luc est la plus pertinente : pourquoi faire ?

[3uclide]

je dois effectuer un traitement spécifique suivant l'objet. Si l'objet dérivé est de tel type je fais ceci, s'il est de se type, je fais cela...

La réponse de "poukill" me semble le plus adapter, a moins que j'ai mal compris le dynamic_cast<>

J'vais aller faire quelques testes.

[JolyLoic]

je dois effectuer un traitement spécifique suivant l'objet. Si l'objet dérivé est de tel type je fais ceci, s'il est de se type, je fais cela...

La seule bonne façon de faire ça, c'est une fonction virtuelle...

[bretus]

Bonjour,

La seule bonne façon de faire ça, c'est une fonction virtuelle...

Humph, ceci aurait pas tendance à faire préférer l'héritage à la composition?