Confusione sull'inizializzazione dell'array in C

In linguaggio C, se inizializza un array come questo:

int a[5] = {1,2};

quindi tutti gli elementi dell'array che non sono inizializzati esplicitamente verranno inizializzati implicitamente con zeri.

Ma, se inizializzo un array come questo:

int a[5]={a[2]=1};

printf("%d %d %d %d %d\n", a[0], a[1],a[2], a[3], a[4]);

produzione:

1 0 1 0 0

Non capisco, perché a[0]stampa 1invece di 0? È un comportamento indefinito?

Nota: questa domanda è stata posta in un'intervista.

TL; DR: Non credo che il comportamento di int a[5]={a[2]=1};sia ben definito, almeno in C99.

La parte divertente è che l'unico bit che ha senso per me è la parte su cui stai chiedendo: a[0]è impostato su 1perché l'operatore di assegnazione restituisce il valore che è stato assegnato. È tutto il resto che non è chiaro.

Se il codice fosse stato int a[5] = { [2] = 1 }, tutto sarebbe stato facile: è un'impostazione di inizializzazione designata a[2]per 1e tutto il resto per 0. Ma con { a[2] = 1 }abbiamo un inizializzatore non designato contenente un'espressione di assegnazione, e cadiamo in una tana di coniglio.

Ecco cosa ho trovato finora:

• a deve essere una variabile locale.

  6.7.8 Inizializzazione

  4. Tutte le espressioni in un inizializzatore per un oggetto che ha una durata di memorizzazione statica devono essere espressioni costanti o stringhe letterali.

  a[2] = 1non è un'espressione costante, quindi adeve avere la memorizzazione automatica.

• a è nell'ambito della propria inizializzazione.

  6.2.1 Scopo degli identificatori

  7. I tag di struttura, unione ed enumerazione hanno un ambito che inizia subito dopo la comparsa del tag in uno specificatore di tipo che dichiara il tag. Ogni costante di enumerazione ha un ambito che inizia subito dopo la comparsa del relativo enumeratore di definizione in un elenco di enumeratori. Qualsiasi altro identificatore ha uno scopo che inizia subito dopo il completamento del suo dichiaratore.

  Il dichiaratore è a[5], quindi le variabili rientrano nell'ambito della propria inizializzazione.

• a è vivo nella propria inizializzazione.

  6.2.4 Durate di conservazione degli oggetti

  4. Un oggetto cui identificatore è dichiarata in alcun legame e senza l'identificatore della classe di archiviazione staticha durata di memorizzazione automatica .

  5. Per un tale oggetto che non ha un tipo di array di lunghezza variabile, la sua durata si estende dall'ingresso nel blocco a cui è associato fino a quando l'esecuzione di quel blocco non termina in alcun modo. (L'immissione di un blocco racchiuso o la chiamata di una funzione sospende, ma non termina, l'esecuzione del blocco corrente.) Se il blocco viene inserito ricorsivamente, viene creata ogni volta una nuova istanza dell'oggetto. Il valore iniziale dell'oggetto è indeterminato. Se per l'oggetto è specificata un'inizializzazione, essa viene eseguita ogni volta che si raggiunge la dichiarazione nell'esecuzione del blocco; in caso contrario, il valore diventa indeterminato ogni volta che viene raggiunta la dichiarazione.

• C'è un punto di sequenza dopo a[2]=1.

  6.8 Dichiarazioni e blocchi

  4. Una piena espressione è un'espressione che non fa parte di un'altra espressione o di un declarator. Ciascuno dei seguenti è un'espressione completa: un inizializzatore ; l'espressione in una dichiarazione di espressione; l'espressione di controllo di un'istruzione di selezione ( ifo switch); l'espressione di controllo di una dichiarazione whileo do; ciascuna delle espressioni (facoltative) di una fordichiarazione; l'espressione (facoltativa) in returnun'istruzione. La fine di un'espressione completa è un punto della sequenza.

  Si noti che per esempio nel int foo[] = { 1, 2, 3 }la { 1, 2, 3 }parte è una lista brace-chiuso di initializers, ciascuno dei quali ha un punto sequenza dopo.

