Posso "estendere" una struct in C?

Question

typedef struct foo_s { 
    int a; 
} foo; 

typedef struct bar_s { 
    foo; 
    int b; 
} bar; 

In sostanza voglio fare:

bar b; 
b.a; 

So che avrei potuto fare b.foo_name.a se avessi chiamato lo struct foo in bar, ma Id preferisco non farlo.

Un modo per farlo?

Questa domanda ha ottenuto una varietà di risposte diverse, quindi lasciatemi spiegare la necessità. La ragione per cui voglio farlo è perché ho una libreria che devo adattare alla mia situazione, il che significa che non posso modificare la decodifica della struct originale. Inoltre, tutto ciò che devo fare è aggiungere 1 elemento all'inizio della struct (perché all'inizio? Perché ho una struttura 'object' che dirige tutte le strutture nel progetto). Potrei semplicemente incorporare la struttura come dici tu, ma è DAVVERO fastidiosa dato che tutti i riferimenti dovranno essere digitati 'variable-> image.location' che 'immagine'. digitato un miliardo di tipi è davvero fastidioso.

Answer 1

Evidentemente this feature has been added to C11, ma purtroppo non ho accesso a un compilatore C di recente epoca (> = GCC 4.6.2).

typedef struct foo { 
    int a; 
} foo; 

typedef struct bar { 
    struct foo; 
    int b; 
} bar; 

int main() { 
    bar b; 
    b.a = 42; 
    b.b = 99; 
    return 0; 
} 

Answer 2

Non possibile in C come hai fatto tu. Ma puoi simulare l'ereditarietà con una variabile membro foo in bar.

typedef struct bar_s { 
    foo obj; 
    int b; 
} bar; 

bar b; 
b.obj.a = 10; 

Answer 3

Puoi provare a utilizzare l'ereditarietà:

struct foo_s 
{ 
    int a; 
}; 

struct bar_s: foo_a 
{ 
    int b; 
}; 

Lavori in C++, non è sicuro se funziona in C.

Answer 4

Se Ment

typedef struct foo_s { 
    int a; 
    } foo; 

typedef struct bar_s { 
foo my_foo; 
int b; 
} bar; 

modo da poter fare :

bar b; b.my_foo.a = 3; 

Altrimenti, Non c'è modo di farlo in C poiché lo sizeof(bar_s) è un danno per il tempo di compilazione. Non è una buona pratica, ma puoi salvare un puntatore void * ptr; all'interno di bar_s e un'altra enum che descrive il tipo ptr e eseguire il cast in base al tipo.

cioè:

typedef enum internalType{ 
    INTERNAL_TYPE_FOO = 0, 
}internalType_t; 

typedef struct bar_s { 
internalType_t ptrType; 
void* ptr; 
int b; 
} bar; 

e poi:

bar b; foo f; 
b.ptrType = INTERNAL_TYPE_FOO; 
b.ptr = &f; 

e qualche altro posto nel codice:

if (b.ptrType == INTERNAL_TYPE_FOO) { 
    foo* myFooPtr = (foo *)b.ptr; 
} 

Answer 5

È possibile, utilizzando i puntatori, perché un puntatore ad una struttura l'oggetto è garantito per puntare il suo primo membro. Vedi per es. this article.

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

typedef struct foo_s { 
    int a; 
} foo; 

typedef struct bar_s { 
    foo super; 
    int b; 
} bar; 

int fooGetA(foo *x) { 
    return x->a; 
} 

void fooSetA(foo *x, int a) { 
    x->a = a; 
} 

int main() { 
    bar* derived = (bar*) calloc(1, sizeof(bar)); 
    fooSetA((foo*) derived, 5); 
    derived->b = 3; 
    printf("result: %d\n", fooGetA((foo*) derived)); 
    return 0; 
} 

Answer 6

Può essere facilmente fatto tramite preprocessore:

Creare un file denominato base_foo.h:

int foo; 

Poi basta includerlo:

typedef struct foo_s { 
    #include "base_foo.h" 
} foo; 

typedef struct bar_s { 
    #include "base_foo.h" 
    int b; 
} bar;