operatore di incremento che non funziona con sizeof

Question

Eventuali duplicati:
Why does sizeof(x++) not increment x?

Chiedo solo perché l'operatore di incremento non funziona nel frammento di codice qui sotto:

int main() 
    { 
     int a = 10; 
     int b = sizeof(a++); 
     cout<<"a: "<<a<<endl; 
     cout<<"b: "<<b<<endl; 
     return 0; 
    } 

uscita -

un: 10

b: 4

Answer 1

sizeof non valuta la sua argomentazione. Calcola staticamente la dimensione dell'argomento al momento della compilazione senza causare l'esecuzione di alcun codice.

Answer 2

L'operando dell'operatore sizeof è inutilizzato, non è valutato. Questo è un comportamento standard.

Answer 3

sizeof non è una funzione in C.

Il suo argomento non viene in realtà valutata, solo il suo tipo è e questo è fatto a tempo di compilazione. Nel codice, l'assegnazione è equivalente (nell'architettura) a:

int b = 4 

Answer 4

Quando il tipo di espressione sizeof non è un tipo di matrice variabile modificata, l'espressione non viene valutata perché il tipo è completamente noto al momento della compilazione. int non ha parti modificate in modo variabile.

In C++ (almeno C++ 11) non ci sono tipi variabilmente modificati (almeno non come nel concetto di C - si può sostenere che new int[a++] utilizza un tipo di matrice variabilmente modificato, ma il tipo non sfuggire a qualsiasi altra parte della lingua, in particolare, non a sizeof), quindi in C++, l'espressione to sizeof non viene mai valutata. In C, non è specificato se un'espressione viene valutata se non influenza la dimensione di un tipo di matrice modificato in modo variabile. Ad esempio

int main() 
{ 
    int a = 10; 
    int b = sizeof(int[a++ ? 1 : 1]); 
    cout<<"a: "<<a<<endl; 
    cout<<"b: "<<b<<endl; 
    return 0; 
} 

In C (da C99 in poi), questo può uscita 11 per a, ma può anche uscita 10, a seconda che il compilatore è abbastanza intelligente omettere valutare a++, deducendo che il sizeof int[10] è calcolato al momento della compilazione.

---

Nota a piè di pagina: i tipi di array modificati in modo variabile sono anche chiamati tipi VLA (array di lunghezza variabile). In breve, un tipo variabilmente modificato è un tipo che è o un tipo VLA o un tipo che dipende da uno. Ad esempio int(*)[a++].

Answer 5

In un contesto non valorizzato, solo il tipo è importante. Lo stesso accade quando si chiamano le funzioni:

void f(); 

sizeof(f()); // f not called