• L'inizializzazione viene eseguita nell'ordine dell'elenco degli inizializzatori.

  6.7.8 Inizializzazione

  17. Ogni elenco di inizializzatori racchiuso tra parentesi graffe ha un oggetto corrente associato . Quando non sono presenti designazioni, i suboggetti dell'oggetto corrente vengono inizializzati in ordine in base al tipo di oggetto corrente: elementi della matrice in ordine crescente di pedici, membri della struttura in ordine di dichiarazione e il primo membro denominato di un'unione. [...]

   

  19. L'inizializzazione deve avvenire nell'ordine dell'elenco degli inizializzatori, ogni inizializzatore fornito per un particolare oggetto secondario sovrascrive qualsiasi inizializzatore elencato in precedenza per lo stesso oggetto secondario; tutti i suboggetti che non sono inizializzati esplicitamente devono essere inizializzati implicitamente come gli oggetti che hanno una durata di memorizzazione statica.

• Tuttavia, le espressioni dell'inizializzatore non vengono necessariamente valutate in ordine.

  6.7.8 Inizializzazione

  23. L'ordine in cui si verificano gli effetti collaterali tra le espressioni dell'elenco di inizializzazione non è specificato.

Tuttavia, ciò lascia ancora alcune domande senza risposta:

• I punti della sequenza sono anche rilevanti? La regola di base è:

  6.5 Espressioni

  2. Tra il punto della sequenza precedente e quello successivo un oggetto deve avere il suo valore memorizzato modificato al massimo una volta dalla valutazione di un'espressione . Inoltre, il valore precedente deve essere letto solo per determinare il valore da memorizzare.

  a[2] = 1 è un'espressione, ma non lo è l'inizializzazione.

  Ciò è leggermente contraddetto dall'allegato J:

  J.2 Comportamento indefinito

  • Tra due punti di sequenza, un oggetto viene modificato più di una volta, oppure viene modificato e il valore precedente viene letto diversamente che per determinare il valore da memorizzare (6.5).

  L'allegato J dice che ogni modifica conta, non solo le modifiche tramite espressioni. Ma dato che gli allegati non sono normativi, possiamo probabilmente ignorarlo.

• Come vengono sequenziate le inizializzazioni dei suboggetti rispetto alle espressioni di inizializzazione? Tutti gli inizializzatori vengono valutati per primi (in un certo ordine), quindi i suboggetti vengono inizializzati con i risultati (nell'ordine dell'elenco degli inizializzatori)? O possono essere interfogliati?

Penso int a[5] = { a[2] = 1 }sia eseguito come segue:

1. La memoria per aviene allocata quando viene inserito il blocco contenitore. I contenuti sono indeterminati a questo punto.
2. L '(unico) inizializzatore viene eseguito ( a[2] = 1), seguito da un punto di sequenza. Questo memorizza 1in a[2]e ritorna 1.
3. Che 1viene utilizzato per inizializzare a[0](la prima inizializzazione inizializza il primo sotto-oggetto).

Ma qui le cose si fanno sfumata perché gli elementi rimanenti ( a[1], a[2], a[3], a[4]) dovrebbero essere inizializzato a 0, ma non è chiaro quando: lo fa accadere prima a[2] = 1viene valutata? In tal caso, a[2] = 1"vincerebbe" e sovrascriverebbe a[2], ma quell'assegnazione avrebbe un comportamento indefinito perché non esiste un punto di sequenza tra l'inizializzazione zero e l'espressione dell'assegnazione? I punti della sequenza sono anche rilevanti (vedi sopra)? O si verifica zero inizializzazione dopo che tutti gli inizializzatori sono stati valutati? Se è così, a[2]dovrebbe finire per essere 0.

Poiché lo standard C non definisce chiaramente cosa succede qui, credo che il comportamento non sia definito (per omissione).

Non capisco, perché a[0]stampa 1invece di 0?

Presumibilmente viene a[2]=1inizializzato per a[2]primo e il risultato dell'espressione viene utilizzato per inizializzare a[0].

Da N2176 (bozza C17):

6.7.9 Inizializzazione

23. Le valutazioni delle espressioni dell'elenco di inizializzazione sono sequenziate in modo indeterminato l'una rispetto all'altra e quindi l'ordine in cui si verificano gli effetti collaterali non è specificato. ¹⁵⁴⁾

Quindi sembrerebbe che anche l'output 1 0 0 0 0sarebbe stato possibile.

Conclusione: non scrivere inizializzatori che modificano al volo la variabile inizializzata.

Penso che lo standard C11 copra questo comportamento e dica che il risultato non è specificato e non credo che C18 abbia apportato modifiche rilevanti in quest'area.

Il linguaggio standard non è facile da analizzare. La sezione pertinente dello standard è §6.7.9 Inizializzazione . La sintassi è documentata come:

