2012-06-24 6 views
10

Sono confuso circa il tempo di valutazione dell'operatore sizeof.
Quando viene valutato l'operatore sizeof?sizeof operatore compile-time o run-time

Il suo tempo di valutazione [compile-time or run-time] dipende dalla lingua [C? C++?]?

È possibile utilizzare sizeof in caso di oggetti creati in fase di runtime [in C++]?

risposta

19

In quasi tutti i casi, sizeof viene valutato in base a informazioni di tipo statico (in fase di compilazione, in pratica).

Un'eccezione (l'unica, a mio avviso) è nel caso degli array di lunghezza variabile C99 (VLA).

+0

Un'eccellente dimostrazione di quanto siano ridicoli i VLA perversione. Il consumo esplicito di stack a lunghezza variabile IMHO ('alloca') è molto meglio. – valdo

+3

@valdo, non vedo cosa dovrebbe dimostrare. Sembra normale che 'sizeof' un oggetto che è dimensionato dinamicamente al momento dell'esecuzione deve essere valutato al momento dell'esecuzione. E confrontando con altri meccanismi come 'alloca' (che non è nemmeno standardizzato e non ha scope) o' malloc' che entrambi non sanno nulla delle dimensioni degli oggetti che creano non è molto utile. –

+0

@Jens Gustedt: Scusa, volevo dire * esempio *, non un * prova *. 'alloca' non ha bisogno di una liberazione/ambito esplicito. Il codice generato è (più o meno) identico ai VLA - spostando il puntatore dello stack + sondando la memoria dello stack al passaggio del confine della pagina. Personalmente uso 'sizeof' in modo molto aggressivo nella meta-programmazione (temapltes e così via), e mi piacerebbe essere sicuro al 100% che qualunque cosa si trovi all'interno di' sizeof' non sarà mai valutata in fase di esecuzione. – valdo

11

Quasi sempre tempo di compilazione. Ma gli esempi che seguono potrebbero essere di vostro interesse:

char c[100]; 
sizeof(c); // 100 

char* d = malloc(100); 
sizeof(d); //probably 4 or 8. tells you the size of the pointer! 

BaseClass* b = new DerivedClass(); 
sizeof(b); //probably 4 or 8 as above. 

void foo(char[100] x) { 
    sizeof(x); //probably 4 or 8. I hate this. Don't use this style for this reason. 
} 

struct Foo { 
    char a[100]; 
    char b[200]; 
}; 

sizeof(struct Foo); //probably 300. Technically architecture dependent but it will be 
//the # of bytes the compiler needs to make a Foo. 

struct Foo foo; 
sizeof(foo); //same as sizeof(struct Foo) 

struct Foo* fooP; 
sizeof(fooP); //probably 4 or 8 

class ForwardDeclaredClass; 

ForwardDeclaredClass* p; 
sizeof(p); //4 or 8 
ForwardDeclaredClass fdc; //compile time error. Compiler 
//doesn't know how many bytes to allocate 

sizeof(ForwardDeclaredClass); //compile time error, same reason 
+0

Forse "void foo (char [100] x)" dovrebbe effettivamente essere "void foo (char x [100])"? –

0

Tempo di compilazione, perché è calcolare la dimensione in fase di compilazione "Tempo di compilazione" è quando si genera il codice - quando il compilatore converte il codice sorgente in IL..