Habe versucht die Länge erstmal wegzulassen (Knoten * Kinder[]), das 0te und das 1te Kind wird problemlos erzeugt, das 2te Kind verursacht dann aber einen Memory-Overflow. Hat jemand eine Lösung, oder wenigstens einen Ansatz.

Übrigens, ich arbeite mit Eclipse und als Compiler ist MinGW eingebunden.

#include <iostream>
#include <string>
using namespace std;
struct Task{
Task ();
Task (int KNOTENNR,int KINNA);

int alphaIst(){return alpha;};//erstma unwichtig, fuer den spaeteren Algo aus ner Vorlesung wichtig
int nameIst(){return knotenNr;};
int wieVieleKinder(){return anzahlKinder;};
void hatEinKind(Task kind);

Task * papa;
Task * baelger[];

private:
int knotenNr;
int alpha;
int anzahlKinder;

};

Task::Task()
:alpha(0), anzahlKinder(0) {}
Task::Task(int kinner,int nr)
:anzahlKinder(kinner),knotenNr(nr),alpha(0) {}
void Task::hatEinKind(Task kind){
cout << "0. Groesse des Arrays ist " << sizeof baelger<< endl;
cout << "1. der Name des Balgs: " << kind.nameIst()<< endl;
cout << "2. anzahlKinder war eben: " << anzahlKinder << endl;
baelger[anzahlKinder]= &kind;
cout << "3. Probe: Kind " << anzahlKinder << " traegt den Namen " << baelger[anzahlKinder]->nameIst()<<endl;

anzahlKinder++;
cout << "4. anzahlKinder ist nun: " << anzahlKinder << endl;
}

int main () {
cout << "los gehts" << endl;

Task knoten1(0,1);
Task knoten2(0,2);
Task knoten3(0,3);
Task knoten4(0,4);
Task knoten5(0,5);
Task knoten6(0,6);
Task knoten7(0,7);

knoten1.hatEinKind(knoten2);
knoten1.hatEinKind(knoten3);
knoten1.hatEinKind(knoten4);//diese Zeile verursacht den Fehler
return 0;}

http://www.kharchi.de/cppratgeber2.htm

struct Task
{
  Task* parent;
  Task* childs;

  Task(int nr,int ch_anz) : childs(new Task[ch_anz]),number(nr),child_count(ch_anz) {}
  ~Task() {delete[] childs;}

private:
  int number;
  int child_count;
  //...
};

bin neu im forum, daher ging es schneller das problem zu schildern, als stundenlang nach einem aehnlichen problem zu suchen. ich werde erstmal die vektoren ausprobieren, da man hinten imma wat anhaengen kann.

P.S. Dynamische Datenstrukturen (auch Arrays), werden in dem Buch hier behandelt:
http://www.pronix.de/pronix-632.html (Wieder für C)

=> Links wertlos