initializer:
                assignment-expression
                { initializer-list }
                { initializer-list , }
initializer-list:
                designationopt initializer
                initializer-list , designationopt initializer
designation:
                designator-list =
designator-list:
                designator
                designator-list designator
designator:
                [ constant-expression ]
                . identifier

Si noti che uno dei termini è espressione-assegnazione e poiché a[2] = 1è indubbiamente un'espressione di assegnazione, è consentito all'interno di inizializzatori per array con durata non statica:

§4 Tutte le espressioni in un inizializzatore per un oggetto che ha una durata di archiviazione statica o di thread devono essere espressioni costanti o stringhe letterali.

Uno dei paragrafi chiave è:

§19 L'inizializzazione deve avvenire nell'ordine della lista degli inizializzatori, ogni inizializzatore fornito per un particolare sottooggetto sovrascrive qualsiasi inizializzatore precedentemente elencato per lo stesso sottooggetto; ¹⁵¹⁾ tutti i suboggetti che non sono inizializzati esplicitamente devono essere inizializzati implicitamente come gli oggetti che hanno una durata di memorizzazione statica.

¹⁵¹⁾ Qualsiasi inizializzatore per il suboggetto che viene sovrascritto e quindi non utilizzato per inizializzare quel suboggetto potrebbe non essere valutato affatto.

E un altro paragrafo chiave è:

§23 Le valutazioni delle espressioni della lista di inizializzazione sono in sequenza indeterminata l'una rispetto all'altra e quindi l'ordine in cui si verificano gli effetti collaterali non è specificato. ¹⁵²⁾

¹⁵²⁾ In particolare, l'ordine di valutazione non deve essere lo stesso dell'ordine di inizializzazione del suboggetto.

Sono abbastanza sicuro che il paragrafo §23 indichi che la notazione nella domanda:

int a[5] = { a[2] = 1 };

porta a comportamenti non specificati. L'assegnazione a a[2]è un effetto collaterale e l'ordine di valutazione delle espressioni è in sequenza indeterminata l'una rispetto all'altra. Di conseguenza, non penso che ci sia un modo per fare appello allo standard e affermare che un particolare compilatore lo gestisce correttamente o in modo errato.

La mia comprensione a[2]=1restituisce il valore 1, quindi il codice diventa

int a[5]={a[2]=1} --> int a[5]={1}

int a[5]={1}assegna un valore a [0] = 1

Quindi stampa 1 per a [0]

Per esempio

char str[10]={‘H’,‘a’,‘i’};


char str[0] = ‘H’;
char str[1] = ‘a’;
char str[2] = ‘i;

Provo a dare una risposta breve e semplice per il puzzle: int a[5] = { a[2] = 1 };

1. Il primo a[2] = 1è impostato. Ciò significa che l'array dice:0 0 1 0 0
2. Ma ecco, dato che l'hai fatto tra { }parentesi, che servono per inizializzare l'array in ordine, prende il primo valore (che è 1) e lo imposta su a[0]. È come se int a[5] = { a[2] };rimanesse, dove già siamo arrivati a[2] = 1. L'array risultante è ora:1 0 1 0 0

Un altro esempio: int a[6] = { a[3] = 1, a[4] = 2, a[5] = 3 };- Anche se l'ordine è alquanto arbitrario, supponendo che vada da sinistra a destra, andrebbe in questi 6 passaggi:

0 0 0 1 0 0
1 0 0 1 0 0
1 0 0 1 2 0
1 2 0 1 2 0
1 2 0 1 2 3
1 2 3 1 2 3

L'assegnazione a[2]= 1è un'espressione che ha il valore 1e in sostanza hai scritto int a[5]= { 1 };(con l'effetto collaterale che a[2]viene assegnato 1anche tu ).

Credo che int a[5]={ a[2]=1 };sia un buon esempio per un programmatore che si spara al proprio piede.

Potrei essere tentato di pensare che quello che intendevi fosse int a[5]={ [2]=1 };quale sarebbe un elemento di impostazione dell'inizializzatore designato C99 da 2 a 1 e il resto a zero.

Nel raro caso in cui intendevi davvero int a[5]={ 1 }; a[2]=1;, allora sarebbe un modo divertente di scriverlo. Ad ogni modo, questo è ciò a cui si riduce il codice, anche se alcuni qui hanno sottolineato che non è ben definito quando la scrittura a[2]viene effettivamente eseguita. Il trabocchetto qui è che a[2]=1non è un inizializzatore designato ma un semplice assegnamento che a sua volta ha il valore 1.