Verwendung eines Structs INNERHALB sich selbst.

[TheTraina]

Hallo,

ich habe ein Problem bei der Definition eines Structes , welches ich als Grundlage für eine Baumstruktur haben will. Jeder Knoten (node) soll einen Vektor mit Zeigern auf seine Söhne (subnodes) enthalten, welche ja selbst wieder vom Typ node sind.

typedef struct _node {

    ...
    nodeptr* subnodes;			// array of pointer to subnodes
    ...
    
} node, *nodeptr;

Leider meckert der Compiler herum.

ISO C++ forbids declaration of ‘nodeptr’ with no type

Der Compiler erkennt also nodeptr noch nicht als Typ?

Was muss ich abändern, damit das so funktioniert wie gewollt.

Vielen Dank!

[locus vivendi]

Du musst dem Compiler schon sagen, was nodeptr ist *bevor* du es verwendest:

struct node {
typedef node* nodeptr; // <-- Hier.

nodeptr subnodes[2];
};

Außerdem "lügt" dein Kommentar bezüglich "subnodes". Es würde sich ja nicht um ein Array sondern einen Zeiger handeln.Vielleicht soll nodeptr ja auf ein Array zeigen, aber das ist etwas Anderes. Wenn du ein Array haben willst, dann z.B. so wie oben.
Die Konstruktion mit typedef struct X { } X; ist in C++ übrigens überflüssig. Es reicht vollkommen struct X { }; um den Typ X zu definieren.
Zuletzt noch der Hinweis zu dem Namen _node: Namen mit vorangestelltem Unterstrich sind teilweise reserviert, z.B. im globalen Namespace. Du hast nicht angegeben in welchem Namespace du _node definierst, da musst du jedenfalls aufpassen.

[TheTraina]

struct node {
typedef node* nodeptr; // <-- Hier.

nodeptr subnodes[2];
};

also ein typedef innerhalb eines typedef? das 'node, *nodeptr;' nach der geschweiften klammer fällt dann weg?

Außerdem "lügt" dein Kommentar bezüglich "subnodes". Es würde sich ja nicht um ein Array sondern einen Zeiger handeln.Vielleicht soll nodeptr ja auf ein Array zeigen, aber das ist etwas Anderes. Wenn du ein Array haben willst, dann z.B. so wie oben.

Ne ne, das soll schon ein array sein. Aber da sich die Größe erst während des Programmlaufes ermittelt, kann ich zunächst ja nur ein Pointer auf den Array von Pointern (des Typs nodeptr) initialisieren. Analog zu

double* myvector; ...(erhalte dim)... myvector = new double[dim];

danke noch den hinweis zu dem namespace

----------------------------
ADDED:

ich habe das problem jetzt so gelöst(?), dass ich zwei structs definiert habe: Der erste enthält alle Komponenten, die vom Struct unabhängig sind (double, int,...). Darauf aufbauend dann einen zweiten Struct.

typedef struct _nbase {
    ...
    (alle Komponenten, die unabhängig sind vom Struct nbase )
    ...
} nbase, *nbaseptr;

typedef struct {
    nbase mynode;

    nbaseptr* subnodes;
} node, *nodeptr;

Wenn ich eine neue node haben will, kann ich einfach " n= new node " setzen und erhalte eine Knoten, der alle gewünschten Komponenten (also auch jene vom Struct nbase) enthält. Das müsste doch eigtl. klappen, oder?

[anda_skoa]

Das geht nur dann, wenn subnodes ihrerseits keine weiteren Kindknoten haben, weil die Baum-/Listenstruktur ja in der zweiten Struct ist.

Was auch funktionieren sollte, ist eine "Forward Declaration", also die Bekanntmachung eines Typs bzw der Art des Typs ohne seine Details

// forward declaration
struct node;

// actual declaration
struct node {
  node *subnodes;

  // data
};

Ciao,
_

[locus vivendi]

Genau genommen würde auch dieses hier funktionieren,

struct X { X* subnode; };

, weil X dann ja schon bekannt ist.

[TheTraina]

// forward declaration
struct node;
// actual declaration
struct node {
  node *subnodes;
  // data
};

Danke dafür. Habe meins jetzt mal so wie oben modifiziert. Bei dir dürfte subnodes aber kein Array von Pointern sein, wie ich ihn brauche, sondern subnodes enthält nur ein Poiner auf eine node.

struct node;
#define nodeptr node*     // nodeptr als pointer auf ein Element des Typs node

struct node {
    int level;            // level of node within tree
    ...
    nodeptr* subnodes;    // array of pointer to subnodes
    ...
};

#define level(x)       (((nodeptr) (x))->level)
#define subnodes(x)    (((nodeptr) (x))->subnodes)

Ich benutze noch gewisse Makros für einen besser lesbaren Zugriff (siehe die define's). Wenn ich jetzt einer Funktion einen Zeiger auf einen Knoten übergebe (um einfach zu bleiben, soll diese Funktion einfach mal das level des Knoten zurückgeben, welcher in dem member level gespeichert ist), müsste das doch einfach so gehen, oder?

int welches_level( nodeptr q ) {
     return level(q);
}

Wenn ich während des Programmes nun die Dimension der subnodes kenne. Kann ich doch einfach die Größe wie folgt initialisieren, oder?

subnodes(q) = new nodeptr[dim]; //wobei q eben ein nodeptr, also ein zeiger auf eine node ist und dim die während des Programms erhaltene Dimension.

d.h. mein subnodes ist wie gewollt ein Aray der Größe dim mit Pointern auf structe des Typs node als Elemente.