C++ objet d'égalité

J'ai une classe MyCloth et un objet instance de la classe que j'ai instancié comme ceci:

MyCloth** cloth1;

Et à un moment dans le programme, je vais faire quelque chose comme ceci:

MyCloth** cloth2 = cloth1;

Et puis à un moment plus tard, je veux vérifier pour voir si cloth1 et cloth2 sont les mêmes. (Quelque chose comme objet d'égalité en Java, seulement ici, MyCloth est très complexe de la classe et que je peux"t construire un isEqual fonction.)

Comment puis-je faire ce contrôle d'égalité? Je pensais peut-être vérifier s'ils pointent vers la même adresse. Est-ce une bonne idée? Si oui, comment dois-je faire?

Vous n'avez pas un "objet de la classe MyCloth". Si vous croyez ça, vous avez vraiment à repenser beaucoup de choses sur le C++.
...Pourquoi le ptr ptr?
SB: j'essayais juste d'expliquer ce que je veux faire, je sais que je peux"t ont un objet de la classe MyCloth, mais je ne savais pas comment le mettre, je suis novice en C++ et en essayant de le comprendre, comme je l'ai créer un projet.
cloth1 et cloth2 sont des pointeurs de pointeurs (chaque tissu se compose de pointeurs qui définissent ses paramètres, le comportement, et ainsi de suite)
Ce que vous voulez faire est de vérifier si chacun des pointeurs pointent sur la même allocation de mémoire ?
Oui, j'espère que cela fonctionnerait. Comment dois-je faire? comme ceci: If(&cloth1 == &cloth2) ?
Je sais qu'ils SONT ptr ptrs, je n'ai juste aucune idée de pourquoi vous les utilisez.
MadScienceDreams: comme je l'ai dit avant, je suis novice en C++ et je ne"t vraiment long avec des pointeurs très bien. Je ne savais pas comment gérer les pointeurs, je suis en utilisant un programme auxiliaire qui a offert un exemple, et dans cet exemple, ils ont écrit le code comme je l'ai écrit ici
Les pointeurs sont juste un emplacement dans la mémoire de l'espace. C'est une adresse à un emplacement dans la mémoire. Le "type" de le pointeur indique comment interpréter les uns et de zéros dans cet endroit. Lorsque vous utilisez un pointeur de pointeur, vous avez une adresse d'une adresse. Rien de ce que vous avez des points à une instance d'une classe. Toutefois, si vous n'avez initialiser une classe, comme "MyCloth* c1 = new MyCloth ();" Que vous pouvez utiliser 'MyCloth* c2 = NULL;/*ou que ce soit*/ c1==c2;" pour vérifier si c'est la même instance de déterminer si ou non les deux pointeurs sont à la même mémoire.Cela ne fonctionne PAS avec l'héritage virtuel!

InformationsquelleAutor user2399378 | 2013-05-30

c++equality pointers

13

Vous pouvez tester pour objet identité en comparant les adresses tenue par deux pointeurs. Vous mentionnez Java; c'est similaire au test que les deux références sont égaux.
```
MyCloth* pcloth1 = ...
MyCloth* pcloth2 = ...
if ( pcloth1 == pcloth2 ) {
    //Then both point at the same object.
}   
```
Vous pouvez tester pour objet l'égalité en comparant le contenu de deux objets. En C++, ce qui est généralement fait par la définition des operator==.
```
class MyCloth {
   friend bool operator== (MyCloth & lhs, MyCloth & rhs );
   ...
};

bool operator== ( MyCloth & lhs, MyCloth & rhs )
{
   return ...
}
```
Avec l'opérateur== est défini, vous pouvez comparer les sexes:
```
MyCloth cloth1 = ...
MyCloth cloth2 = ...
if ( cloth1 == cloth2 ) {
    //Then the two objects are considered to have equal values.
}   
```
- Compte tenu de MyCloth *pcloth1, *pcloth2; comment pourrait-on comparer le contenu des deux? votre exemple montre comment le faire pour les non-pointeurs seulement.
- @user2813274 -- if ( *pcloth1 == *pcloth2 ) ...
- Comment pouvez-vous dire si c'est la vérification où les pointeurs point, ou si le contenu des deux sites sont les mêmes?
- La valeur de votre pcloth1 est une adresse. La valeur de *pcloth1 est un MyCloth objet. L'expression *pcloth1 déréférence le pointeur pcloth1. Depuis les deux opérandes de l'expression sont MyCloth objets, le contenu est vérifié, plutôt que les adresses.
InformationsquelleAutor Andy Thomas
4

Si vous souhaitez définir une méthode permettant de commander une comparaison d'un ensemble d'objets de votre custome classe. Par exemple:
```
someClass instance1;
someClass instance2;
```
Vous pouvez le faire par la surcharge de la < opérateur pour cette classe.
```
class someClass
{

    bool operator<(someClass& other) const
    {
        //implement your ordering logic here
    }
};
```
Si ce que vous voulez faire est de comparer et de voir si les objets sont littéralement le même objet, vous pouvez faire un simple pointeur de comparaison pour voir si elles pointent vers le même objet. Je pense que votre question est mal formulé, je ne suis pas sûr que vous allez pour.

EDIT:

Pour la deuxième méthode, c'est vraiment très facile. Vous avez besoin d'accéder à l'emplacement de la mémoire de votre objet. Vous pouvez accéder de différentes manières. Voici quelques-unes:
```
class someClass
{

    bool operator==(someClass& other) const
    {
        if(this == &other) return true; //This is the pointer for 
        else return false;
    }
};
```
Remarque: je n'aime pas la-dessus, comme d'habitude == les opérateurs ne vont plus en profondeur qu'une simple comparaison de pointeurs. Les objets peuvent représenter des objets, des qualités similaires sans être identiques, mais c'est une option. Vous pouvez aussi le faire.
```
someClass *instancePointer = new someClass();
someClass instanceVariable;
someClass *instanceVariablePointer = &instanceVariable;


instancePointer == instanceVariable;
```
C'est non-sens et non valides/faux. Si il serait même compiler, en fonction de vos drapeaux, nous espérons que votre utilisation des indicateurs qui ne permettent pas cela!
```
instancePointer == &instanceVariable; 
```
Ceci est valable et aurait pour résultat faux.
```
instancePointer == instanceVaribalePointer;  
```
Cela est également valable, et le résultat serait faux.
```
instanceVariablePointer == &instanceVariable;
```
Cela est également valable, et aurait pour résultat VRAI
```
instanceVariable == *instanceVariablePointer;
```
Ce serait d'utiliser l'opérateur==, nous avons défini ci-dessus pour obtenir le résultat de VRAI;
- L'OP est en train de tester l'identité de l'objet ou de l'égalité, de ne pas comparer. Aussi, l'OP spécifie "MyCloth est très complexe de la classe et que je peux"t construire un isEqual fonction".
- La deuxième variante que vous décrivez. Comment dois-je faire?
- À l'aide de == de comparer les pointeurs vérifier qu'ils point exactement au même emplacement mémoire.
InformationsquelleAutor ChrisCM

Vous devez vous connecter pour publier un commentaire.