C++ Standardoperatoren bei Klassen

[gugugs]

Ich steh gerade auf dem Schlauch und finde keine passende Frage die ich google gezielt stellen könnte.

Bei einer Klasse, dessen Attribute nur aus int Werten besteht. Wenn ich zwei Klassen diesen Typs "<", ">", ">=" oder "<=" vergleiche OHNE eigene Operatorüberladung, was passiert dann genau bei C++?

Welche Werte werden verglichen und unter welchen Umständen, wird welches Ergebnis geliefert?

Danke

 

[gugugs]

ja der Compiler meckert.

Ich komm grad einfach nicht weiter, möchte den Vergleichsoperator == überladen (was ja analog zu <, >, <= und >= sein sollte)

die Header sieht so aus:

bool operator==(DateTime* dateTime);

die cpp so

bool DateTime::operator ==(DateTime* dateTime) {
    if (this->jahr != dateTime->getJahr())
        return false;

    if (this->monat != dateTime->getMonat())
        return false;

    if (this->tag != dateTime->getTag())
        return false;

    if (this->stunde != dateTime->getStunde())
        return false;

    if (this->minuten != dateTime->getMinuten())
        return false;

    if (this->sekunden != dateTime->getSekunden())
        return false;

    return true;
}

Setze ich Breakpoints in die Funktion, werde diese nicht aufgerufen. Also ich denke diese Funktion wird also gar nicht erst aufgerufen, an was liegts?


//edit
ok, wenn es so aussieht:

bool DateTime::operator ==(DateTime& dateTime) {
    if (this->jahr != dateTime.getJahr())
        return false;

    if (this->monat != dateTime.getMonat())
        return false;

    if (this->tag != dateTime.getTag())
        return false;

    if (this->stunde != dateTime.getStunde())
        return false;

    if (this->minuten != dateTime.getMinuten())
        return false;

    if (this->sekunden != dateTime.getSekunden())
        return false;

    return true;
}

funktioniert das ganze, aber nur wenn ich beim vergleich keine Pointer benutze. Was ist an dieser Stelle die ordentlichste Lösung? Muss die Funktion so bleiben wie sie jetzt ist?

//edit2: eine globale funktion als operator machen, welche zwei Pointer entgegen nimmt?

 

[benediktibk]

Die Lösung mit den Referenzen finde ich persönlich besser, weil Pointer sollten nur dann herum gereicht werden, wenn man auch den Besitz von dem Objekt aus der Hand geben möchte. Außerdem möchte man in der Regel Objekte vergleichen wenn man Objekte vergleicht, und nicht Adressen. Die Variante mit den Pointern würde so ziemlich jeden der diese Klasse verwendet definitiv verwirren.
Trotzdem funktionieren beide Varianten, auch wenn ich auf den Fall die mit der Referenz empfehle:

#include <iostream>

using namespace std;

class Foo
{
public:
	bool operator==(const Foo &foo)
	{
		cout << "with reference" << endl;
		return false;
	}
	
	bool operator==(const Foo * const foo)
	{
		cout << "with pointer" << endl;
		return false;
	}
};

int main(int, char**)
{
	Foo one;
	Foo two;
	
	one == two;
	one == &two;
	
	return 0;
}

benediktibk@crub-gentoo ~ $ ./a.out 
with reference
with pointer

 

[gugugs]

Ja, das dachte ich mir beides schon so. Auch dass das arbeiten mit Referenzen an der Stelle bevorzugt werden sollte klingt einleuchtend. Trotzdem muss/will ich an dieser Stelle mit Zeigern arbeiten. Ich habe mich letztendlich für eine Funktion isEqual() entschieden

 

[benediktibk]

Warum musst oder willst du mit Zeigern arbeiten?