Eine Klasse welche sich selbst enthalten kann... Kritik an Implementation:

BorisDieKlinge

Habe ein Klasse CAllocation, welche eine list von Elemente von Sich selbst enthalten kann bspw. baumstruktur... was meint ihr dazu was würde ihr bessere machen? Später soll die summe der Kinder Allocationen die Vater Allocation sein usw. :

//############################################################################################################
//
// Class: CAllocation
//
// Description: Represents the base Allocation Block of the Scheduler
// 
//############################################################################################################
class CAllocation : public CObject{

private:

	CAllocation *m_pParent;
	std::vector<CAllocation> m_vChilds;

public:

	double m_dStartTime;
	double m_dDuration;

	//Konstruktoren
	CAllocation():	m_dStartTime(0), 
					m_dDuration(0), 
					m_pParent(NULL) {}

	CAllocation(double dS,double dD) :	m_dStartTime(dS), 
										m_dDuration(dD),
										m_pParent(NULL){}

	//CAllocation(CAllocation *pP): m_pParent(pP){}

	CAllocation(const CAllocation &scr){
		this->operator =(scr);
	}

	CAllocation& CAllocation::operator = (const CAllocation &scr){	
		//kopieren
		m_pParent= scr.m_pParent;
		m_vChilds= scr.m_vChilds;
		m_dStartTime= scr.m_dStartTime;
		m_dDuration= scr.m_dDuration;

		return *this;
	}

	//Memberfunktionen
	void AppendChild(CAllocation &child){
		child.m_pParent=this;
		m_vChilds.push_back(child);
	}

	CAllocation* GetBasisAlloc(){
		CAllocation *pParent= m_pParent;
		while(pParent->m_pParent!=NULL)
			pParent= pParent->m_pParent;	
		return pParent;
	}

	virtual ~CAllocation() {
		m_vChilds.clear();
	}

};

vielleicht beim zuweiseungsoperator eine zuweiseung auf zuweiseung auf sich selbst überprüfen?
Mehr hab ich jetzt nich direkt geschaut

pumuckl

Mit Copy-CTOR und operator= wäre ich in dem Zusammenhang etwas vorsichtiger - schau dir mal beispielsweise folgenden Code an:

CAllocation* Father;
CAllocation* Child;

Father->AppendChild(Child);

CAllocation* Child2 = Child; 

//jetzt gilt: Child2->m_pParent == Father
//ABER: Child2 ist in Father->m_vChilds (sollte besser Children heißen)
//  nicht enthalten...

delete Father; // hier werden die Kopien im vector gelöscht, die originale bleiben aber erhalten

Child->GetBasisAlloc() // AUA - Segfault, da Father gelöscht und Child->m_pParent auf freigegebenen Speicher zeigt...

queer_boy

was gleich sofort auffällt: du solltest die elemente in der elementinitialisierungsliste immer in derselben reihenfolge initialisieren, wie sie in der klassendefinition vorkommen - könnte sonst in manchen situationen haarig werden, besser du gewöhnst es dir gleich an. du solltest dir überlegen, ob du wirklich diese namen willst (C... und m_p...) - aber das nur nebenbei.
dann: du könntest operator= und den copy-ctor sicherer machen - implementiere eine swap funktion und verwende

X &operator = (X const& x)
{
   X tmp(x);
   swap(tmp); //damit sollen die interna vertauscht werden, ohne dass du auf tiefe kopien angewiesen bist. s.u.
   return *this;
}

- macht es sicherer, v.a. weil du mit zeigern hantierst was mich zum letzten punkt bringt: du vermischst einerseits zeiger auf eltern und andererseits kopien von elementen. so passiert es dass ein father z.b. nur ein kind registriert hat und in wirklichkeit zehn kopien davon herumlaufen können, bzw. dass die kinder, die du gespeichert hast, in wahrheit nur kopien sind. inwiefern du das beabsichtig hast, weiß ich natürlich nicht.