Signatur der Operatoren?

vip*r

Ich hab diese Templatefunktion:

template<typename T1, typename T2> T1 mittelwert(T1 val1, T2 val2)
{
	return ((val1 + val2)/2);
}

In meiner Aufgabenstellung heißt es nun, dass ich diese Funktion in meiner eigenen Klasse myClass verwenden soll. Nun die Frage: Welche Operatoren muss ich dann in myClass zur Verfügung stellen? Und ich soll noch die Signatur der Operatoren angeben.

Ich weiß da grad so gar nicht was ich da machen soll. Könnt ihr mir da drauf helfen?

yihaaa

Also erst mal den + Operator und den / Operator. Ich würde es so versuchen:

T1 operator + ( const T1& rhs ) const;
T1 operator / ( const int& rhs ) const;

MfG

Edit: Stimmt du kannst dir das lhs spaaren...

icarus2

Oder noch besser so:

const T1 operator + ( const T1& rhs) const;

*Edit
Warum das const am Anfang? Damit erreichst du, dass z.B. bei

(a + b) = c

eine Fehlermeldung ausgegeben wird. Ist ja auch nicht sinnvoll der Ausdruck oben.

vip*r

Ich hab das jetzt mal so versucht:

class myClass
{
private:

public:
	template<typename T1, typename T2> T1 mittelwert(T1 val1, T2 val2)
	{
		return ((val1 + val2)/2);
	}

	const T1& operator + (const T1& l, const T2% r)
	{

	}
};

Ich weiß jetzt aber allerdings nicht mehr so recht, was ich in den Rumpf der Überladung schreiben soll... Was soll ich hier überhaupt überladen?

SeppJ

Ich bin mir sehr sicher, du hast die Aufgabe falsch verstanden. Du sollst sicherlich so etwas machen:

class myclass
{
  // Hier bitte selber ausfüllen
};

const myclass& operator+(const myclass& lhs, const myclass& rhs)
{
  // Hier bitte selber ausfüllen
}

template<typename T1, typename T2> T1 mittelwert(T1 val1, T2 val2)
{
    return ((val1 + val2)/2);
} 

int main()
{
 myclass wert1, wert2;
 // ...
 myclass mittel = mittelwert(wert1, wert2);
}

P.S.: In dem Beispielcode fehlt noch ein weiterer Operator, aber da kommst du bestimmt selber drauf.

vip*r

Meinst du so:

class myClass
{
private:

public:
	template<typename T1, typename T2> T1 mittelwert(T1 val1, T2 val2)
	{
		return ((val1 + val2)/2);
	}

	const myClass& operator + (const myClass l, const myClass r)
	{

	}
};

Damit hier aber nun l und r addiert werden können, muss ich doch unter private noch deklarieren, oder? Dafür muss ich doch aus der Klasse eine Template klasse machen, oder?

SeppJ

vip@r schrieb:

Meinst du so:

Nein, überhaupt gar nicht. Wo ist denn überhaupt der Unterschied zu deinem vorherigen Beitrag? Das ist einfach nur Unsinn. Das was ich meine (und sehr sicher auch der Aufgabensteller) ist doch schon in meinem Beitrag fast vollständig dargestellt. Alles werde ich dir bestimmt nicht vormachen.

TyRoXx

SeppJ schrieb:

Ich bin mir sehr sicher, du hast die Aufgabe falsch verstanden. Du sollst sicherlich so etwas machen:
class myclass
{
  // Hier bitte selber ausfüllen
};

const myclass& operator+(const myclass& lhs, const myclass& rhs)
{
  // Hier bitte selber ausfüllen
}

Der Rückgabetyp ist Quatsch.
So ist das einfacher:

class myclass
{
  // Hier bitte selber ausfüllen

  myclass &operator += (const myclass &rhs)
  {
	//...
	return *this;
  }
};

myclass operator+(myclass lhs, const myclass& rhs)
{
	return lhs += rhs;
}

SeppJ

TyRoXx schrieb:

Der Rückgabetyp ist Quatsch.

Stimmt. Das kommt davon, wenn man einfach Copy und Paste macht.

yihaaa

SeppJ musst du bei deinem ersten Beitrag nicht noch die Template-Parameter von mittelwert angeben?

myclass mittel = mittelwert< myclass, myclass >( wert1, wert2 );
}

MfG

SeppJ

yihaaa schrieb:

SeppJ musst du bei deinem ersten Beitrag nicht noch die Template-Parameter von mittelwert angeben?
myclass mittel = mittelwert< myclass, myclass >( wert1, wert2 );
}
MfG

Nein, die kann sich der Compiler hier selber erschließen.

Wobei ich übrigens die Signatur der Funktion lieber als

template<typename T1> T1 mittelwert(T1 val1, T1 val2);

oder

template<typename T1> T1 mittelwert(const T1& val1, const T1& val2);

hätte, da der Begriff "Mittelwert" eigentlich nur bei gleichartigen Werten Sinn macht. Aber das ist wohl eine Schwäche in der Aufgabenstellung.

camper

icarus2 schrieb:

Oder noch besser so:
const T1 operator + ( const T1& rhs) const;
*Edit
Warum das const am Anfang? Damit erreichst du, dass z.B. bei
(a + b) = c
eine Fehlermeldung ausgegeben wird. Ist ja auch nicht sinnvoll der Ausdruck oben.

Die Signatur anzupassen, um gegen einen unwahrscheinlichen Fehler, der in keinem direkten Zusammenhang mit der Funktion steht, gewappnet zu sein, war schon immer eine fragwürdige Empfehlung.
In C++11 hat diese Form sowieso keinen Platz mehr, weil
1. das Ergebnis nicht mehr für move-Konstruktion/-Zuweisung genutzt werden kann, und
2. die Implementierung eines entsprechenden Zuweisungsoperators mit ref-Qualifikation

Foo operator=(const Foo&) &

zum gleichen Ergebnis an der richtigen Stelle führt, schließlich wird die Zuweisung als problematisch dargestellt, nicht die Addition.

Abgesehen davon ist das Argument ohnehin nicht besonders überzeugend.

HugeInt a,b,c;
if ( ( ( a + b ) += c ) == 42 )

ist nicht völlig sinnlos. Das Verhalten von eingebauten Operatoren zu imitieren bedeutet ja schließlich nicht, dass die Menge zulässiger Argumente nicht erweitert werden darf.

krümelkacker

icarus2 schrieb:

Oder noch besser so:
const T1 operator + ( const T1& rhs) const;

Ich fand das "damals" schon nicht "besser" und heutzutage ist das eh nicht zeitgemäß. Du kannst dir sicher sein, dass Scott Meyers diesen "Tipp" nicht mehr mit in die nächste Auflage von "Effective C++" rettet, da damit move semantics stark eingeschränkt würde.