Problem mit dynamischer datenstruktur?

BorisDieKlinge

Habe ein Objekt was eine datenstruktur enthält:

class Liste{

CAllocationNew *m_First_Son;

}

class CAllocationNew{

   CAllocationNew *m_pBrother;

}

das Objekt zeit auf das erste element der datenstruktur über den m_Frist_Son Pointer. die Elemente "CAllocationNew" sind dann über den Pointer m_pBrother Verkettet.

wenn ich nun ein Element am ende anfügen mit der methode :

void Liste::AddChild(CAllocationNew *pNew){

for(CAllocationNew *&pChilds= m_pFirst_Son; pChilds!=NULL; pChilds= pChilds->m_pBrother;		

pChilds= pNew;
}

wird immer wieder das erste Element überschrieben, obwohl er eigentlich die Elemt aneinader hängen soltle.. ich blick nich wieso das so nich geht!

CStoll

Eine Referenz ist ein Alias für die Variable. Das heißt, du hangelst dich effektiv mit dem Zeiger m_First_Son durch deine verkettete Liste. Aber an dieser Stelle brauchst du eine unabhängige Kopie von m_First_Son, die durch die Liste hangeln kann. (und du solltest einen Schritt weiter vorne aufhören zu hangeln)

for(CAllocationNew* pChilds= m_pFirst_Son; pChilds->m_pBrother!=NULL; pChilds= pChilds->m_pBrother);
pChilds->m_pBrother = pNew;

Edit: Und du brauchst eine Sonderbehandlung für den Fall, daß die Liste leer ist

BorisDieKlinge

@CStoll: Genau so hab ich es bisher gemacht.. dachte übe rdie referenz ist es eleganter...;)

if(m_pFirst_Son==NULL)
			m_pFirst_Son =pNew;
		else{
			//Allokation an bereit bestehenden Kinder hinten anhängen
			for(CAllocationNew *pChilds= m_pFirst_Son; pChilds->m_pBrother!=NULL; pChilds= pChilds->m_pBrother);
			pChilds->m_pBrother= pNew;
		}

wollte damit due lästigge "Sonderbehandung" umgehen..

oder wie würdet du dies noch edelt coden?

CStoll

BorisDieKlinge schrieb:

@CStoll: Genau so hab ich es bisher gemacht.. dachte übe rdie referenz ist es eleganter...;)

Man kann es auch übertreiben mit der Eleganz - besonders wenn man nicht weiß, was man da macht (und Referenzen sind - wie du gesehen hast - sehr leicht falsch einzusetzen)

oder wie würdet du dies noch edelt coden?

Eine Möglichkeit wäre es, an den Listenanfang einen Dummy-Knoten zu hängen, auf den m_First_Son dann zeigt. Ich würde vermutlich anstelle der selbstgebauten verketteten Liste eine std::list nehmen.

BorisDieKlinge

das mit std::list war schon letzte woche mein ansatz..

aber da ich einen iterator in meiner baumstruktur habe .. geht das nicht, da quasie jeder Knoten unter knoten haben kann...

Ich glaub das war sogar damals du der mit den tip gegeben hat mit den Father,Broher,First_Son pointer.. zu iterieren...

die gesamte Baumstruktur funktioniert auch wunder bar mit dem konzept...

CStoll

Du könntest auch einen Baum-Iterator um einen list-Iterator herumbauen:

class node
{
  list<node> children;
  list<node>::iterator father;
  ...
};

class baum_iterator
{
  typedef list<node>::iterator pos_type;
  pos_type pos;
public:
  baum_iterator& operator++()
  {
    post_type father = pos->father;
    ++pos;
    if(pos==father->children.end())
      durchhangeln zum nächsten Cousin
    return *this;
  }
};

BorisDieKlinge

Gute idee... aber wenn ich das übernehme sind 2 tage arbeit im arsch.. un komm nie zum ende...^

@cstoll: was cool wäre wenn du mir das mit de father iterator erklären könnest, und wie du das mit "durchängel bist zum cousin" erklärne könnest:)

Wenn ich diese Lösung in 2 stunden habe.. wäre cool:)