Inizializzazione di tipi di aggregazioneInitializing Aggregate Types

Un tipo "aggregato" può essere una struttura, un'unione o un tipo di matrice.An "aggregate" type is a structure, union, or array type. Se un tipo aggregato contiene membri di tipi aggregati, le regole di inizializzazione vengono applicate in modo ricorsivo.If an aggregate type contains members of aggregate types, the initialization rules apply recursively.

SintassiSyntax

initializer:initializer:
{ initializer-list } /* Per inizializzazione aggregata */{ initializer-list } /* For aggregate initialization */

{ initializer-list , }{ initializer-list , }

initializer-list:initializer-list:
initializerinitializer

initializer-list , initializerinitializer-list , initializer

initializer-list è un elenco di inizializzatori separati da virgole.The initializer-list is a list of initializers separated by commas. Ogni inizializzatore presente nell'elenco è un'espressione costante o un elenco di inizializzatori.Each initializer in the list is either a constant expression or an initializer list. Di conseguenza, gli elenchi di inizializzatori possono essere annidati.Therefore, initializer lists can be nested. Questo modulo è utile per inizializzare i membri di aggregazione di un tipo aggregato, come illustrato negli esempi riportati in questa sezione.This form is useful for initializing aggregate members of an aggregate type, as shown in the examples in this section. Tuttavia, se l'inizializzatore di un identificatore automatico è un'espressione singola, non è necessario che sia un'espressione costante. È sufficiente che abbia un tipo appropriato per l'assegnazione all'identificatore.However, if the initializer for an automatic identifier is a single expression, it need not be a constant expression; it merely needs to have appropriate type for assignment to the identifier.

Per ogni elenco di inizializzatori, i valori delle espressioni costanti vengono assegnati, in ordine, ai membri corrispondenti della variabile di aggregazione.For each initializer list, the values of the constant expressions are assigned, in order, to the corresponding members of the aggregate variable.

Se initializer-list dispone di meno valori rispetto al tipo aggregato, gli altri membri o elementi presenti nel tipo aggregato vengono inizializzati su 0.If initializer-list has fewer values than an aggregate type, the remaining members or elements of the aggregate type are initialized to 0. Il valore iniziale di un identificatore automatico non esplicitamente inizializzato non è definito.The initial value of an automatic identifier not explicitly initialized is undefined. Se initializer-list contiene più valori rispetto al tipo aggregato, viene generato un errore.If initializer-list has more values than an aggregate type, an error results. Queste regole vengono applicate all'aggregazione nel suo complesso e a ogni elenco di inizializzatori incorporato.These rules apply to each embedded initializer list, as well as to the aggregate as a whole.

Un inizializzatore di struttura è un'espressione dello stesso tipo o un elenco di inizializzatori per i membri della struttura racchiusi tra parentesi graffe ({ }).A structure's initializer is either an expression of the same type, or a list of initializers for its members enclosed in curly braces ({ }). I membri senza nome del campo di bit non vengono inizializzati.Unnamed bit-field members are not initialized.

Quando viene inizializzata un'unione, initializer-list deve essere un'espressione costante singola.When a union is initialized, initializer-list must be a single constant expression. Il valore dell'espressione costante viene assegnato al primo membro dell'unione.The value of the constant expression is assigned to the first member of the union.

In caso di una matrice di dimensione sconosciuta, il numero di inizializzatori ne determina la dimensione e il relativo tipo diventa completo.If an array has unknown size, the number of initializers determines the size of the array, and its type becomes complete. Non è possibile specificare la ripetizione di un inizializzatore in C né inizializzare un elemento che si trova nel mezzo di una matrice, se non si forniscono anche tutti i valori precedenti.There is no way to specify repetition of an initializer in C, or to initialize an element in the middle of an array without providing all preceding values as well. Se si desidera che questa operazione sia presente nel programma, è necessario scrivere la routine in linguaggio assembly.If you need this operation in your program, write the routine in assembly language.

