Initialisation des types d’agrégats

Un type d’agrégation est une structure, une union ou un type de tableau. Si un type d’agrégation contient des membres de types d’agrégation, les règles d’initialisation s’appliquent de manière récursive.

Syntaxe

initializer :
  { initializer-list } /* Pour l’initialisation d’agrégation */
  { initializer-list , }

initializer-list :
 initializer
  initializer-list , initializer

Il initializer-list s’agit d’une liste d’initialiseurs séparés par des virgules. Chaque initialiseur de la liste est une expression constante ou une liste d’initialiseurs. Par conséquent, les listes d’initialiseurs peuvent être imbriquées. Ce formulaire est utile pour initialiser les membres d’agrégation d’un type d’agrégation, comme illustré dans les exemples de cette section. Toutefois, si l’initialiseur d’un identificateur automatique est une expression unique, il ne doit pas s’agir d’une expression constante ; il doit simplement avoir un type approprié pour l’affectation à l’identificateur.

Pour chaque liste d’initialiseurs, les valeurs des expressions constantes sont affectées, dans l’ordre, aux membres correspondants de la variable d’agrégation.

Si initializer-list elle a moins de valeurs qu’un type d’agrégation, les membres ou éléments restants du type d’agrégation sont initialisés à 0. La valeur initiale d’un identificateur automatique non initialisé explicitement n’est pas définie. Si initializer-list elle a plus de valeurs qu’un type d’agrégation, une erreur se produit. Ces règles s’appliquent à chaque liste d’initialiseurs incorporées et à l’agrégat dans son ensemble.

L’initialiseur d’une structure est soit une expression du même type, soit une liste d’initialiseurs pour ses membres placés entre accolades ({ }). Les membres de champ de bits non nommés ne sont pas initialisés.

Lorsqu’une union est initialisée, initializer-list doit être une expression constante unique. La valeur de l’expression constante est affectée au premier membre de l’union.

Si un tableau a une taille inconnue, le nombre d’initialiseurs détermine la taille du tableau et son type devient terminé. Il n’existe aucun moyen de spécifier la répétition d’un initialiseur en C ou d’initialiser un élément au milieu d’un tableau sans fournir également toutes les valeurs précédentes. Si vous avez besoin de cette opération dans votre programme, écrivez la routine dans le langage d’assembly.

Le nombre d’initialiseurs peut définir la taille du tableau :

int x[ ] = { 0, 1, 2 }

Si vous spécifiez la taille et donnez le mauvais nombre d’initialiseurs, toutefois, le compilateur génère une erreur.

Spécifique à Microsoft

La taille maximale d’un tableau est définie par size_t.

FIN de la section spécifique à Microsoft

Exemples

Cet exemple montre les initialiseurs d’un tableau.

int P[4][3] =
{
    { 1, 1, 1 },
    { 2, 2, 2 },
    { 3, 3, 3,},
    { 4, 4, 4,},
};

Cette instruction déclare P comme un tableau de quatre par trois et initialise les éléments de sa première ligne à 1, les éléments de sa deuxième ligne à 2, et ainsi de suite, à travers la quatrième ligne. La liste d’initialiseurs pour les troisième et quatrième lignes contient des virgules après la dernière expression constante. La dernière liste d’initialiseurs ({4, 4, 4,},) est également suivie d’une virgule. Ces virgules supplémentaires sont autorisées, mais ne sont pas requises. Seules les virgules qui séparent les expressions constantes des unes des autres et les virgules qui séparent une liste d’initialiseurs d’une autre sont requises.

Si un membre d’agrégation n’a pas de liste d’initialiseur incorporée, les valeurs sont affectées, dans l’ordre, à chaque membre de la sous-agrégation. Par conséquent, l’initialisation dans l’exemple précédent équivaut à l’exemple suivant :

int P[4][3] =
{
   1, 1, 1, 2, 2, 2, 3, 3, 3, 4, 4, 4
};

Les accolades peuvent également apparaître autour des initialiseurs individuels dans la liste et contribueraient à clarifier l’exemple.

