2012-12-27 3 views
8

Eventuali duplicati:
Why does sizeof(x++) not increment x?operatore di incremento che non funziona con sizeof

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

+1

Sizeof è un operatore in fase di compilazione e l'intero sizeof() viene sostituito con il suo valore risultante prima della compilazione del codice. Vedere: http: // stackoverflow.it/questions/8225776/why-does-sizeofx-not-increment-x/8225813 # 8225813 –

+0

Qual è il comportamento previsto per quel codice? –

+0

@EtiennedeMartel: Immagino che l'aspettativa del richiedente sia a = 11, b = 10. –

risposta

10

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

+0

Perché sono sorpreso da questo? –

+5

@ JanDvorak: Perché non conosci il C++? – sbi

+0

@sbi Sì, questa è una causa probabile –

2

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

+0

Ma 'a' è usato sia per determinare' sizeof (a ++) 'che in seguito per l'output. –

1

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 
+0

"questo è fatto in fase di esecuzione." - Davvero? –

+0

ergh, typo. scusa. – lbonn

8

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++].

+0

+1: in C++ 11, 5.3.3p1, "L'operatore sizeof produce il numero di byte nella rappresentazione dell'oggetto del suo operando L'operando è un'espressione ** che è un operando non valutato ** (Clausola 5), o un id-tipo parentesi. " enfasi aggiunta. – WhozCraig

0

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

void f(); 

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