Si noti che il numero di inizializzatori può impostare la dimensione della matrice:Note that the number of initializers can set the size of the array:

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

Se si specifica la dimensione e si indica un numero di inizializzatori errato, il compilatore genera un errore.If you specify the size and give the wrong number of initializers, however, the compiler generates an error.

Sezione specifica MicrosoftMicrosoft Specific

La dimensione massima di una matrice è definita da size_t.The maximum size for an array is defined by size_t. Definito nel file di intestazione STDDEF.H, size_t è unsigned int con intervallo da 0x00000000 a 0x7CFFFFFF.Defined in the header file STDDEF.H, size_t is an unsigned int with the range 0x00000000 to 0x7CFFFFFF.

Fine sezione specifica MicrosoftEND Microsoft Specific

EsempiExamples

In questo esempio sono illustrati gli inizializzatori di una matrice.This example shows initializers for an array.

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

Questa istruzione dichiara P come una matrice quattro per tre e inizializza gli elementi della prima riga su 1, gli elementi della seconda riga su 2 e così via, fino alla quarta riga.This statement declares P as a four-by-three array and initializes the elements of its first row to 1, the elements of its second row to 2, and so on through the fourth row. Si noti che l'elenco di inizializzatori per la terza e quarta riga contiene virgole dopo l'ultima espressione costante.Note that the initializer list for the third and fourth rows contains commas after the last constant expression. Anche l'ultimo elenco di inizializzatori ({4, 4, 4,},) è seguito da una virgola.The last initializer list ({4, 4, 4,},) is also followed by a comma. Tali virgole aggiuntive sono consentite ma non necessarie; le uniche virgole necessarie sono quelle che separano le espressioni costanti e gli elenchi di inizializzatori.These extra commas are permitted but are not required; only commas that separate constant expressions from one another, and those that separate one initializer list from another, are required.

Se un membro di aggregazione non dispone di un elenco di inizializzatori incorporato, i valori vengono semplicemente assegnati, in ordine, a ogni membro del subaggregato.If an aggregate member has no embedded initializer list, values are simply assigned, in order, to each member of the subaggregate. Di conseguenza, l'inizializzazione illustrata nell'esempio precedente è equivalente alla seguente:Therefore, the initialization in the previous example is equivalent to the following:

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

È possibile che vi siano delle parentesi graffe anche attorno ai singoli inizializzatori presenti nell'elenco, il che contribuirebbe a chiarire l'esempio precedente.Braces can also appear around individual initializers in the list and would help to clarify the example above.

Quando si inizializza una variabile di aggregazione, è necessario utilizzare le parentesi graffe e gli elenchi di inizializzatori correttamente.When you initialize an aggregate variable, you must be careful to use braces and initializer lists properly. Nell'esempio seguente viene illustrata più dettagliatamente l'interpretazione delle parentesi graffe da parte del compilatore:The following example illustrates the compiler's interpretation of braces in more detail:

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

In questo esempio, nlist viene dichiarato come una matrice di strutture due per tre, in cui ogni struttura dispone di tre membri.In this example, nlist is declared as a 2-by-3 array of structures, each structure having three members. La riga 1 dell'inizializzazione assegna valori alla prima riga di nlist, come illustrato di seguito:Row 1 of the initialization assigns values to the first row of nlist, as follows:

  1. La prima parentesi graffa sinistra sulla riga 1 indica al compilatore che l'inizializzazione del primo membro di aggregazione di nlist (ovvero nlist[0]) sta iniziando.The first left brace on row 1 signals the compiler that initialization of the first aggregate member of nlist (that is, nlist[0]) is beginning.

  2. La seconda parentesi graffa sinistra indica che l'inizializzazione del primo membro di aggregazione di nlist[0] (ovvero la struttura presente in nlist[0][0]) sta iniziando.The second left brace indicates that initialization of the first aggregate member of nlist[0] (that is, the structure at nlist[0][0]) is beginning.

  3. La prima parentesi graffa destra termina l'inizializzazione della struttura nlist[0][0]; la parentesi graffa sinistra successiva avvia l'inizializzazione di nlist[0][1].The first right brace ends initialization of the structure nlist[0][0]; the next left brace starts initialization of nlist[0][1].

  4. Il processo continua fino alla fine della riga, dove la parentesi graffa destra di chiusura termina l'inizializzazione di nlist[0].The process continues until the end of the line, where the closing right brace ends initialization of nlist[0].

    Con modalità simili, la riga 2 assegna valori alla seconda riga di nlist.Row 2 assigns values to the second row of nlist in a similar way. Si noti che i set di parentesi graffe esterni che racchiudono gli inizializzatori sulle righe 1 e 2 sono necessari.Note that the outer sets of braces enclosing the initializers on rows 1 and 2 are required. La costruzione seguente, nella quale le parentesi graffe esterne sono omesse, genererebbe un errore:The following construction, which omits the outer braces, would cause an error:

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

