Discussion :

[alves1993]

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

Code :

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

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
}

[Bousk]

Bonjour,

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

[alves1993]

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

Code :

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

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 ) 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 :

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

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.

[Iradrille]

Ç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 :

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
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++.

[Neckara]

Bonjour,

Il te suffit dans tes classes de rajouter :

Code :

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

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 :

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

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 :

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

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
Pour les "types de bases" du genre int, float, je pense que la question ne se pose même pas

[Bousk]

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

Code :

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

1
2
Maya perso2;
Maya perso3;

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

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.

[Neckara]

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 :

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

1
2
3
4
convert(const Type & object)
{
 
}

Et qu'on a :

Code :

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

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
Pas vraiment adapté je trouve pour maintenir le code (ex un utilisateur utilise notre bibliothèque et rajoute un type).

[Bousk]

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 :

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

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 :

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

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!

[Neckara]

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.

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) ?

[Bousk]

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
Mais on peut p-e trouver une astuce avec la visibilité protected ou private, et une amitié