Lorsque vous initialisez une variable d’agrégation, veillez à utiliser correctement des accolades et des listes d’initialiseurs. L’exemple suivant illustre l’interprétation du compilateur des accolades plus en détail :

typedef struct
{
    int n1, n2, n3;
} triplet;

triplet nlist[2][3] =
{
    { {  1, 2, 3 }, {  4, 5, 6 }, {  7, 8, 9 } },  /* Row 1 */
    { { 10,11,12 }, { 13,14,15 }, { 16,17,18 } }   /* Row 2 */
};

Dans cet exemple, nlist est déclaré sous la forme d’un tableau de structures de 2 à 3, chaque structure ayant trois membres. La ligne 1 de l’initialisation affecte des valeurs à la première ligne de nlist, comme suit :

1. La première accolade gauche sur la ligne 1 signale au compilateur que l’initialisation du premier membre d’agrégation ( nlist autrement dit, nlist[0]) commence.

2. La deuxième accolade gauche indique que l’initialisation du premier membre d’agrégation ( nlist[0] autrement dit, la structure à nlist[0][0]) commence.

3. La première accolade droite met fin à l’initialisation de la structure nlist[0][0]; l’accolades gauche suivante démarre l’initialisation .nlist[0][1]

4. Le processus se poursuit jusqu’à la fin de la ligne, où l’accolade droite fermante met fin à l’initialisation de nlist[0].

La ligne 2 affecte des valeurs à la deuxième ligne d’une nlist manière similaire. Les ensembles externes d’accolades englobant les initialiseurs sur les lignes 1 et 2 sont requis. La construction suivante, qui omet les accolades externes, provoquerait une erreur :

triplet nlist[2][3] =  /* THIS CAUSES AN ERROR */
{
     {  1, 2, 3 },{  4, 5, 6 },{  7, 8, 9 },   /* Line 1 */
     { 10,11,12 },{ 13,14,15 },{ 16,17,18 }    /* Line 2 */
};

Dans cette construction, la première accolade gauche sur la ligne 1 commence l’initialisation de nlist[0], qui est un tableau de trois structures. Les valeurs 1, 2 et 3 sont affectées aux trois membres de la première structure. Lorsque l’accolade droite suivante est rencontrée (après la valeur 3), l’initialisation est nlist[0] terminée et les deux structures restantes du tableau de trois structures sont automatiquement initialisées sur 0. De même, { 4,5,6 } initialise la première structure dans la deuxième ligne de nlist. Les deux structures restantes sont nlist[1] définies sur 0. Lorsque le compilateur rencontre la liste d’initialiseurs suivante (), { 7,8,9 } il tente d’initialiser nlist[2]. Étant nlist donné qu’il n’y a que deux lignes, cette tentative provoque une erreur.

Dans cet exemple suivant, les trois int membres x sont initialisés à 1, 2 et 3, respectivement.

struct list
{
    int i, j, k;
    float m[2][3];
} x = {
        1,
        2,
        3,
       {4.0, 4.0, 4.0}
      };

Dans la list structure, les trois éléments de la première ligne sont m initialisés à 4,0 ; les éléments de la ligne restante sont m initialisés à 0,0 par défaut.

union
{
    char x[2][3];
    int i, j, k;
} y = { {
            {'1'},
            {'4'}
        }
      };

La variable yunion, dans cet exemple, est initialisée. Le premier élément de l’union est un tableau, de sorte que l’initialiseur est un initialiseur d’agrégation. La liste {'1'} d’initialiseurs affecte des valeurs à la première ligne du tableau. Étant donné qu’une seule valeur apparaît dans la liste, l’élément de la première colonne est initialisé sur le caractère 1et les deux autres éléments de la ligne sont initialisés à la valeur 0 par défaut. De même, le premier élément de la deuxième ligne est x initialisé au caractère 4et les deux autres éléments de la ligne sont initialisés à la valeur 0.

Voir aussi

Initialisation