[C] Recursive struct members

[Verwijderd]

Ik heb er helaas niet veel concreets over bijelkaar kunnen googlen, maar is het mogelijk in C recursive members in een structure te hebben?

Dus dit:

C:

typdef struct
{
  char *content;
  tree_struct *left;
  tree_struct *top;
} tree_struct;

Of moet het echt zo gebeuren:

C:

typdef struct
{
  char *content;
  void *left;
  void *top;
} tree_struct;

En dan bij het gebruik de void * gaan typecasten naar een tree_struct.

[Verwijderd]

je kan refererenaar het zelfde tpye struct binnen eens struct:

bv

code:

typedef struct LinkedListEl_ {
   void *data;
   struct LinkedListEl_ *next;
} LinkedListEl;

[Zoijar]

En anders kan je het zo doen:

code:

struct A;
struct B;

struct A {
    B* b;
};

struct B {
    A* a;
};

met forward declarations. Dit kan overigens alleen als je pointers gebruikt als members. Denk maar aan het resultaat van sizeof(A); ...

[Verwijderd]

Zoijar schreef op 22 december 2002 @ 14:54:

code:

struct A;
struct B;

struct A {
    B* b;
};

struct B {
    A* a;
};

Dit werkte in mijn voorbeeld merkwaardigerwijs niet...
maar ik bekijk het zodadelijk even :-)

[Alarmnummer]

Ben ik blij dat geavanceerdere talen over multipass parsers beschikken.

[farlane]

Dit is ook nog een mogelijkheid:

C:

/* Forward declaration of tree node structure */
struct _tree_struct;

/* The types */
typedef _tree_struct tree_struct, *p_tree_struct;

/* The struct */
struct _tree_struct
{
    char content[1024];
    p_tree_struct prev;
    p_tree_struct next;
};

int main()
{
    tree_struct first;
    tree_struct second;

    p_tree_struct p = 0;
    
    p = &first;

    p->next = &second;

    p = &second;
    p->prev = &first;

    return 0;
}      

[Bigs]

Gewoon een naam geven aan je typedeclaratie zoals tijnbraun doet en dan moet het werken

[.oisyn]

Alarmnummer schreef op 22 december 2002 @ 16:12:
Ben ik blij dat geavanceerdere talen over multipass parsers beschikken.

Definieer multipass
Verder is het niet echt een constructieve opmerking voor deze thread...

[ Voor 15% gewijzigd door .oisyn op 23-12-2002 12:09 ]

[Zoijar]

Een mulipass parser is een parser die eerst je hele source parsed, daar wat informatie over opslaat die dan gebruikt kan worden voor de volgende "pass". Het resultaat is dat je gemakkelijk een struct kan gebruiken voordat deze gedeclareerd/definieerd is.
Het hoeft trouwens niet een extra pass over je source te zijn in de parsing fase, maar kan ook een extra pass over je abstract syntax tree zijn in je semantic analysis fase.

[.oisyn]

Ik weet wat multipass op zich inhoudt, maar het punt is dat er meerder interpretaties van zijn. Vroeger was multipass namelijk dat de source echt 2x wordt gescanned/geparsed, denk aan de oude assemblers. Tegenwoordig is dat helemaal niet meer het geval, waardoor het dus nogal vaag wordt of iets single of multipass gebeurt

Java bijvoorbeeld, waar Alarmnummer ongetwijfeld op doelt met z'n 'geavanceerdere talen', is in principe ook wel in singlepass te parsen. Maar daar is het probleem ook vrij simpel, de enige typen die je zelf kunt definieren zijn classes (en dan reken ik interfaces ook even tot de classes). Een 2e pass over de AST is dus totaal niet nodig, je kunt simpelweg voldoen met eerst verzamelen van de class definities en dan elke class definitie apart gaan analyseren. Je doorloopt de boom dan in 1 pass, zij het in een andere volgorde

