Comment initialiser une structure conformément aux normes du langage de programmation C

Je veux initialiser un élément struct, divisé en déclaration et initialisation. Voici ce que j'ai:

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

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

Est-ce la façon de déclarer et d'initialiser une variable locale MY_TYPEconformément aux normes du langage de programmation C (C89, C90, C99, C11, etc.)? Ou y a-t-il quelque chose de mieux ou au moins de travailler?

Mise à jour J'ai fini par avoir un élément d'initialisation statique où je définissais chaque sous-élément en fonction de mes besoins.

Dans (ANSI) C99, vous pouvez utiliser un initialiseur désigné pour initialiser une structure:

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

Modifier: les autres membres sont initialisés à zéro: "Les membres de champ omis sont implicitement initialisés de la même manière que les objets qui ont une durée de stockage statique." ( https://gcc.gnu.org/onlinedocs/gcc/Designated-Inits.html )

Vous pouvez le faire avec un littéral composé . Selon cette page, cela fonctionne en C99 (qui compte également comme 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 };

Les désignations dans les initialiseurs sont facultatives; vous pouvez également écrire:

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

Je vois que vous avez déjà reçu une réponse sur ANSI C 99, donc je vais jeter un os sur ANSI C 89. ANSI C 89 vous permet d'initialiser une structure de cette façon:

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

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

Une chose importante à retenir, au moment où vous initialisez même un objet / variable dans la structure, toutes ses autres variables seront initialisées à la valeur par défaut.

Si vous n'initialisez pas les valeurs dans votre structure, toutes les variables contiendront des "valeurs inutiles".

Bonne chance!

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

ferait bien en C99

Vous l'avez presque compris ...

MY_TYPE a = { true,15,0.123 };

Une recherche rapide sur 'struct initialize c' me le montre

La norme de langage de programmation C ISO / IEC 9899: 1999 (communément appelée C99) permet d'utiliser un initialiseur désigné pour initialiser les membres d'une structure ou d'une union comme suit:

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

Il est défini dans la paragraph 7section 6.7.8 Initializationde la norme ISO / IEC 9899: 1999 comme:

Si un désignateur a le formulaire
. identifiant,
alors l'objet courant (défini ci-dessous) doit avoir une structure ou un type d'union et l'identifiant doit être le nom d'un membre de ce type.

Notez que paragraph 9de la même section déclare que:

Sauf indication contraire explicite, aux fins du présent paragraphe, les membres non nommés d'objets de structure et de type d'union ne participent pas à l'initialisation. Les membres sans nom des objets de structure ont une valeur indéterminée même après l'initialisation.

Dans la mise en œuvre de GNU GCC, cependant, les membres omis sont initialisés en tant que valeur appropriée de type zéro ou de type zéro. Comme indiqué dans la section 6.27 Initialiseurs désignés de la documentation GNU GCC:

Les membres de champ omis sont implicitement initialisés de la même manière que les objets qui ont une durée de stockage statique.

Le compilateur Microsoft Visual C ++ devrait prendre en charge les initialiseurs désignés depuis la version 2013 selon le blog officiel C ++ Conformance Roadmap . Paragraphe Initializing unions and structsdes initialiseurs article dans la documentation MSDN Visual Studio suggère que les membres non nommés sont initialisés à des valeurs appropriées de type zéro similaires à GNU GCC.

La norme ISO / IEC 9899: 2011 (communément appelée C11) qui avait remplacé ISO / IEC 9899: 1999 conserve les initialiseurs désignés dans la section 6.7.9 Initialization. Il conserve égalementparagraph 9 inchangé.

La nouvelle norme ISO / IEC 9899: 2018 (communément appelée C18) qui avait remplacé ISO / IEC 9899: 2011 conserve les initialiseurs désignés dans la section 6.7.9 Initialization. Il reste également paragraph 9inchangé.

comme l'a dit Ron Nuni:

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

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

Une chose importante à retenir: au moment où vous initialisez même un objet / variable dans la structure, toutes ses autres variables seront initialisées à la valeur par défaut.

Si vous n'initialisez pas les valeurs dans votre structure (c'est-à-dire si vous déclarez simplement cette variable), toutes variable.memberscontiendront des "valeurs de poubelle", seulement si la déclaration est locale!

Si la déclaration est globale ou statique (comme dans ce cas), tous les non initialisés variable.membersseront initialisés automatiquement à:

• 0 pour les nombres entiers et virgule flottante
• '\0'pour char(bien sûr, c'est la même chose que 0, etchar c'est un type entier)
• NULL pour les pointeurs.

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

Si MS n'a pas mis à jour vers C99, MY_TYPE a = {true, 15,0.123};

J'ai trouvé une autre façon d'initialiser les structures.

La structure:

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

Initialisation:

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

Selon la documentation de GCC, cette syntaxe est obsolète depuis GCC 2.5 .

Je n'ai aimé aucune de ces réponses, alors j'ai fait la mienne. Je ne sais pas si c'est ANSI C ou pas, c'est juste GCC 4.2.1 dans son mode par défaut. Je ne me souviens jamais du bracketing, donc je commence avec un sous-ensemble de mes données et je me bats avec les messages d'erreur du compilateur jusqu'à ce qu'il se ferme. La lisibilité est ma première priorité.

    // 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"}
    };

Les données peuvent commencer la vie comme un fichier délimité par des tabulations que vous recherchez-remplacez pour masser dans autre chose. Oui, c'est des trucs Debian. Donc une paire extérieure de {} (indiquant le tableau), puis une autre paire pour chaque structure à l'intérieur. Avec des virgules entre. Mettre des choses dans un en-tête n'est pas strictement nécessaire, mais j'ai environ 50 éléments dans ma structure, donc je les veux dans un fichier séparé, à la fois pour garder le désordre de mon code et donc c'est plus facile à remplacer.

La structure en C peut être déclarée et initialisée comme ceci:

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;
}

J'ai déjà lu la documentation de Microsoft Visual Studio 2015 pour l'initialisation des types d'agrégats , toutes les formes d'initialisation avec{...} sont expliquées, mais l'initialisation avec point, nommée `` désignateur '' n'y est pas mentionnée. Cela ne fonctionne pas non plus.

Le standard C99 chapitre 6.7.8 Initialisation explique la possibilité des désignateurs, mais dans mon esprit ce n'est pas vraiment clair pour les structures complexes. La norme C99 en pdf .

Dans mon esprit, il vaut peut-être mieux

1. Utilisez le = {0}; initialisation pour toutes les données statiques. C'est moins d'effort pour le code machine.

2. Utilisez des macros pour l'initialisation, par exemple

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

La macro peut être adaptée, sa liste d'arguments peut être indépendante du contenu struct modifié. Il convient que moins d'éléments soient initialisés. Il convient également pour les structures imbriquées. 3. Un formulaire simple est: Initialiser dans un sous-programme:

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

Cette routine ressemble à ObjectOriented en C. Utilisez thiz, pas thispour la compiler avec C ++ aussi!

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

Je cherchais un bon moyen d'initialiser ma structure, et je dois utiliser le ci-dessous (C99). Cela me permet d'initialiser une seule structure ou un tableau de structures de la même manière que les types 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}

Cela peut être utilisé dans le code comme:

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 */