Wieso bruach hier meine Klasse ein Zuweisungsoperator?

[BorisDieKlinge]

Was meinsdu mit Default-Operator? Default-Konsturktor oder?

"instanciated from here" Liste woher bekomm ich di in VS 2003?

[BorisDieKlinge]

ERROR: Die logische Konstanz wird hier bereits durch die die Initialisierung im Konstruktor und das Fehlen eines Interfaces zur Änderung dieser Member vermittelt.

Für die klasse CProcess wird doch automatisch ein Zuweisungsoperator erzeugt.. der müsste doch genügen!

[CStoll]

BorisDieKlinge schrieb:

Was meinsdu mit Default-Operator? Default-Konsturktor oder?

Damit meine ich die default-angelegten Memberfunktionen, die jeder C++ Compiler im Ernstfall für dich erzeugt (bzw. erzeugen will) - operator=, copy-Ctor und Dtor.

@logische Konstanz: Es gibt keine Methoden, die die Member ändern können (OK, die Tatsache, daß sie public sind, könnte da kontraproduktiv sein) und in der set<> werden sowieso nur const SModulPriority-Objekte untergebracht, also ist es unnötig, die Member noch konstant zu setzen.

[BorisDieKlinge]

ok danke....

Aber wieso muss ich den zuweisungoperator selber schreiben, bei der klasse CProcess kann der "automatisch" erzeuge von compiler doch verwendet werden???

Wie sieht der zuweisungoperator eine abgeleiten klasse aus?

Hier die Klassen:

//#####################################################################################
//
// Class:			CModul
// Name:			Systemmodul als abstrakte Basisklasse (Handler,Processmodul)
// Description:		Basismodul Parameter 
//
//#####################################################################################
class CModul{

protected:

	//Modul ID
	const UINT m_iModulID;

	//Modulname
	const std::string m_strName;

	//Modul bereit/aktiviert!
	BOOL m_boReady;

public:

	//Konstruktor
	CModul(UINT iD=1,std::string strN="NONAME") :	m_iModulID(iD), 
													m_strName(strN),
													m_boReady(true){

	}
	////Kopie-Konstruktor

	CModul(const CModul &scr):	m_iModulID(scr.m_iModulID), 
								m_strName(scr.m_strName),
								m_boReady(scr.m_boReady){ 
	//	
	//	
	}

	//CModul& operator=(const CModul & scr){
	//
	//	if(this!= &scr){

	//		this->m_boReady= scr.m_boReady;
	//		this->m_iModulID= scr.m_iModulID;
	//		this->m_strName(scr.m_strName);
	//	}
	//	return *this;
	//}
	//Destruktor
	virtual ~CModul()=0{}

	virtual inline const BOOL &isReady() { return m_boReady; }
	virtual inline const UINT &ID() { return m_iModulID; }

};

//#####################################################################################
//
// Class:			CProcess
// Name:			Processmodul
// Description:		Klasse definiert Processmodulkonfiguration und beinhaltet Modulrezepte
//
//#####################################################################################
class CProcess : public CModul{

public:
	//Modulpriorität gegenüber Alternativmodule
	//int m_iPriority;

	CProcess(UINT iD=-1,std::string strN="NONAME"/*,UINT iP=0*/): CModul(iD,strN)/*	,	
															m_iPriority(iP)*/{}

	//Sortierkriteriumfunktion std:set
	//bool SortPriority(const CProcess &scr){
	//	
	//	return (m_iPriority > scr.m_iPriority) ? true : false;
	//
	//
	//}

	//bool operator< (const CProcess &scr) const {
	//	return (m_iPriority < scr.m_iPriority) ? true : false;
	//}

};

[CStoll]

BorisDieKlinge schrieb:

ok danke....

Aber wieso muss ich den zuweisungoperator selber schreiben, bei der klasse CProcess kann der "automatisch" erzeuge von compiler doch verwendet werden???

Nein, kann er nicht. Der default-generierte Operator kopiert deine Klasse elementweise - und das funktioniert nicht mit Referenzen und konstanten Membern (und mit Klassen, die selber keinen erreichbaren Zuweisungsoperator haben).

[BorisDieKlinge]

hmm.. ok, aber wie kann aich ein zuweisungsoperator schreiben, wenn ich member variaben const sin?

this->data= ...;

geht ja dann nich

[CStoll]

Ja, da stehst du vor dem selben Problem wie der Compiler - du kannst einem konstanten Element nichts zuweisen. Die Lösung ist, entweder einen Dummy-Operator anzulegen, der nichts macht, oder das const bei den Membern wegzulassen.

(theoretisch geht auch noch pl*** - aber das dürfte bereits an der Grenze der Legalität liegen)

[camper]

BorisDieKlinge schrieb:

hmm.. ok, aber wie kann aich ein zuweisungsoperator schreiben, wenn ich member variaben const sin?

this->data= ...;

geht ja dann nich

Warum sind sie denn überhaupt const? Und was soll die Zuweisung bei dieser Klasse logisch darstellen. Das sind die Fragen, die sich mir zuerst stellen. Implementationstechniken sind da erst einmal zweitrangig.