En is C++ bijvoorbeeld multipass? Daar kun je in principe 2 antwoorden op geven. Ten eerste zou je zeggen: nee, aangezien de types van tevoren bekend moeten zijn
Ten tweede kun je zeggen: ja, je kunt in een class definitie gebruik maken van een member function/variable terwijl die pas verderop gedefinieerd wordt
Dus wat is het nou?

[Alarmnummer]

.oisyn schreef op 23 december 2002 @ 12:46:
Ik weet wat multipass op zich inhoudt, maar het punt is dat er meerder interpretaties van zijn. Vroeger was multipass namelijk dat de source echt 2x wordt gescanned/geparsed, denk aan de oude assemblers. Tegenwoordig is dat helemaal niet meer het geval, waardoor het dus nogal vaag wordt of iets single of multipass gebeurt

Ik zou zelf ook niet zo vast houden aan 2 keer. Waar ik voornamelijk op doel is dat je een AST opbouwt, en daar later meerdere keren over heen gaat, en dan kan je dit soort problemen zeer eenvoudig oplossen

class A{
B b;
}

class B{
A a;
}

Ipv dat je met allerlei onnodige forward declaraties moet komen. Dit komt over het algemeen de leesbaarheid ten goeie. En ik vind het persoonlijk ook wel zo handig werken omdat je niet bezig hoeft te houden met allerlei tekortkomingen in de parser die al lang verholpen hadden kunnen worden (tenslotte zijn die technieken tot in den treure beschreven).

Java bijvoorbeeld, waar Alarmnummer ongetwijfeld op doelt met z'n 'geavanceerdere talen',

Niet alleen Java hoor, maar ik heb het zelf ook meerdere keren toegepast en het is zeer eenvoudig (als je een beetje een goeie AST hebt).

is in principe ook wel in singlepass te parsen. Maar daar is het probleem ook vrij simpel, de enige typen die je zelf kunt definieren zijn classes (en dan reken ik interfaces ook even tot de classes).

Een 2e pass over de AST is dus totaal niet nodig, je kunt simpelweg voldoen met eerst verzamelen van de class definities en dan elke class definitie apart gaan analyseren. Je doorloopt de boom dan in 1 pass, zij het in een andere volgorde

Zie mijn voorbeeld. Een andere volgorde die classes parsen heeft ook geen nut, omdat het probleem symetrisch is.

En is C++ bijvoorbeeld multipass? Daar kun je in principe 2 antwoorden op geven. Ten eerste zou je zeggen: nee, aangezien de types van tevoren bekend moeten zijn

Ten tweede kun je zeggen: ja, je kunt in een class definitie gebruik maken van een member function/variable terwijl die pas verderop gedefinieerd wordt
Dus wat is het nou?

Ik ben niet echt thuis in c++ of de parsetechnieken die daarvoor gebruikt zijn.

[ Voor 8% gewijzigd door Alarmnummer op 23-12-2002 13:33 ]

[.oisyn]

[nohtml]

Alarmnummer schreef op 23 December 2002 @ 13:29:
[...]

Ik zou zelf ook niet zo vast houden aan 2 keer. Waar ik voornamelijk op doel is dat je een AST opbouwt, en daar later meerdere keren over heen gaat, en dan kan je dit soort problemen zeer eenvoudig oplossen

class A{
B b;
}

class B{
A a;
}

dit is natuurlijk ook te doen door maar 1 keer door de boom heen te gaan, zij het in een andere volgorde
Ik bedoel, de boom zou er bij dit voorbeeld er ongeveer zo uit zien:

code:

Source file
|
+-+ class definition (A)
| |
| +-- class member (B b)
|
+-+ class definition (B)
  |
  +-- class member (A a)

Je kunt dan eerst alle kinderen van Source file afgaan, en alle class definitions verzamelen. Dan heb je in feite alle types, zodat je vervolgens van elke class de rest kunt gaan analyseren. Je gaat maar 1x door de boom, alleen niet postorder. Dat lijkt me geen multipass