ich habe von oben genanntem Thema anscheined noch etwas nicht verstanden.....
Wenn ich einen Operator in meiner Header datei überladen möchte,
funktioniert das so wunderbar:

Vector operator = (const Vector &v)	{x = v.x; y = v.y; z = v.z; return *this;}

warum meckert er wenn ich ihm mehr als zwei Parameter geben möchte, wie z.B.

Vector operator + (const Vector &a, const Vector &b)	{a.x + b.x, a.y + b.y, a.z + b.z; return *this;}

Wenn du x,y, z als Objekte der Klasse Vector hast.
Dann wird
z = x + y;
ausgewertet zu
z = x.operator+(y);
Das heisst die Funktion wird auf dem ersten Objekt aufgerufen.

warum meckert er wenn ich ihm mehr als zwei Parameter geben möchte, wie z.B.

Weil innerhalb der Klasse deklariert es in wirklichkeit 3 Parameter sind, this wird ja auch (unsichtbar) übergeben.
Raus aus der Klasse und drunterschreiben.

class Vector{
...
};
Vector operator + (const Vector &a, const Vector &b)	{Vector c; c.x=a.x+b.x; c.y=a.y+b.y; c.z=a.z+b.z; return c;}

Vector operator + (const Vector &a) {
	x + operator + (a.x); 
	y + operator + (a.y);
	z + operator + (a.z);
	return *this;

}

ich frage extra weil

Vector operator + (const Vector &a) {
       x = x.operator + (a.x);
       .....
}

funktioniert net^^

Vector operator + (const Vector &a) {
	x + a.x;
	y + a.y;
	z + a.z;
	return *this;
	
}

Ganz großer Blödsinn. Der Operator tut nichts und gibt nur eine Kopie von *this zurück - ohne dass sich irgendwas ändert.

Jetzt schon....

