Comparer des classes

salut je voudrais savoir s'il est possible de comparer deux classes en C++. si oui comment procéder :roll:
je vous donne un exemple :

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13 14

Athénien perso1; Maya perso2; Maya perso3;   if(perso1 == perso2) { //instruction } if(perso2 == perso3) { //instruction }

---

Bonjour,

ça s'apelle la surcharge d'opérateur. == en particulier.
http://cpp.developpez.com/faq/cpp/?p..._operator_egal

peut être que j'ai du mal formuler ma question.
mais je parle de comparer deux type de classe. je donne un exemple

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13

int a; int b; string test;   if( a==b) { //instruction } if(a==test) { //instruction }

---

dans la première conditions je veux vérifié si a et b sont de même type (sont de même type :roll:) et non de comparer leur valeur. de même pour la seconde condition (ne sont pas de même type ).

puis savoir si cela peut s'appliquer au classe crée pour nos programmes :?

un exemple :

Code:

---

1 2 3 4 5 6 7 8

Maya perso1; Zulu perso2;   if( Maya==Zulu) { //instruction }

---

dans ce exemple je veux comparer les types de classe(ici ils ne sont pas de même type de classe) et non les valeur de ces classes.

Ça peut se faire avec std::is_same, mais vu tes exemples, je suis pas sur que ce soit ce que tu cherches, std::is_same est un template, donc "exécuté" pendant la compilation

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16

std::string str; int i;   if(std::is_same<decltype(str), decltype(i)>::value) { // type de str == type de i } else { // type de str != type de i } // cependant c'est équivalent à if(false) {   } else {   }

---

L'intérêt est ici (très) limité. Ça marche avec tous les types. (Il faut juste penser à supprimer les références si besoin pour comparer les types)

Par contre comparer des types de variables à l'exécution, ça se fait dans certains langages, mais pas en c++.

Bonjour,

Il te suffit dans tes classes de rajouter :

Code:

---

1 2 3 4 5 6 7 8

class MaClass { public : virtual Type getType(void){ return m_type; } private : Type m_type = ??; }

---

Rq : Tu peux même faire hériter toutes tes classes d'un classe "Object" (comme en Java) :

Code:

---

1 2 3 4 5 6 7

class Object { public : virtual ~Object(void){} Object(Type type = TYPE_OBJECT) : m_type(type){} const Type m_type; }

---

Voir même utiliser un std::set<Type> si tu veux que :

Code:

---

1 2 3 4 5

class A{}; class B : public A {}; A a; B b; compareType(a, b); //retourne true

---

Après, si tu veux utiliser d'autres classes que tu n'as pas écrit, je pense qu'il faudra les encapsuler :aie:
Pour les "types de bases" du genre int, float, je pense que la question ne se pose même pas ;)

Le C++ est fortement typé, si j'écris

Code:

---

1 2	Maya perso2; Maya perso3;

---

Y'a à peu près 8000% de chance que oui, perso2 et perso3 soient de même type. :calim2:

Si c'est dans le cas d'un polymorphisme, il y a le plus souvent mieux à faire que de vouloir connaitre leur type réel, via le polymorphisme justement.

En tout dernier recours, il faut alors employer des dynamic_cast.

Est-ce que connaître le type réel ne pourrait pas être utile dans tout ce qui est interfaçage avec des scripts/transmissions de données "brutes" via le réseau ?

Si on utilise une méthode/fonction :

Code:

---

1 2 3 4

convert(const Type & object) {   }

---

Et qu'on a :

Code:

---

1 2 3 4 5 6 7 8 9

class A { };   convert(const A & a);   class B : public A { };

---

On va pouvoir transmettre un B à convert(const A & a) ce qui risque de générer des erreurs dans le futur.
Ainsi connaître le type exact des classes permettrait d'avoir des listes de type qu'on peut "convertir" et d'autres qu'on ne peut pas (?).

Pour dynamic_cast, le problème, c'est qu'il faut tester tous les types :aie:
Pas vraiment adapté je trouve pour maintenir le code (ex un utilisateur utilise notre bibliothèque et rajoute un type).

Franchement je vois pas.
Tout ce qu'on envoit sur le réseau est connu et maitrisé : typage statique.
Effectivement si t'as une hiérarchie de Object* que tu espères faire passer sans savoir ce qu'il y a derrière, tu vas avoir des problèmes.
Et encore... il suffit de changer son fusil d'épaule et de fournir une méthode à surcharger qui fait l'envoi, ou au moins te retourne la sérialisation de l'objet.

Donc tu pourrais préférer plutôt

Code:

---

1 2 3

class Object { virtual std::string Serialize() const=0; };

---

Ce qui est totalement acceptable amha au vue des possibilités d'introspection disponibles en C++.

Et non

Code:

---

1 2	class Object {}; std::string Serialize(const Object&) {}

---

Qui est plus proche du code utopique selon moi.

En C++ en tous cas, en Python l'inverse est plus vrai par contre!

Il est vrai que je n'avais pas pensé au fait, qu'il faut bien pensé à donner l'identifiant dans le constructeur de la classe donc qu'il y a aussi source d'erreur en cas d'oubli. :aie:

Il n'y a pas un mot-clé qui force les classe héritante de redéfinir une méthode (même si elle est déjà définie dans la classe mère) ?

Citation:

---

Envoyé par Neckara

Il n'y a pas un mot-clé qui force les classe héritante de redéfinir une méthode (même si elle est déjà définie dans la classe mère) ?

---

J'ai pas vraiment suivi l'avalanche de mot-clé C++11 puis 14 donc je sais pas :aie:
Mais on peut p-e trouver une astuce avec la visibilité protected ou private, et une amitié :roll:

Salut,

De manière générale, c'est une très mauvaise idée de vouloir faire ce genre de test, de toutes manières.

Il ne faut pas oublier:

1. que pour profiter du polymorphisme, on va devoir maintenir les objets de types dérivés sous la forme de pointeurs (éventuellement intelligents) dont le type est celui de la classe de base
2. que le maya sait etre un maya et que le zulu sait être un zulu et que c'est largement assez
3. que, si tu commence à décider de faire quelque chose (ou non) à coup de if... else, tu va très rapidement te retrouver avec énormément d'endroits de ton code dans lesquels tu feras ce genre de tests, avec comme résultat une difficulté énorme à rajouter un nouveau type (parce que tu devras passer tous ces endroits en revue, au risque d'en oublier un)

Il faut donc veiller, lorsque tu ne connais les différents éléments que comme étant du type de base, à ne les utiliser que comme des objets du type de base.

Si, à un moment donné, tu dois décider de faire (ou non) quelque chose de particulier en fonction du type réel de l'objet pointé, tu as grandement intérêt à passer par le double dispatch.

Une solution (parmi d'autres) est de recourir au patron de conception "visiteur", mais rien ne t'empêche, pour certains comportements spécifiques, de "simplement" créer une surcharge de fonction proche de

Code:

---

1 2 3 4 5 6 7

void doSomething(Zulu /*const*/ &){   }   void doSomething(Maya /*const*/ &){   }

---

qui sera utilisée lors du double dispatch:

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12

class Personne{ public: virtual void doIt()/* const*/ = 0; }; class Maya{ public: virtual void doIt()/*const*/{ doSomething(*this);} }; class Zulu{ public: virtual void doIt()/*const*/{ doSomething(*this);} };

---

bon merci pour les réponses je vais utiliser chacune de vos méthode.
mais j'avoue que pour un débutant en programmation c'est pas de la tarte 8O.

Le problème c'est que ce que tu essaie de faire n'est pas dans "la philosophie" du c++, donc c'est compliqué. L'idée du c++, en gros, c'est que "un objet doit pouvoir se débrouiller tout seul".
Il parait que la comparaison de type peut être inévitable; je n'ai pour ma part jamais eu à faire ça.
Une solution simple (mais moche), si tu es débutant, c'est de rajouter un enum avec tous les types que tu veux pouvoir comparer, et de l'utiliser en variable membre des classes. Quelque chose comme ça:

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

enum ComparableType { maya, zulu };   class Maya { public: Maya():type_(maya) {} ComparableType GetType() const { return type_; } private: ComparableType type_ ; };   class Zulu { public: Zulu():type_(zulu) {} ComparableType GetType() const { return type_; } private: ComparableType type_ ; };

---

Après, si tu veux, tu peux faire hériter tes classes d'une classe de base et passer la variable membre type_ dans cette classe de base.