Frage zur Überladung von Operatoren



  • Hallo,

    ich habe das folgende Beispiel. Wenn ich den * Operator aber innerhalb der Klasse schreibe

    Vector3 operator * (const Vector3& v1, const Vector3& v2) {
    	return Vector3(v1.x * v2.x, v1.y * v2.y, v1.z * v2.z);
    }
    

    erhalte ich die Fehlermeldung "zu viele Parameter". Warum ist das so? Außerhalb der Klasse funktioniert es ohne Probleme.

    #include <iostream>
    
    class Vector3
    {
    public:
    	double x, y, z;
    
    	Vector3() { x = 0.0; y = 0.0; z = 0.0; }
    	Vector3(double x, double y, double z) {
    		this->x = x;
    		this->y = y;
    		this->z = z;
    	}
    
    	// Operator * überladen innerhalb der Klasse
    	Vector3 operator * (const double val) {
    		return Vector3(this->x*val, this->y*val, this->z*val);
    	}
    
    	double getLength() const {
    		return sqrt(x * x + y * y + z * z);
    	}
    
    	void printVector() {
    		std::cout << "Vector3: x: " << x << " y: " << y << " z: " << z << std::endl;
    	}
    };
    
    // Operator + überladen ausserhalb der Klasse
    Vector3 operator + (const Vector3& v1, const Vector3& v2) {
    	return Vector3(v1.x + v2.x, v1.y + v2.y, v1.z + v2.z);
    }
    
    // Operator * überladen ausserhalb der Klasse
    Vector3 operator * (const Vector3& v1, const Vector3& v2) {
    	return Vector3(v1.x * v2.x, v1.y * v2.y, v1.z * v2.z);
    }
    
    int main() {
    	Vector3 v1 = Vector3(1.0, 1.0, 1.0);
    	Vector3 v2 = Vector3(1.0, 2.0, 3.0);
    
    	Vector3 v3 = v1 + v2;	// + überladen
    	Vector3 v4 = v2 * 2.0;	// * überladen
    	Vector3 v5 = v3 * v4;	// * überladen
    
    	v1.printVector();
    	v2.printVector();
    	v3.printVector();
    	v4.printVector();
    	v5.printVector();
    
    	getchar();
    	return 0;
    }
    
    


  • Es wird bei der Definition innerhalb einer Klasse immer ein impliziter Paramter this mitgeliefert. Wie Du bereits in Deinem eigenem Code so verwendest.

    Vector v1, v2, r;
    
    r = v1.mult(v2);
    r = v1 * v2;
    

    sind effektiv das gleiche, wenn beides in der Klasse definiert wurde. Unterschiede gibt es zu einer freien Funktion, weil es dann auch Konversion beim ersten Parameter geben kann, was bei der Definition innerhalb der Klasse ausgeschlossen ist.

    Bei einer freien Funktion ruft man stattdessen

    r = mult(v1, v2);
    

    auf.



  • Warum wunderst du dich nicht, dass du für Vector3 operator * (const double val) { nur einen Parameter angeben musst?


Anmelden zum Antworten