Cómo inicializar una estructura de acuerdo con los estándares del lenguaje de programación C

Quiero inicializar un elemento de estructura, dividido en declaración e inicialización. Esto es lo que tengo:

typedef struct MY_TYPE {
  bool flag;
  short int value;
  double stuff;
} MY_TYPE;

void function(void) {
  MY_TYPE a;
  ...
  a = { true, 15, 0.123 }
}

¿Es esta la forma de declarar e inicializar una variable local de MY_TYPEacuerdo con los estándares del lenguaje de programación C (C89, C90, C99, C11, etc.)? ¿O hay algo mejor o al menos funciona?

Actualización Terminé teniendo un elemento de inicialización estático donde configuré cada subelemento según mis necesidades.

En (ANSI) C99, puede usar un inicializador designado para inicializar una estructura:

MY_TYPE a = { .flag = true, .value = 123, .stuff = 0.456 };

Editar: Otros miembros se inicializan como cero: "Los miembros de campo omitidos se inicializan implícitamente igual que los objetos que tienen una duración de almacenamiento estático". ( https://gcc.gnu.org/onlinedocs/gcc/Designated-Inits.html )

Puedes hacerlo con un literal compuesto . Según esa página, funciona en C99 (que también cuenta como ANSI C ).

MY_TYPE a;

a = (MY_TYPE) { .flag = true, .value = 123, .stuff = 0.456 };
...
a = (MY_TYPE) { .value = 234, .stuff = 1.234, .flag = false };

Las designaciones en los inicializadores son opcionales; también podrías escribir:

a = (MY_TYPE) { true,  123, 0.456 };
...
a = (MY_TYPE) { false, 234, 1.234 };

Veo que ya ha recibido una respuesta sobre ANSI C 99, así que voy a echar un vistazo sobre ANSI C 89. ANSI C 89 le permite inicializar una estructura de esta manera:

typedef struct Item {
    int a;
    float b;
    char* name;
} Item;

int main(void) {
    Item item = { 5, 2.2, "George" };
    return 0;
}

Una cosa importante para recordar, en el momento en que inicialice incluso un objeto / variable en la estructura, todas sus otras variables se inicializarán al valor predeterminado.

Si no inicializa los valores en su estructura, todas las variables contendrán "valores basura".

¡Buena suerte!

a = (MYTYPE){ true, 15, 0.123 };

haría bien en C99

Casi lo tienes ...

MY_TYPE a = { true,15,0.123 };

La búsqueda rápida en 'struct initialize c' me muestra esto

El lenguaje de programación estándar ISO / IEC 9899: 1999 (comúnmente conocido como C99) permite utilizar un inicializador designado para inicializar miembros de una estructura o unión de la siguiente manera:

MY_TYPE a = { .stuff = 0.456, .flag = true, .value = 123 };

Se define en la paragraph 7sección 6.7.8 Initializationde la norma ISO / IEC 9899: 1999 como:

Si un designador tiene la forma
. identificador
entonces el objeto actual (definido a continuación) se tiene estructura o unión tipo y el identificador deberá ser el nombre de un miembro de ese tipo.

Tenga en cuenta que paragraph 9de la misma sección establece que:

Excepto donde se indique explícitamente lo contrario, a los efectos de esta subcláusula, los miembros sin nombre de objetos de estructura y tipo de unión no participan en la inicialización. Los miembros sin nombre de los objetos de estructura tienen un valor indeterminado incluso después de la inicialización.

Sin embargo, en la implementación de GNU GCC, los miembros omitidos se inicializan como valor apropiado para el tipo cero o similar a cero. Como se indica en la sección 6.27 Inicializadores designados de la documentación de GNU GCC:

Los miembros de campo omitidos se inicializan implícitamente igual que los objetos que tienen una duración de almacenamiento estático.

El compilador de Microsoft Visual C ++ debe admitir inicializadores designados desde la versión 2013 según la publicación oficial del blog C ++ Conformance Roadmap . El párrafo Initializing unions and structsdel artículo Inicializadores en la documentación de MSDN Visual Studio sugiere que los miembros sin nombre se inicializaron a valores apropiados similares a cero de manera similar a GNU GCC.

El estándar ISO / IEC 9899: 2011 (comúnmente conocido como C11) que había reemplazado al ISO / IEC 9899: 1999 conserva los inicializadores designados en la sección 6.7.9 Initialization. También conserva paragraph 9sin cambios.

El nuevo estándar ISO / IEC 9899: 2018 (comúnmente conocido como C18) que había reemplazado a ISO / IEC 9899: 2011 conserva los inicializadores designados en la sección 6.7.9 Initialization. También conserva paragraph 9sin cambios.

como dijo Ron Nuni:

typedef struct Item {
    int a;
    float b;
    char* name;
} Item;

int main(void) {
    Item item = {5, 2.2, "George"};
    return 0;
}

Una cosa importante para recordar: en el momento en que inicialice incluso un objeto / variable en la estructura, todas sus otras variables se inicializarán al valor predeterminado.

Si no inicializa los valores en su estructura (es decir, si solo declara esa variable), todos variable.memberscontendrán "valores basura", solo si la declaración es local!

Si la declaración es global o estática (como en este caso), todos los no variable.membersinicializados se inicializarán automáticamente para:

• 0 para enteros y coma flotante
• '\0'para char(por supuesto, esto es lo mismo que 0, ychar es un tipo entero)
• NULL para punteros

void function(void) {
  MY_TYPE a;
  a.flag = true;
  a.value = 15;
  a.stuff = 0.123;
}

Si MS no se ha actualizado a C99, MY_TYPE a = {true, 15,0.123};

Encontré otra forma de inicializar estructuras.

La estructura:

typedef struct test {
    int num;
    char* str;
} test;

Inicializacion:

test tt = {
    num: 42,
    str: "nice"
};

Según la documentación de GCC, esta sintaxis es obsoleta desde GCC 2.5 .

No me gustó ninguna de estas respuestas, así que hice la mía. No sé si esto es ANSI C o no, es solo GCC 4.2.1 en su modo predeterminado. Nunca recuerdo el paréntesis, así que comienzo con un subconjunto de mis datos y lucho con los mensajes de error del compilador hasta que se cierra. La legibilidad es mi primera prioridad.

    // in a header:
    typedef unsigned char uchar;

    struct fields {
      uchar num;
      uchar lbl[35];
    };

    // in an actual c file (I have 2 in this case)
    struct fields labels[] = {
      {0,"Package"},
      {1,"Version"},
      {2,"Apport"},
      {3,"Architecture"},
      {4,"Bugs"},
      {5,"Description-md5"},
      {6,"Essential"},
      {7,"Filename"},
      {8,"Ghc-Package"},
      {9,"Gstreamer-Version"},
      {10,"Homepage"},
      {11,"Installed-Size"},
      {12,"MD5sum"},
      {13,"Maintainer"},
      {14,"Modaliases"},
      {15,"Multi-Arch"},
      {16,"Npp-Description"},
      {17,"Npp-File"},
      {18,"Npp-Name"},
      {19,"Origin"}
    };

Los datos pueden comenzar como un archivo delimitado por tabulaciones que usted busca, reemplaza para dar masajes a otra cosa. Sí, esto es cosa de Debian. Entonces, un par externo de {} (que indica la matriz), luego otro par para cada estructura interna. Con comas entre. Poner cosas en un encabezado no es estrictamente necesario, pero tengo alrededor de 50 elementos en mi estructura, así que los quiero en un archivo separado, tanto para mantener el desorden de mi código como para que sea más fácil de reemplazar.

La estructura en C se puede declarar e inicializar así:

typedef struct book
{
    char title[10];
    char author[10];
    float price;
} book;

int main() {
    book b1={"DS", "Ajay", 250.0};

    printf("%s \t %s \t %f", b1.title, b1.author, b1.price);

    return 0;
}

Ya he leído la documentación de Microsoft Visual Studio 2015 para inicializar tipos agregados , todas las formas de inicialización con{...} se explican allí, pero la inicialización con punto, llamada '' designador '' no se menciona allí. No funciona tampoco.

El capítulo estándar C99 6.7.8 Inicialización explica la posibilidad de designadores, pero en mi opinión no está realmente claro para estructuras complejas. El estándar C99 como pdf .

En mi opinión, puede ser mejor

1. Utilizar el = {0}; inicialización para todos los datos estáticos. Es menos esfuerzo para el código de la máquina.

2. Use macros para inicializar, por ejemplo

   typedef MyStruct_t{ int x, int a, int b; } MyStruct; define INIT_MyStruct(A,B) { 0, A, B}

La macro se puede adaptar, su lista de argumentos puede ser independiente del contenido de la estructura modificada. Es apropiado si se deben inicializar menos elementos. También es apropiado para estructuras anidadas. 3. Una forma simple es: Inicializar en una subrutina:

void init_MyStruct(MyStruct* thiz, int a, int b) {
  thiz->a = a; thiz->b = b; }

Esta rutina se parece a ObjectOriented en C. ¡Use thiz, no thispara compilarla también con C ++!

MyStruct data = {0}; //all is zero!
init_MyStruct(&data, 3, 456);

He estado buscando una buena manera de inicializar mi estructura, y tengo que usar el siguiente (C99). Esto me permite inicializar una sola estructura o una matriz de estructuras de la misma manera que los tipos simples.

typedef struct {
    char *str;
    size_t len;
    jsmntok_t *tok;
    int tsz;
} jsmn_ts;

#define jsmn_ts_default (jsmn_ts){NULL, 0, NULL, 0}

Esto se puede usar en el código como:

jsmn_ts mydata = jsmn_ts_default; /* initialization of a single struct */

jsmn_ts myarray[10] = {jsmn_ts_default, jsmn_ts_default}; /* initialization of
                                                    first 2 structs in the array */