Operatoren überladen

Hallo.

WOZU überlädt man Operatoren?

Ich habe im Studium folgende Aufgabe bekommen:
Ein Programm erstellen für eine Klasse Vektor - für 2dimensionale Vektoren und soll die Operatoren "+" und "-" überladen.

Hey, ich programmiere liebend gerne in Java aber jetzt das...

Habt ihr Beispiele, die einfach sind ... Will das verstehen.

Danke!

golden_jubilee

#include <iostream> 
#include "Vektor.h"

using namespace std; 
int main() 
{ 				

Vektor rep1 ;
rep1.setCordinates(2,2);
Vektor rep2;
rep2.setCordinates(2,2);

Vektor rep3;

rep3 = rep1+rep2;

cout << rep3.getX();

cin.ignore();

return 0;
}

ausgabe: - wie zu erwarten 4

header:

#pragma once

class Vektor
	{
	public:

		Vektor(void)
			{
			}

		~Vektor(void)
			{
			}

		void setCordinates (double x, double y){

			_x  = x;
			_y  = y;
			}
	double getX(){
		return _x;
		}

	double getY(){
		return _y;
	}
	Vektor operator + ( Vektor a){
		Vektor c;

		_x = a.getX() + _x;
		_y = _y + a.getY();
		return *this;
	}
	private:

		double _x;
		double _y;

	};

ich habe das mal geschrieben, weil wir gerade mit analytischer geometrie angefangen haben, da ist das nochmal ne gute übung
wie der - operator funktioniert kann man sich ja dann denken

Z2

Ne! Sorry, aber der operator+ ist kompletter Blödsinn. Du veränderst damit ja einen der beiden Summanden. Außerdem sollte operator+ immer eine freie Funktion sein, z.B. so:

Vector operator+ (const Vector& Left, const Vector& Right)
{
    return Vector (Left.getX()+Right.getX(), Left.getY()+Right.getY());
}

Damit das funktioniert, muß Vector noch um einen weiteren Konstruktor ergänzt werden, der x und y übergeben bekommt. Und die getX() und getY() Funktionen müssen const sein.

golden_jubilee

Z2 schrieb:

Ne! Sorry, aber der operator+ ist kompletter Blödsinn. Du veränderst damit ja einen der beiden Summanden. Außerdem sollte operator+ immer eine freie Funktion sein, z.B. so:
Vector operator+ (const Vector& Left, const Vector& Right)
{
    return Vector (Left.getX()+Right.getX(), Left.getY()+Right.getY());
}
Damit das funktioniert, muß Vector noch um einen weiteren Konstruktor ergänzt werden, der x und y übergeben bekommt. Und die getX() und getY() Funktionen müssen const sein.

ja, einer wird verändert... vlt nicht optimal
aber warum sollte es immer eine freie Funktion sein? -das finde ich unschön

finix

steff3 schrieb:

ja, einer wird verändert... vlt nicht optimal

hehe.. "nicht optimal" ist jetzt das neue "falsch" oder wie?

volkard

finix schrieb:

hehe.. "nicht optimal" ist jetzt das neue "falsch" oder wie?

"suboptimal" ist eigentlich das ersatzwort für codebeschreibende fäkalausdrücke.

Z2

Weil operator+ sonst unsymmetrisch wird. Nehmen wir an das folgende geht:

a + b

Dann würde man doch erwarten, daß auch das hier geht:

b + a

Wenn aber nun b von einem anderen Typ ist als a (und a einen Konstruktor hat, der b als Argument nimmt), geht das eben nicht mehr, wenn operator+ eine Member-Funktion ist.

Ok, so eine zweite Klasse haben wir in diesem Fall nicht und Vector hat auch keinen solchen Konstruktor. Aber was nicht ist, kann ja noch werden. Ich finde jedes Klassen-Design hochgradig fragwürdig, bei dem das Hinzufügen eines Konstruktors den operator+ dazu veranlaßt sich seltsam zu verhalten und darum bleibe ich bei meinem Standpunkt, daß operator+ unter allen Umständen eine freie Funktion sein sollte.

Th

Warum nennt ihr den Operator nicht gleich += ?!?

David_pb

Operator+ muss nicht frei sein. In dem Fall würde es nichtmal besonders viel Sinn machen. Bei einer Skalarmultiplikation allerdings schon:

Vector a( 1.0f, 2.0f, 3.0f );
float  skalar = 10.0f;

a = a * skalar;
a = skalar * a; // diesda funktioniert nur per freiem operator +

Allerdings ist die oben genannte Version tatsächlich sehr seltsam:

Vektor operator + ( Vektor a){ // const Vector &a wär schöner
      Vektor c;

      _x = a.getX() + _x;  // _x und _y sollten hier NICHT geändert werden, das ist Sache des += Operators
      _y = _y + a.getY();
      return *this; // whatever... 
}

Da keine Memberattribute geändert werden sollte die Funktion konstant sein, also:

Vektor operator +( const Vektor &a ) const
{
    return Vektor( _x+a.x, _y+a.y );
}

Oder eben ausgelagert (frei), wie oben erwähnt.

grüße