In questa costruzione, la prima parentesi graffa sinistra sulla riga 1 avvia l'inizializzazione di nlist[0], che è una matrice di tre strutture.In this construction, the first left brace on line 1 starts the initialization of nlist[0], which is an array of three structures. I valori 1, 2 e 3 vengono assegnati ai tre membri della prima struttura.The values 1, 2, and 3 are assigned to the three members of the first structure. Quando viene rilevata la successiva parentesi graffa destra (dopo il valore 3), l'inizializzazione di nlist[0] è completa e le due strutture rimanenti della matrice a tre strutture vengono automaticamente inizializzate su 0.When the next right brace is encountered (after the value 3), initialization of nlist[0] is complete, and the two remaining structures in the three-structure array are automatically initialized to 0. In modo simile { 4,5,6 } inizializza la prima struttura presente nella seconda riga di nlist.Similarly, { 4,5,6 } initializes the first structure in the second row of nlist. Le due strutture rimanenti di nlist[1] vengono impostate su 0.The remaining two structures of nlist[1] are set to 0. Quando il compilatore rileva il successivo elenco di inizializzatori ({ 7,8,9 }) prova a inizializzare nlist[2].When the compiler encounters the next initializer list ( { 7,8,9 } ), it tries to initialize nlist[2]. Poiché nlist dispone di due sole righe, questo tentativo provoca un errore.Since nlist has only two rows, this attempt causes an error.

Nell'esempio seguente, i tre membri int di x vengono inizializzati, rispettivamente, su 1, 2 e 3.In this next example, the three int members of x are initialized to 1, 2, and 3, respectively.

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

Nella struttura list precedente, i tre elementi presenti nella prima riga di m vengono inizializzati su 4.0. Gli elementi nella restante riga di m vengono inizializzati su 0.0 per impostazione predefinita.In the list structure above, the three elements in the first row of m are initialized to 4.0; the elements of the remaining row of m are initialized to 0.0 by default.

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

La variabile di unione y, presente in questo esempio, viene inizializzata.The union variable y, in this example, is initialized. Il primo elemento dell'unione è una matrice, pertanto l'inizializzatore è un inizializzatore di aggregazione.The first element of the union is an array, so the initializer is an aggregate initializer. L'elenco di inizializzatori {'1'} assegna i valori alla prima riga della matrice.The initializer list {'1'} assigns values to the first row of the array. Poiché nell'elenco viene visualizzato un solo valore, l'elemento presente nella prima colonna viene inizializzato al carattere 1 e i due elementi rimanenti nella riga vengono inizializzati sul valore 0 per impostazione predefinita.Since only one value appears in the list, the element in the first column is initialized to the character 1, and the remaining two elements in the row are initialized to the value 0 by default. Analogamente, il primo elemento della seconda riga di x viene inizializzato al carattere 4, mentre i due elementi rimanenti nella riga vengono inizializzati sul valore 0.Similarly, the first element of the second row of x is initialized to the character 4, and the remaining two elements in the row are initialized to the value 0.

Vedere ancheSee Also

InizializzazioneInitialization