BorisDieKlinge schrieb:

Aber wieso muss ich den zuweisungoperator selber schreiben, bei der klasse CProcess kann der "automatisch" erzeuge von compiler doch verwendet werden???

Es ist wichtig, die Dinge auseinanderzuhalten. Der Zuweisungsoperator wird immer implizit deklariert, wenn du selbst keinen deklarierst. Implizit definiert wird der implizit deklarierte Zuweisungsoperator erst, wenn er benutzt wird. Ein implizit deklarierter Zuweisungsoperator ist aber möglicherweise nicht (implizit) definierbar, weil entweder Member const sind (und der Zuweisungsoperator des betreffenden Members nicht const ist, was eher ungewöhnlich wäre), oder auf die Zuweisungsoperatoren der Baisklassen oder Member nicht zugegriffen werden kann (sie existieren - d.h. sie wurden (wenigstens implizit) deklariert - ja in jedem Falle). In diesem Falle ist das Programm fehlerhaft - an dem Punkt, an dem der Zuweisungoperator benutzt wird. Es ist aber erst einmal kein Fehler, eine Klasse zu haben, die nicht zugewiesen werden kann.

Der implizit definierte Zuweisungsoperator ist keine magische Blackbox, er tut nichts weiter, als die Zuweisungsoperatoren der Basisklassen und Member aufzurufen - deshalb ist er, nebenbei gesagt, im Allgemeinen auch nicht exceptionsicher.

[BorisDieKlinge]

also ich habe eine std:list mit CProcess Elemente, deren ID eindeutig sind ,deswegen "const"!

Also zweites will ich die Module in gruppen mit proritäten gruppieren wollen (siehe oben CModulSharing! Aber darin speicher bzw. hantiere ich ja nur die Pointer auf die eindeutigen Objekte, deswegen frag ich ja wieso ich ein zuweisungsoperator brauche?

class CModulSharing{

	//Struktur definiert Gruppenelement , Modulreferenz + Priorität entsprechend des
	//Gruppen Name
	struct SModulPriority{

		CProcess *m_pProcess;
		UINT m_iPriority;

		//Default Konstruktor
		SModulPriority(CProcess* pP, UINT iP=0) : m_pProcess(pP),
												  m_iPriority(iP){
		}
		//Sortierkriterum
		bool operator< (const SModulPriority &scr) const {
			return (m_iPriority < scr.m_iPriority) ? true : false;
		}

	};

	//Groupierungen
	std::map<std::string,std::set<SModulPriority> > m_Grouping;

public:

	void addToGroup(CProcess &Obj,std::string strGroup,UINT iPriority=0){

		m_Grouping[strGroup].insert(SModulPriority(&Obj,iPriority));

	}
};

[CStoll]

BorisDieKlinge schrieb:

also ich habe eine std:list mit CProcess Elemente, deren ID eindeutig sind ,deswegen "const"!

Besonders eindeutig sind die IDs ja nicht, wenn sie alle mit 1 vordefiniert werden
In dem Fall würde ich die IDs wohl aus einer statischen Variable heraus initialisieren, um echt eindeutige Werte zu erhalten - und bei der Zuweisung gar nicht anfassen:

class CProcess
{
  static int next_id
  const int m_id;
  string m_data;
public:
  CProcess(const string& d)
  : m_id(next_id++)
  , m_data(d)
  {}

  CProcess(const CProcess& other)
  : m_id(next_id++)
  , m_data(other.m_data)
  {}

  CProcess& operator=(const CProcess& other)
  {
    m_data=other.m_data;
    return *this;
  }
};

int CProcess::next_id=1;

Also zweites will ich die Module in gruppen mit proritäten gruppieren wollen (siehe oben CModulSharing! Aber darin speicher bzw. hantiere ich ja nur die Pointer auf die eindeutigen Objekte, deswegen frag ich ja wieso ich ein zuweisungsoperator brauche?

Da du mit Zeigern arbeitest, braucht diese Klasse nicht den op= der CProcess-Klasse. Aber das set<> benötigt den op= der SModulPriority - und der hat(te) die gleichen Schwierigkeiten mit den const-Membern.

[Simon2]

BorisDieKlinge schrieb:

also ich habe eine std:list mit CProcess Elemente, deren ID eindeutig sind ,deswegen "const"!...

"Eindeutigkeit" ist aber nicht das Kriterium für "const".
"const" ist etwas, wenn es über die gesamte Lebenszeit des Objekts (über diesen Bezeichner) nicht mehr verändert werden soll.
Bzgl. operator=() sehe ich da eigentlich nur 2 Alternativen:

• Entweder behält das "Zielobjekt" seinen vorherigen Wert (Hinweis auf "const)
• oder es übernimmt den des "Quellobjekts" (dann ist er aber nicht const).

Die Umsetzung ist dann auch klar: Im Ersten Fall ignoriert der operator=() einfach das entsprechende Member (das kann der "default-Operator" nicht wissen, deswegen muss man es manuell implementieren). Im Zweiten Fall macht man das Member nicht const (und der default-operator=() tut, was man will)...

Gruß,

Simon2.