2011-08-31 20 views
6

non v'è alcuna differenza tra, ad esempioDifferenza tra array [n] e array []?

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

e,

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

compilatore ha bisogno di calcolare il numero di elementi da sé per il primo caso, e che può prendere un po 'di tempo ({...} di 1234332534 elementi), quindi il secondo caso è efficiente rispetto al primo?

+0

"matrice di 1234332534 elementi" - L'allocazione di circa 4 GB (1,2 miliardi di ints) sullo stack può essere problematica. Le dimensioni dello stack usuali sono dell'ordine di pochi megabyte. Oltre a questo, non vi è alcun motivo per utilizzare un metodo sull'altro, poiché se c'è un sovraccarico, accade comunque solo al momento della compilazione. – Damon

+4

Il tempo impiegato per "contare" gli elementi sarà impercettibile in relazione al resto della compilation - infatti, * deve * contare anche nella seconda forma comunque, penso (per segnalare un errore), e in qualsiasi caso elaborerà lo stesso numero di elementi. 'int arr [2] = {1, 2, 3};' - errm? –

risposta

5

Non c'è differenza, a condizione che il conteggio degli elementi espliciti tra [] sia uguale al numero di inizializzatori tra {}.

La domanda sull'efficienza è discutibile. La dimensione dell'array è determinata al momento della compilazione, il che significa che non ha alcun impatto sull'efficienza del codice. E poiché in ogni caso il compilatore dovrà analizzare l'elenco di inizializzazione in ogni caso, non ha alcun impatto reale sull'efficienza della compilazione.

+2

Il numero di elementi inizializzati può essere inferiore al numero in '[]'. È un errore se ce ne sono altri. – wallyk

+0

@wallyk: Beh, non ho mai detto che il numero * deve * essere lo stesso. Ho detto: * non c'è differenza * se il numero è lo stesso. Se il numero in '[]' è maggiore di quello che ci sarà differenza, poiché imporrà la creazione di elementi extra inizializzati di default (o zero inizializzati in C). – AnT

8

Questa dichiarazione di matrice:

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

è esattamente lo stesso come:

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

Il numero di elementi è calcolato al momento della compilazione, quindi non c'è alcun costo runtime associato a tale.

Il vantaggio della prima dichiarazione è che non richiede al programmatore di contare manualmente il numero di elementi, quindi è una dichiarazione di array più efficiente in tal senso.

1

Nessuna differenza, tranne il fatto che il programmatore non deve determinare quanti elementi sono presenti nell'array. Il compilatore continua a contare gli elementi per allocare la quantità corretta, quindi entrambi richiedono al compilatore lo stesso tempo di compilazione.

2
  1. Non c'è differenza nel risultato finale; tuttavia, la prima forma è più facile da scrivere e da mantenere, perché non è necessario contare manualmente gli elementi.
  2. Il compilatore probabilmente deve comunque contare gli elementi: deve rilevare se sono più perché si tratta di un errore di compilazione, e se sono meno gli altri devono essere inizializzati a zero.
  3. In ogni caso, tale conteggio viene eseguito in fase di compilazione, quindi non c'è alcun impatto sulle prestazioni dell'eseguibile generato.
  4. In generale non si hanno mai array molto grandi creati nello stack o come globali (perché generalmente le grandi allocazioni dello stack falliscono, e gli array di grandi dimensioni come quelli globali porteranno a enormi eseguibili ).
  5. E anche se si è riusciti a far accettare al compilatore un array statico/locale di 1234332534 elementi, il conteggio degli elementi sarà probabilmente l'ultimo dei problemi di prestazioni di questa compilation.

†. d'altra parte, i grandi array globali sono il modo in cui le risorse binarie sono spesso incluse nel firmware per essere proiettate su dispositivi embedded. Ma non credo che qualcuno considererà questo metodo di forza bruta per qualcosa di più grande di diversi MB.

+0

+1 per # 5. :) (anche in 15 caratteri) –

0

Nel secondo caso il precompilatore riceve un errore se viene fornito un numero errato di valori per inizializzare la memoria. Questo è praticamente tutto.

+2

Non vero. Il numero in '[]' s potrebbe essere più grande della dimensione della lista di inizializzazione; nel qual caso si presume che l'area rimanente sia inizializzata a zero. –

+0

È consentito fornire meno elementi della dimensione dell'array, gli altri elementi sono inizializzati a zero. E il precompilatore non è coinvolto qui, il controllo è fatto dal compilatore vero e proprio. –

Problemi correlati