Perché sizeof (x ++) non incrementa x?

Ecco il codice compilato in windows dev c ++:

#include <stdio.h>

int main() {
    int x = 5;
    printf("%d and ", sizeof(x++)); // note 1
    printf("%d\n", x); // note 2
    return 0;
}

Mi aspetto xdi essere 6 dopo aver eseguito la nota 1 . Tuttavia, l'output è:

4 and 5

Qualcuno può spiegare perché xnon si incrementa dopo la nota 1 ?

Dallo standard C99 (l'enfasi è mia)

6.5.3.4/2

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

sizeofè un operatore in fase di compilazione, quindi al momento della compilazione sizeofe il suo operando vengono sostituiti dal valore del risultato. L' operando non viene valutato (tranne quando si tratta di un array di lunghezza variabile); conta solo il tipo di risultato.

short func(short x) {  // this function never gets called !!
   printf("%d", x);    // this print never happens
   return x;
}

int main() {
   printf("%d", sizeof(func(3))); // all that matters to sizeof is the 
                                  // return type of the function.
   return 0;
}

Produzione:

2

come shortoccupa 2 byte sulla mia macchina.

Modifica del tipo di ritorno della funzione in double:

double func(short x) {
// rest all same

darà 8come output.

sizeof(foo) cerca davvero di scoprire la dimensione di un'espressione in fase di compilazione:

6.5.3.4:

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

In breve: array di lunghezza variabile, eseguiti in fase di esecuzione. (Nota: le matrici a lunghezza variabile sono una caratteristica specifica, non le matrici assegnate con malloc(3).) Altrimenti, viene calcolato solo il tipo di espressione e quello al momento della compilazione.

sizeofè un operatore incorporato in fase di compilazione e non è una funzione. Ciò diventa molto chiaro nei casi in cui è possibile utilizzarlo senza parentesi:

(sizeof x)  //this also works

Nota

Questa risposta è stata unita da un duplicato, il che spiega la data tardiva.

Originale

Tranne che per le matrici di lunghezza variabile sizeof non valuta i suoi argomenti. Possiamo vedere questo dal progetto di sezione standard C99 6.5.3.4 La dimensione dell'operatore paragrafo 2 che dice:

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

Un commento ( ora rimosso ) ha chiesto se qualcosa di simile avrebbe valutato in fase di esecuzione:

sizeof( char[x++]  ) ;

e in effetti avrebbe funzionato anche qualcosa del genere ( vederli entrambi dal vivo ):

sizeof( char[func()]  ) ;

poiché sono entrambi array di lunghezza variabile. Anche se non vedo molto uso pratico in nessuno dei due.

Si noti che le matrici a lunghezza variabile sono trattate nel paragrafo 4 dei dichiaratori di array della sezione standard C99 :6.7.5.2

[...] Se la dimensione è un'espressione costante intera e il tipo di elemento ha una dimensione costante nota, il tipo di array non è un tipo di array a lunghezza variabile; in caso contrario, il tipo di array è un tipo di array a lunghezza variabile.

Aggiornare

In C11 la risposta cambia per il caso VLA, in alcuni casi non è specificato se l'espressione della dimensione sia valutata o meno. Dalla sezione 6.7.6.2 Dichiaratori di array che dice:

[...] Laddove un'espressione di dimensione fa parte dell'operando di un operatore sizeof e la modifica del valore dell'espressione di dimensione non influisce sul risultato dell'operatore, non è specificato se l'espressione di dimensione sia valutata o meno.

Ad esempio in un caso come questo ( vederlo dal vivo ):

sizeof( int (*)[x++] )

Poiché l'operando sizeofdell'operatore non viene valutato, è possibile eseguire questa operazione:

int f(); //no definition, which means we cannot call it

int main(void) {
        printf("%d", sizeof(f()) );  //no linker error
        return 0;
}

Demo online: http://ideone.com/S8e2Y

Cioè, non è necessario definire la funzione fse viene utilizzata sizeofsolo in. Questa tecnica viene utilizzata principalmente nella metaprogrammazione di modelli C ++, poiché anche in C ++ l'operando di sizeofnon viene valutato.

Perché funziona? Funziona perché l' sizeofoperatore non opera sul valore , ma sul tipo dell'espressione. Quindi quando scrivi sizeof(f()), opera sul tipo dell'espressione f()e che non è altro che il tipo restituito della funzione f. Il tipo restituito è sempre lo stesso, indipendentemente dal valore che la funzione restituirebbe se fosse effettivamente eseguita.

In C ++, puoi anche questo:

struct A
{
  A(); //no definition, which means we cannot create instance!
  int f(); //no definition, which means we cannot call it
};

int main() {
        std::cout << sizeof(A().f())<< std::endl;
        return 0;
}

Eppure sembra che, in primo luogo sizeof, sto creando un'istanza di A, scrivendo A(), e quindi chiamando la funzione fsull'istanza, scrivendo A().f(), ma non succede nulla del genere.

Demo: http://ideone.com/egPMi

Ecco un altro argomento che spiega alcune altre proprietà interessanti di sizeof:

• dimensione di prendere due argomenti

L'esecuzione non può avvenire durante la compilazione. Quindi ++i/ i++non accadrà. Inoltre sizeof(foo())non eseguirà la funzione ma restituirà il tipo corretto.

sizeofviene eseguito in fase di compilazione, ma x++può essere valutato solo in fase di esecuzione. Per risolvere questo, lo standard C ++ impone che l'operando di sizeofnon sia valutato. Lo standard C dice:

Se il tipo di operando [di sizeof] è un tipo di array di lunghezza variabile, viene valutato l'operando; in caso contrario, l'operando non viene valutato e il risultato è una costante intera.

sizeof() l'operatore fornisce solo la dimensione del tipo di dati, non valuta gli elementi interni.