Bevorzugte Zuweisung von geschachtelten Strukturen

Question

Ist es vorzuziehen, die 'inneren' Strukturen in einer geschachtelten Hierarchie dynamisch zuzuordnen? Wenn die Elternstruktur dynamisch zugewiesen wird, spielt das überhaupt eine Rolle? Warum/wie spielt es eine Rolle? Ich versuche nur, mein Verständnis von Implikationen verschiedener, scheinbar widersprüchlicher Wege zu entwickeln, mit denen das Gedächtnis in einer Code-Basis behandelt wird, mit der ich es zu tun habe.

Zum Beispiel, was sind die Vorteile von:

struct Foo_type { 
    int i; 
}; typedef struct Foo_type Foo; 

struct Bar_type { 
    Foo f; 
}; typedef struct Bar_type Bar; 

int main() { 
    Bar* b = malloc(sizeof(Bar)); 

    /* yada yada yada */ 

    free(b); 
    return 0; 
} 

Im Gegensatz zu:

struct Foo_type { 
    int i; 
}; typedef struct Foo_type Foo; 

struct Bar_type { 
    Foo* f; 
}; typedef struct Bar_type Bar; 

int main() { 
    Bar* b = malloc(sizeof(Bar)); 
    b->f = malloc(sizeof(Foo)); 

    /* yada yada yada */ 

    free(b->f); 
    free(b); 
    return 0; 
} 

Sind sie gleichwertig/anders?

Answer 1

Im ersten Fall ist die Struktur in einem Speicherzuweisungsblock enthalten, so dass Sie sie memcpy und benötigen nur einen frei, um es zu befreien.

Wenn zwei Sie zwei Speicherblöcke nicht unbedingt nebeneinander belegen, haben Sie zusätzliche Mühe, diese beiden Blöcke zu verfolgen.

Wenn Sie mehr Zeiger und Member in Bar_type haben, erhöhen Sie die Komplexität beim Kopieren einer Instanz des Typs.

Answer 2

Als hinzugefügt zu @AndersK. Antwort, die erste Methode (nicht dynamisch) werden bevorzugt, wenn wir Vererbung emulieren sollen, wobei die Basis struct innerhalb der abgeleiteten struct erklärt und die als Base abgeleiteten Gießen:

#include <stdio.h> 
#include <stdlib.h> 

struct foo { 
    int i; 
}; 

struct bar { 
    struct foo f; 
}; 

static void func(struct foo *f, int i) 
{ 
    f->i = i; 
} 

int main(void) 
{ 
    struct bar *b = malloc(sizeof(*b)); 

    func((struct foo *)b, 1); 
    printf("%d\n", b->f.i); 
    return 0; 
}