C++ - Objekt-Gleichheit

Habe ich eine Klasse MyCloth und man eine Objekt-Instanz dieser Klasse, die ich instanziiert wie diese:

MyCloth** cloth1;

Und an einer Stelle im Programm steht, werde ich tun so etwas wie dieses:

MyCloth** cloth2 = cloth1;

Und dann irgendwann später, ich will zu überprüfen, um zu sehen, ob cloth1 und cloth2 sind die gleichen. (So etwas wie Objekt-Gleichheit in Java, nur hier MyCloth ist eine sehr komplexe Klasse und ich kann"t bauen eine isEqual Funktion.)

Wie kann ich diese Gleichheit prüfen? Ich dachte, vielleicht überprüfen, ob Sie auf den gleichen Adressen. Ist das eine gute Idee? Wenn ja, wie mache ich das?

Sie nicht haben ein "Objekt der Klasse MyCloth". Wenn Sie glauben, dass Sie wirklich überdenken eine Menge über C++.
...Warum der ptr ptr?
SB: ich war gerade versucht zu erklären, was ich tun will, ich weiß, ich kann"t haben ein Objekt der Klasse MyCloth, aber ich didn"t wissen, wie sonst zu setzen, es, ich"m mit C++ und versuchen, es herauszufinden, wie ich ein Projekt erstellen.
cloth1 und cloth2 Zeiger der Zeiger (jedes Tuch besteht aus Zeigern, die definieren, deren Parameter, Verhalten, und so weiter)
Zeiger sind einfach ein Speicherort im Speicher Platz. Es ist eine Adresse, die einen Speicherort im Speicher. Der "Typ" der Zeiger kennzeichnet die Interpretation der Nullen und Einsen in dieser Lage. Wenn Sie einen Zeiger-Zeiger, Sie haben eine Adresse von einer Adresse. Nichts von dem, was Sie haben, verweist auf eine Instanz einer Klasse. Allerdings, wenn Sie nicht initialisieren einer Klasse, wie 'MyCloth* c1 = new MyCloth();' Als Sie verwenden können, 'MyCloth* c2 = NULL;/*oder was auch immer*/ c1==c2;', um zu überprüfen, ob es die gleiche Instanz durch die Bestimmung, ob oder nicht, die zwei Zeiger auf den gleichen Speicher.Dies funktioniert NICHT mit virtueller Vererbung!

InformationsquelleAutor user2399378 | 2013-05-30

c++equality pointers

11

Können Sie testen, für das Objekt Identität durch den Vergleich der Adressen statt durch zwei Zeiger. Sie erwähnen Java; dies ist ähnlich der Prüfung, die beiden Referenzen gleich sind.
```
MyCloth* pcloth1 = ...
MyCloth* pcloth2 = ...
if ( pcloth1 == pcloth2 ) {
    //Then both point at the same object.
}   
```
Können Sie testen, für das Objekt Gleichheit durch das vergleichen der Inhalte zweier Objekte. In C++ ist dies in der Regel geschieht durch die Festlegung operator==.
```
class MyCloth {
   friend bool operator== (MyCloth & lhs, MyCloth & rhs );
   ...
};

bool operator== ( MyCloth & lhs, MyCloth & rhs )
{
   return ...
}
```
Mit dem operator== definiert, Sie können vergleichen, Gleichheit:
```
MyCloth cloth1 = ...
MyCloth cloth2 = ...
if ( cloth1 == cloth2 ) {
    //Then the two objects are considered to have equal values.
}   
```
Angesichts MyCloth *pcloth1, *pcloth2; wie würde man Vergleiche den Inhalt der beiden? Ihr Beispiel zeigt, wie man es für non-Zeiger nur.
@user2813274 -- if ( *pcloth1 == *pcloth2 ) ...
Wie können Sie sagen, wenn das überprüft ist, wo die Zeiger zeigen auf, oder wenn der Inhalt der beiden Standorte sind die gleichen?
Der Wert Ihrer pcloth1 ist eine Adresse. Der Wert von *pcloth1 ist ein MyCloth Objekt. Der Ausdruck *pcloth1 dereferenziert der Zeiger pcloth1. Da beide Operanden im Ausdruck sind MyCloth Objekte, die Inhalte werden überprüft, anstatt die Adressen.

InformationsquelleAutor Andy Thomas
4

Wenn Sie möchten, definieren Sie eine Methode mit der, um einen Vergleich von einer Menge von Objekten, Ihrer custome-Klasse. Zum Beispiel:
```
someClass instance1;
someClass instance2;
```
Können Sie dies durch eine überlastung des < - operators für diese Klasse.
```
class someClass
{

    bool operator<(someClass& other) const
    {
        //implement your ordering logic here
    }
};
```
Wenn das, was Sie wollen zu tun ist, vergleichen, und sehen, ob die Objekte sind buchstäblich das gleiche Objekt, die Sie tun können, ein einfacher pointer-Vergleich, um zu sehen, wenn Sie auf das gleiche Objekt zeigen. Ich denke, deine Frage ist schlecht formuliert, ich bin mir nicht sicher, was Sie für gehen.

EDIT:

Für die zweite Methode, es ist wirklich ganz einfach. Sie benötigen Zugriff auf die Speicheradresse des Objekts. Diese erreichen Sie in vielen verschiedenen Arten. Hier sind ein paar:
```
class someClass
{

    bool operator==(someClass& other) const
    {
        if(this == &other) return true; //This is the pointer for 
        else return false;
    }
};
```
Hinweis: ich weiß nicht, wie die oben genannten, in der Regel == Operatoren gehen mehr in die Tiefe als nur der Vergleich von Zeigern. Objekte können Objekte mit ähnlichen Eigenschaften ohne gleichen, aber das ist eine option. Sie können dies auch tun.
```
someClass *instancePointer = new someClass();
someClass instanceVariable;
someClass *instanceVariablePointer = &instanceVariable;


instancePointer == instanceVariable;
```
Dies ist nicht unsinnige und ungültige/falsch. Wenn es auch zu kompilieren, die je auf Ihre Fahnen, hoffentlich Ihr mit flags, die nicht erlauben würde!
```
instancePointer == &instanceVariable; 
```
Diese gültig ist und würde das Ergebnis false.
```
instancePointer == instanceVaribalePointer;  
```
Dies gilt auch und würde das Ergebnis false.
```
instanceVariablePointer == &instanceVariable;
```
Dies gilt auch und würde in WAHRE
```
instanceVariable == *instanceVariablePointer;
```
Diese würden mit dem = = - operator wir Sie oben definiert sind, um das Ergebnis der TRUE;

Der OP versucht zu testen Objekt-Identität oder Gleichheit, nicht vergleichen. Auch die OP gibt "MyCloth ist eine sehr komplexe Klasse und ich kann"t bauen eine isEqual-Funktion".
Die zweite Variante, die Sie beschreiben. Wie mache ich das?
Mit == zu vergleichen Zeiger wird überprüfen, dass Sie Punkt genau in der gleichen Position im Speicher.

InformationsquelleAutor ChrisCM

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.