*.h
#ifndef _operator_h_
#define _operator_h_
using namespace std;

class Rechteck
{
	int SeiteA;
	int SeiteB;
public:
	Rechteck(int sA,int sB);
	bool operator==(Rechteck y);
	int operator+(Rechteck z);
	friend bool operator==(Rechteck &x,Rechteck &y);
	void print();
	friend int operator+(Rechteck &x,Rechteck &y);

};

#endif

*.cpp
#include <iostream>
#include "op_header.h"
using namespace std;

Rechteck::Rechteck(int sA,int sB)
{ 
	SeiteA=sA;
	SeiteB=sB;
}
inline void Rechteck::print()
{
	cout << "\nSeite A= " << SeiteA << "\n";
	cout << "\nSeite B= " << SeiteB << "\n";
	cin.ignore();
}

bool Rechteck::operator ==(Rechteck y)
{
	if(this->SeiteA==y.SeiteB && this->SeiteB == y.SeiteA)
		return true;
	else
		return false;
}

bool operator==(Rechteck &a, Rechteck &b)
{
	return( a.SeiteA==b.SeiteB && a.SeiteB==b.SeiteA);
}

int operator+(Rechteck &a, Rechteck &b)
{
	return a.SeiteA+a.SeiteB+b.SeiteA+b.SeiteB;
}

int Rechteck::operator +(Rechteck z)
{
	return this->SeiteA+z.SeiteB+this->SeiteB+z.SeiteA;
}

int main(void)
{
	Rechteck z(2,2);
	Rechteck y(2,2);
	if (z==y) // <-******_____------**++++++++++++****-----********HIER
		cout <<"jouu";

	z.print();
	cout <<"\n look == : " << y.operator==(z);
	cout <<"\n look == 2nd: " << operator==(z,y);
	cout <<"\n look + : " << y.operator +(z);
	cout <<"\n look + 2nd : " << operator +(z,y);

	cin.ignore();
}

Es geht um die markierte Zeile. kann ich durch so etwas nicht die operatorFkt's angeben oder hab ich da einfach nur en Fehler gemacht?? Wenn nein weshalb benutzt man denn die operatorenFunktionen?

mfG
Phrua@

bool Rechteck::operator ==(Rechteck y)
{
    if(this->SeiteA==y.SeiteB && this->SeiteB == y.SeiteA)
        return true;
    else
        return false;
}

und

bool operator==(Rechteck &a, Rechteck &b)
{
    return( a.SeiteA==b.SeiteB && a.SeiteB==b.SeiteA);
}

Der Compiler weiß dann wenn du z==y schreibst nicht mehr, welche von den beiden Funktionen er aufrufen soll. Wenn du bloß eine der beiden Funktionen im Quellcode lässt kannst du den Test auf Gleichheit so anstellen, wie du das auch bei normalen Variablen kennst: also z==y. Das funktioniert auch beim +-Operator, aber dann musst du auch ein Klassenobjekt zurückgeben. Wenn du zum Beispiel so einen Text in deinen Code schreiben würdest:

z+y;

Und du würdest auch eine von den beiden Funktionen die den +-Operator überladen rausnehmen, würde der Compiler nicht meckern, aber du würdest ein völlig sinnloses Ergebnis rauskommen, nämlich ein int-Wert. Das ist in etwa so wie wenn du eine Birne plus 2 Birnen rechnest und bekommst als Ergebnis einen Apfel.
Deshalb überlädt man ja auch die Operatoren, damit man mit Klassen fast so rechnen kann wie mit normalen Variablen.
Deshalb ist das auch relativ sinnlos:

y.operator==(z);
operator==(z,y);
y.operator +(z);
operator +(z,y);

Da hätte man genau so gut normale Funktionen schreiben können .

MfG