Hallo,

Ich habe das Problem, dass ich Operatoren habe, die ein Objekt der Klasse CPerson wiedergeben, in der Klasse funktionieren diese eigentlich, außerhalb bekomm ich die Fehlermeldung: "Operator '=' muss ein nicht-statisches Element sein"

Ich weis nicht warum das kommt, weil eigentlich hatte ich nichts von static geschrieben

h:

class CPerson

{

public:

	//Konstruktor und Destruktor

	CPerson(void);

	CPerson(CString FName, CString Name, double Gewicht, CPerson* lpPrev, CPerson* lpNext);

	CPerson(CPerson&);

	~CPerson(void);

	//Funktionen

	//gibt den Vorgänger

	CPerson* getPrev(void);

	//gibt den Nachfolger

	CPerson* getNext(void);

	//gibt den Vornamen

	CString getFName(void);

	//gibt den Namen

	CString getName(void);

	//gibt das Gewicht

	double getGewicht(void);	

	//gibt die ID

	int getID(void);

	//Operatoren

	CPerson operator = (CPerson&);

	friend CPerson operator = (CPerson&, CPerson&);

	//Klassenvariable

	static int s_nCount;

private:

	// Member nimmt Name auf

	CString m_lpName;

	// Member nimmt Vornamen auf

	CString m_lpFName;

	// Member nimmt Gewicht auf

	double m_dGewicht;

	// Member ID der Person

	UINT m_unID;

	// Member nimmt Vorgänger auf

	CPerson* m_pPrev;

	// Member nimmt Nachfolger auf

	CPerson* m_pNext;

	// //Übergewicht, Normalgewicht, Untergewicht

	int m_nBMI;

};

cpp:

/////////////////////////////////////////////////////////////////////////////////////////////////////////////

//	Konstruktion/Destruktion

/////////////////////////////////////////////////////////////////////////////////////////////////////////////

CPerson::CPerson(void):m_lpFName(""), m_lpName(""), m_dGewicht(0)

, m_nBMI(0), m_unID(0)

{

	CPerson* m_pPrev = NULL;

	CPerson* m_pNext = NULL;

}

CPerson::CPerson(CString FName, CString Name, double Gewicht, CPerson* pPrev, CPerson* pNext):m_lpFName(FName), m_lpName(Name), m_dGewicht(Gewicht)

{

	CPerson* m_pPrev = new CPerson(*pPrev);

	CPerson* m_pNext = new CPerson(*pNext);

	s_nCount++;

	m_unID = (unsigned) s_nCount;

}


CPerson::CPerson(CPerson& Person)

{

	if (&Person != NULL)

	{

		this -> m_dGewicht = Person.m_dGewicht;

		this -> m_lpFName = Person.m_lpName;

		this -> m_lpName = Person.m_lpName;

		this -> m_pNext = NULL;

		this -> m_pPrev = &Person;

		this -> m_pPrev -> m_pPrev = this;

	}

}


CPerson::~CPerson(void)

{

	m_pPrev = NULL; delete m_pPrev;

	m_pNext = NULL; delete m_pNext;

}


/////////////////////////////////////////////////////////////////////////////////////////////////////////////

//	Operatoren

/////////////////////////////////////////////////////////////////////////////////////////////////////////////


CPerson CPerson::operator =(CPerson& rhs)

{

	this -> m_dGewicht = rhs.getGewicht();

	this -> m_lpFName = rhs.getFName();

	this -> m_lpName = rhs.getName();

	this -> m_pNext = new CPerson(*(rhs.m_pNext));

	this -> m_pPrev = new CPerson(*(rhs.m_pPrev));

	return *(this);

}


CPerson operator =(CPerson& rhs, CPerson& lhs)

{

	lhs.m_dGewicht = rhs.getGewicht();

	lhs.m_lpFName = rhs.getFName();

	lhs.m_lpName = rhs.getName();

	lhs.m_pNext = new CPerson(*(rhs.m_pNext));

	lhs.m_pPrev = new CPerson(*(rhs.m_pPrev));

	return lhs;

}

Der normale Operator geht im Kopierkonstruktor. (In der Klasse)

Beim anderen (mit rhs und lhs) kommt immer die obengenannte Fehlermeldung.

Warum willst du mit dem = Operator ein Object deiner Klasse zurückgeben?

#include <iostream>


using namespace std;


class A

{

public:

	A(int a, int 

	{

		j = a;

		l = b;

	}

	operator=(A a)

	{

		j = a.j;

		l = a.l;

	}

	int j,l;

};


int main()

{

	A a(2,3),b(5,6);

	a = b;

	cout<<a.j<<"/"<<a.l<<endl;

	return 0;

}

[/PHP]

Das hier klappt zum Beispiel.

außerhalb bekomm ich die Fehlermeldung: "Operator '=' muss ein nicht-statisches Element sein"

Ich weis nicht warum das kommt, weil eigentlich hatte ich nichts von static geschrieben

Aber du hast einen Zuweisungsoperator, der kein Element ist. Und das ist nicht erlaubt.

Warum willst du mit dem = Operator ein Object deiner Klasse zurückgeben?

Der Zuweisungsoperator sollte eine konstante Referenz auf das Objekt selbst zurückgeben, damit eine Verkettung der Operatoren so wie bei den eingebauten Typen möglich ist.

Das hier klappt zum Beispiel.

Ist aber nicht besonders schön. Erstens musst du einen Rückgabetyp angeben - dein Compiler macht vermutlich int draus, was er nicht sollte - und zweitens sollte der Parameter eine konstante Referenz sein, damit keine unnötige Kopie gemacht wird. Wenn man den op= über den Copy-CTor implementiert, hätte man sonst sogar eine Endlosrekursion.

Aber du hast einen Zuweisungsoperator, der kein Element ist. Und das ist nicht erlaubt.

Deswegen hab ich den als friend deklariert (damit der auch von anderen Objekten, die nicht der Klasse angehören übernommen werden können)

Deswegen hab ich den als friend deklariert (damit der auch von anderen Objekten, die nicht der Klasse angehören übernommen werden können)

Durch die friend-Deklaration erreichst du nur, dass dieser Operator auf die protected- und private-Member der Klasse zugreifen kann.

Der Standard sagt, dass Zuweisungsoperatoren Member sein müssen, darum kommst du nicht herum.