¿Puedo 'extender' una estructura en C?

Question

typedef struct foo_s { 
    int a; 
} foo; 

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

Básicamente quiero hacer:

bar b; 
b.a; 

Yo sé que podría hacer b.foo_name.a si hubiera llamado la struct foo en bar, pero Id prefiero no hacerlo.

¿Alguna forma de hacerlo?

Esta pregunta ha recibido una variedad de respuestas diferentes, así que déjame explicarte la necesidad. La razón por la que quiero hacer esto es porque tengo una biblioteca que necesito adaptar a mi situación, lo que significa que no puedo modificar la declinación de la estructura original. Además, todo lo que necesito hacer es agregar 1 elemento al principio de la estructura (¿por qué al principio? Porque tengo una estructura 'objeto' que encabeza todas las estructuras en el proyecto). Simplemente podría insertar la estructura como mencionas pero es realmente molesto ya que todas las referencias deberán escribirse 'variable-> image.location' en 'imagen'. tipeó mil millones de tipos es realmente molesto.

Answer 1

Evidentemente this feature has been added to C11, pero por desgracia no tengo acceso a un compilador C de la vendimia reciente (> = 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

No es posible en C como lo hizo. Pero puede imitar la herencia con una variable de miembro foo en bar.

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

bar b; 
b.obj.a = 10; 

Answer 3

Usted puede intentar usar la herencia:

struct foo_s 
{ 
    int a; 
}; 

struct bar_s: foo_a 
{ 
    int b; 
}; 

Obras en C++, no está seguro si funciona en C.

Answer 4

Si usted ción

typedef struct foo_s { 
    int a; 
    } foo; 

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

lo que puede hacer :

bar b; b.my_foo.a = 3; 

De lo contrario, no hay forma de hacerlo en C ya que el sizeof(bar_s) es perjudicial para el tiempo de compilación. No es una buena práctica, pero puede guardar un puntero void * ptr; dentro de bar_s, y otra enumeración que describe el tipo ptr, y enviar por tipo.

es decir:

typedef enum internalType{ 
    INTERNAL_TYPE_FOO = 0, 
}internalType_t; 

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

y luego:

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

y en otro lugar en el código:

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

Answer 5

Usted puede, usando punteros, porque un puntero a una estructura objeto está garantizado para apuntar a su primer miembro. Ver p. 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

Se puede hacer fácilmente a través de preprocesador:

Crear un archivo llamado base_foo.h:

int foo; 

Después, simplemente lo incluyen:

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

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