Come sizeof (array) funziona in fase di runtime?

Question

Ho letto che l'operatore sizeof in C viene interpretato in fase di compilazione e poiché al momento della compilazione il compilatore conosce la dimensione dell'array e il suo tipo, sizeof è utilizzato per calcolare il numero di byte occupati dall'array. Ma come funziona sizeof working per il seguente codice:

#include<stdio.h> 
#include<string.h> 
int main() 
{ 
    int n; 
    scanf("%d",&n); 
    int a[n]; 
    int s=sizeof(a); 
    printf("%d",s); 
    return 0; 
} 

Qui dimensione della matrice non è noto al momento della compilazione, allora come sta funzionando correttamente?

Answer 1

sizeof viene sempre calcolato in fase di compilazione in C89. Dal momento che C99 e matrici di lunghezza variabile, viene calcolato in fase di esecuzione quando una matrice di lunghezza variabile fa parte dell'espressione nell'operando sizeof.

Uguale per la valutazione dell'operando sizeof: non viene valutato in C89 ma in C99 se l'operando è di tipo a lunghezza variabile viene valutato. Ad esempio:

int n = 5; 
sizeof (int [n++]); 

// n is now 6 

Answer 2

In tal caso, sizeof() viene valutato in fase di esecuzione. Il compilatore, poiché sa che la dimensione di a si basa sul valore di n al momento della dichiarazione dell'array, genera codice per utilizzare il valore appropriato di n per restituire un valore ragionevole per sizeof().

In C99, non tutti gli usi di sizeof() possono essere completamente valutati in fase di compilazione e ridotti a una costante di runtime.

Answer 3

Ho letto che sizeof di C viene interpretato in fase di compilazione

sizeof è determinato in fase di compilazione in tutti i casi a parte per VLA. Per un VLA, sizeof viene valutato in fase di esecuzione.

Answer 4

Poiché si sta applicando sizeof a un array di lunghezza variabile, la cui dimensione non è conosciuta completamente in fase di compilazione, il compilatore deve generare codice per fare parte di esso in fase di esecuzione.

gcc 4.6.3 di ottimizzatori di alto livello convertire il codice che avete mostrato per

scanf ("%d", &n); 
t12 = (long unsigned int) n; 
t13 = t12 * 4; 
__builtin_alloca (t13); 
t16 = (unsigned int) t12; 
t17 = t16 * 4; 
s18 = (int) t17; 
printf ("%d", s18); 

fa che spiegano cosa sta succedendo sotto il cofano? (Non lasciatevi scoraggiare dal numero stupido di variabili temporanee - questo è un artefatto del programma che si trova nel formato static single assignment nel punto in cui ho chiesto un dump di codice intermedio.)

Answer 5

Dallo standard C99 :

6.5.3.4

l'operatore sizeof produce la dimensione (in byte) del suo operando, che può essere un espressione o il nome di un tipo tra parentesi. La dimensione è determinata dal tipo di dell'operando. Il risultato è un numero intero. Se il tipo di operando è un tipo a lunghezza variabile , l'operando viene valutato; in caso contrario, l'operando non viene valutato e il risultato è una costante intera di .

Answer 6

Indipendentemente dal fatto sizeof viene calcolato in fase di compilazione o esecuzione (o più formalmente parlando, se il risultato è un numero intero espressione costante), il risultato di sizeof è puramente basato sulla tipo del suo argomento e non ha alcun nascosto dati che accompagnano la matrice a lunghezza variabile stessa. Naturalmente quando sizeof viene applicato a un tipo variabilmente modificato, il programma generato deve tenere traccia di quella dimensione da qualche parte. Ma potrebbe semplicemente ricalcolarlo se l'espressione fosse abbastanza semplice e le variabili da cui originariamente derivava la lunghezza non possano essere cambiate. Oppure, potrebbe memorizzare la dimensione del tipo da qualche parte (essenzialmente in una variabile locale nascosta), ma questo non sarebbe collegato all'oggetto VLA in alcun modo osservabile (ad esempio, se si passa un puntatore al primo elemento del VLA a un'altra funzione, quel puntatore non può essere utilizzato per recuperare la lunghezza VLA).