class CModulSharing{

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

		const CProcess *m_pProcess;
		const UINT m_iPriority;

		//Default Konstruktor
		SModulPriority(const CProcess* pP,const 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(const CProcess &Obj,std::string strGroup,const UINT iPriority=0){

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

	}
};

Allerding mekkert der Compiler das CPocess ein =operator braucht, aber ich mach doch hier nirgens eine zuweisung mit einem CPorcess Objekt?????

(und das Problem hier ist, daß der Compiler keinen Default-Operator anlegen kann, weil die Klasse SModulPriority zwei konstante Elemente enthält)

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

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

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.

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;
	//}

};

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).

this->data= ...;

geht ja dann nich

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

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.

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));

	}
};

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.

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.