Vector Vector::operator + (const Vector &v) {
    x = x + v.x;
    ......

aber schon gehts weiter:

wenn ich jetzt biespielsweise eine Operator überladung vorgenommen habe wie diese:

Vector Vector::operator / (const float f) {
	x = x / f;
	y = y / f;
	z = z / f;
	return *this;
}

Wieso kann das Programm dann das hier nicht?

// to normalize a vector (lenth 1)
Vector Vector::VectorNormalize(const Vector &v)	{
	return v / sqrtf(v.x * v.x + v.y * v.y + v.z * v.z);
}

da steht ja dann nix anderes als Vector / float
da hab ich ihm ja schon gesagt was er damit machen soll
nämlich

x/f
y/f
z/f

greetz KN4CK3R

Aber wenn ich ne lokale kopie erzeuge, dann ist die hinterher nicht mehr gültig....

Natürlich ist sie gültig, wenn du sie zurückgibst. Schau dir nochmal den von mir geposteten Link an, wie man die Operatoren standardmäßig implementiert.

Wenn ich nen Vektor in die Methode stecke, und ihn normalisieren möchte, dann will ich doch das v verändert wird...

Beim Normalisieren kann man drüber streiten, aber bei c = a + b erwartet keiner, dass a verändert wird (ich wiederhole mich).

Lybrial schrieb:

Aber wenn ich ne lokale kopie erzeuge, dann ist die hinterher nicht mehr gültig....

Natürlich ist sie gültig, wenn du sie zurückgibst. Schau dir nochmal den von mir geposteten Link an, wie man die Operatoren standardmäßig implementiert.

Wenn ich nen Vektor in die Methode stecke, und ihn normalisieren möchte, dann will ich doch das v verändert wird...

Beim Normalisieren kann man drüber streiten, aber bei c = a + b erwartet keiner, dass a verändert wird (ich wiederhole mich).

3.2 operator+, -, *, /, %

Semantik: Addition, Subtraktion, Multiplikation, Division, Modulo. Es wird ein neues Objekt mit dem Ergebniszustand erzeugt. Die folgenden Ausführungen gelten jeweils analog für -, *, / und %.
Übliche Deklaration:

C/C++ Code:
const X operator+(X const& lhs, X const& rhs);
C/C++ Code:
const X operator+(X const& lhs, X const& rhs);

Übliche Implementierung:

C/C++ Code:
const X operator+(X const& lhs, X const& rhs)
{
/* Erzeugen eines neuen Objektes, dessen Attribute gezielt einzeln gesetzt werden. Oder: */
X tmp(lhs); //Kopie des linken Operanden
tmp += rhs; //Implementierung mittels des +=-Operators
return tmp;
}
C/C++ Code:
const X operator+(X const& lhs, X const& rhs)
{
/* Erzeugen eines neuen Objektes, dessen Attribute gezielt einzeln gesetzt werden. Oder: */
X tmp(lhs); //Kopie des linken Operanden
tmp += rhs; //Implementierung mittels des +=-Operators
return tmp;
}

In vielen Fällen macht das Vorhandensein des operator+ auch die Existenz des operator+= sinnvoll, um die kürzere Schreibweise a += b an Stelle von a = a + b zu ermöglichen. Um das Verhalten beider Operatoren konsistent zu halten ist es daher üblich, operator+ im Sinne von operator+= zu implementieren wie gezeigt. Um eine implizite Typumwandlung des ersten Operanden zu ermöglichen werden die binären arithmetischen Operatoren üblicherweise als freie Funktionen definiert.
Wird der Operator nicht mittels operator+= implementiert, benötigt er meist Zugriff auf private Attribute von X. In dem Fall wird er häufig als friend der Klasse deklariert oder greift auf eine öffentliche Methode der Klasse zu, die die eigentliche Operation ausführt:

C/C++ Code:
const X X::plus(X const& rhs) const; //Implementiert die Addition
const X operator+(X const& lhs, X const& rhs)
{
return lhs.plus(rhs);
}
C/C++ Code:
const X X::plus(X const& rhs) const; //Implementiert die Addition
const X operator+(X const& lhs, X const& rhs)
{
return lhs.plus(rhs);
}

Das ist die betreffende Stelle, allerdings werden hier für operator + zwei Parameter reingesteckt, was garnicht möglich ist wenn man sie (wie es sauberes programmieren ist) außerhalb der Klasse definiert.

Das ist die betreffende Stelle, allerdings werden hier für operator + zwei Parameter reingesteckt, was garnicht möglich ist wenn man sie (wie es sauberes programmieren ist) außerhalb der Klasse definiert.

Doch, als freie Funktion benötigt operator+ genau zwei Parameter.

Tritt im Header auf, dort ist die Überladung deklariert
und im entsprechenden cpp File definiert!

Error: "must take either zero or one argument"

Tritt im Header auf, dort ist die Überladung deklariert
und im entsprechenden cpp File definiert!

Glaub ich dir nicht. Hast du den Operator innerhalb einer Klasse deklariert?

class lCVector3 {					

	public:
		struct {
			float x;
			float y;
			float z;
		};							// coords

		lCVector3();													// standart
		lCVector3(const lCVector3 &v);									// copy
		lCVector3(const float f);										// normal each element, same number
		lCVector3(const float _x, const float _y, const float _z);		// normal each element, different number
		lCVector3(const float *pfComponent);							// normal array with three elements

		// operation assignments
		lCVector3 operator = (const lCVector3 &v);
		lCVector3 operator += (const lCVector3 &v);
		lCVector3 operator -= (const lCVector3 &v);
		lCVector3 operator *= (const lCVector3 &v);
		lCVector3 operator *= (const float f);
		lCVector3 operator /= (const lCVector3 &v);
		lCVector3 operator /= (const float f);

		// arithmetical operations
		lCVector3 operator + (const lCVector3 &v);
		lCVector3 operator - (const lCVector3 &v);
		lCVector3 operator * (const lCVector3 &v);
		lCVector3 operator * (const float f);
		lCVector3 operator / (const lCVector3 &v);
		lCVector3 operator / (const float f);

		// compare operations
		bool operator == (const lCVector3 &v);
		bool operator != (const lCVector3 &v);

		// function declaration
		float		lCVector3Length(const lCVector3 &v);
		float		lCVector3LengthSq(const lCVector3 &v);
		lCVector3	lCVector3Normalize(const lCVector3 &v);
		lCVector3	lCVector3NormalizeEx(const lCVector3 &v);
		lCVector3	lCVector3Cross(const lCVector3 &v1, const lCVector3 &v2);
		float		lCVector3Point(const lCVector3 &v1, const lCVector3 &v2);
		float		lCVector3Angle(const lCVector3 &v1, const lCVector3 &v2);
		lCVector3	lCVector3InterpolateCoords(const lCVector3 &v1, const lCVector3 &v2, const float p);
		lCVector3	lCVector3InterpolateNormal(const lCVector3 &v1, const lCVector3 &v2, const float p);
};

wenn man sie (wie es sauberes programmieren ist) außerhalb der Klasse definiert.

Ansonsten haben dir auch schon genug Leute gesagt, dass der Operator als freie Funktion definiert werden soll und eben nicht in einer Klasse.

Ist doch normal.....

Und genau so hab ichs gemacht,
sehe dir den letzten Post von mir an, da hab ich
mal den header gepostet, alles nur deklarationen
nix definiert.

Man deklariert innerhalb der Klasse
und definiert außerhalb.

Nein, eine Funktion ist entweder innerhalb einer Klasse deklariert und definiert oder außerhalb. Beides gibts nicht. Du hast die Definition der Funktion einfach nur räumlich getrennt von der Klassendefinition, aber die Signatur der Funktionsdefinition sagt ganz klar, dass die Funktion zur Klasse gehört.

class Foo
{
    void bar();
}

void Foo::bar()    // bar gehört zu Foo
{
}

void baz()    // freie Funktion
{
}

Ein Beispiel das ich gemacht habe, eine Log-Klasse:

Header

#ifndef __LOGHANDLER
#define __LOGHANDLER

#include <stdio.h>
#include "Singleton.hpp"

enum LOGLEVEL {
    L_OK,
    L_ERROR,
    L_FATAL_ERROR,
    L_INFO
	L_WARN
	L_DEBUG
};

class CLogHandler : public TSingleton<CLogHandler> {

    public:
        CLogHandler();                                                                       //constructor
        ~CLogHandler();                                                                      //destructor
        void createLogHandler(const char *LogName);                                          //new logfile
        void message(const char *File, int Line, const char *Time, const char *msg, LOGLEVEL level); //writes message into logfile

    private:
        FILE *m_Logfile;                                                                     //the FILE ;)
        const char* convertEnum(LOGLEVEL level);                                             //to convert the enums ;)
};

#endif

die cpp dazu, in der die Methoden definiert sind:

#include <iostream>
#include <string.h>
#include "LogHandler.hpp"

using namespace std;

//constructor
CLogHandler::CLogHandler(){};

//destructor
CLogHandler::~CLogHandler(){
    message(__FILE__, __LINE__, __TIME__,"End of logfile!", L_INFO);
    fclose(m_Logfile);
}

//create logfile and write head
void CLogHandler::createLogHandler(const char *LogName) {

    try {
        m_Logfile = fopen(LogName, "w");//fopen = fileopen, w = write

        if (m_Logfile == NULL) {
            throw "Datei konnte nicht geoeffnet werden!";
        }
    } catch (char *ErrorString) {
        cout << "Fehler aufgetreten: " << ErrorString << endl;
        cout << "Programm wird beendet!" << endl;
        exit(0);
    }

    message(__FILE__, __LINE__, __TIME__, "THIS IS THE LOGFILE!!!", L_INFO);

    //print out actual build-configuration
    #ifdef _DEBUG
        message(__FILE__, __LINE__, __TIME__, "BUILD: DEBUG", L_INFO);
    #else
        message(__FILE__, __LINE__, __TIME__, "BUILD: RELEASE", L_INFO);
    #endif

    //close logfile and open it again with append
    fclose(m_Logfile);
    try {
        m_Logfile = fopen(LogName, "a");//fopen = fileopen, a = append

        if (m_Logfile == NULL) {
            throw "Datei konnte nicht geoeffnet werden!";
        }
    } catch (char *ErrorString) {
        cout << "Fehler aufgetreten: " << ErrorString << endl;
        cout << "Programm wird beendet!" << endl;
        exit(0);
    }
}

//message method to print a message into the logfile with LOGLEVEL
void CLogHandler::message(const char *File, int Line, const char *Time, const char *msg, LOGLEVEL level) {
    fprintf(m_Logfile,"[<%s> - <%s>] at: <%20s>: <%d> <%s>\n", convertEnum(level), Time, File, Line, msg);
    fflush(m_Logfile);//forces instantly writing into the file
}

const char* CLogHandler::convertEnum(LOGLEVEL level) {
    switch(level) {
        case L_OK: return "INFO "; break;
        case L_ERROR: return "ERROR"; break;
        case L_FATAL_ERROR: return "FATAL"; break;
        case L_INFO: return "INFO "; break;
		case L_WARN: return "WARN "; break;
		case L_DEBUG: return "DEBUG"; break;
        default: return "INFO "; break;
    }
}

und das funktioniert herrlich

class lCVector3 {

Schrecklicher Name. Was sollen l und C bedeuten?

struct {
			float x;
			float y;
			float z;
		};							// coords

Warum packst du das in ein struct? Warum benutzt du float statt double?

l		lCVector3(const lCVector3 &v);									// copy

Wofür musst du diesen Konstruktor explizit definieren? Danke an die Regel der großen Drei.

lCVector3(const float f);										// normal each element, same number

Was soll "normal" bedeuten? Komischer Satz

lCVector3(const float *pfComponent);							// normal array with three elements

Schlechter Stil. Übergib ein std::array, wenns denn unbedingt sein muss, Hauptsache du hast eine sinnvolle Größenüberprüfung.

// operation assignments
		lCVector3 operator = (const lCVector3 &v);

Siehe Kommentar zum Copy-Konstruktor.

lCVector3 operator *= (const lCVector3 &v);

Wie ist die Multiplikation von zwei Vektoren definiert?

lCVector3 operator /= (const lCVector3 &v);

Wie ist die Division von zwei Vektoren definiert?

// arithmetical operations
		lCVector3 operator + (const lCVector3 &v);
		lCVector3 operator - (const lCVector3 &v);
		lCVector3 operator * (const lCVector3 &v);
		lCVector3 operator * (const float f);
		lCVector3 operator / (const lCVector3 &v);
		lCVector3 operator / (const float f);

		// compare operations
		bool operator == (const lCVector3 &v);
		bool operator != (const lCVector3 &v);

Als freie Funktionen definieren.

// function declaration
		float		lCVector3Length(const lCVector3 &v);
		float		lCVector3LengthSq(const lCVector3 &v);
		lCVector3	lCVector3Normalize(const lCVector3 &v);
		lCVector3	lCVector3NormalizeEx(const lCVector3 &v);

Schlechte Namen, was soll lCVector3? Warum kürzt du die wesentlichen Teile ab? Ich weiß nicht, was du mit NormaliseEx meinst.

lCVector3	lCVector3Cross(const lCVector3 &v1, const lCVector3 &v2);
		float		lCVector3Point(const lCVector3 &v1, const lCVector3 &v2);
		float		lCVector3Angle(const lCVector3 &v1, const lCVector3 &v2);

Hier hast du wiederum drei Parameter, nämlich this, v1 und v2. Was ist das Kreuzprodukt dreier Vektoren? Point ist ein schlechter Name, den versteht man nur, weil Cross direkt drübersteht.

lCVector3	lCVector3InterpolateCoords(const lCVector3 &v1, const lCVector3 &v2, const float p);
		lCVector3	lCVector3InterpolateNormal(const lCVector3 &v1, const lCVector3 &v2, const float p);

Hiermit dasselbe. Die Namen sind auch ziemlich nichtssagen.d

Versteh ich jetzt nicht ganz, funktioniert es dann grundsätzlich nicht
wenn man das so macht oder ist das nur "unschön"

Lies dir dazu bitte nochmal den entsprechenden Abschnitt in deinem Buch durch. Ich denke, wenn du dir meine Erklärung nochmal langsam durchliest, solltest du es auch so verstehen.

Ein Beispiel das ich gemacht habe, eine Log-Klasse:

Hier sind wieder so viele verbesserungswürdige Sachen drin... Wieso hast du eine Funktion createLogHandler, die die Aufgabe des Konstruktors übernimmt, während der Konstruktor gar nichts macht? Wieso erbst du von Singleton? Und so weiter, das geh ich nicht auch noch alles durch.

Aber zur Log-Klasse:

Erbt von Singleton weil ich Singleton als Template Klasse schon implementiert hatte und meine Log-Klasse nur einmal exisitieren soll.

DErbt von Singleton weil ich Singleton als Template Klasse schon implementiert hatte und meine Log-Klasse nur einmal exisitieren soll.

Und warum musst du im Code garantieren, dass nur eine Instanz erstellt werden kann? Deine Implementierung der Klasse passt übrigens gar nicht zum Singleton-Pattern.

wenn ich das ganze so mache um zurück zu Vektor-Klasse zu kommen funzts:

Vector Vector::operator + (const Vector &v) {
	Vector *v1 = new Vector(x + v.x, y + v.y, z + v.z);
	return *v1;
}