Por que sizeof (x ++) não incrementa x?

Aqui está o código compilado nas janelas 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;
}

Espero xser 6 depois de executar a nota 1 . No entanto, a saída é:

4 and 5

Alguém pode explicar por xque não aumenta após a nota 1 ?

Do padrão C99 (a ênfase é minha)

6.5.3.4/2

O operador sizeof gera o tamanho (em bytes) de seu operando, que pode ser uma expressão ou o nome entre parênteses de um tipo. O tamanho é determinado a partir do tipo do operando. O resultado é um número inteiro. Se o tipo do operando for um tipo de matriz de comprimento variável, o operando será avaliado; caso contrário, o operando não é avaliado e o resultado é uma constante inteira.

sizeofé um operador em tempo de compilação, portanto, no momento da compilação sizeofe seu operando, é substituído pelo valor do resultado. O operando não é avaliado (exceto quando é uma matriz de comprimento variável); apenas o tipo do resultado é importante.

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;
}

Resultado:

2

como shortocupa 2 bytes na minha máquina.

Alterando o tipo de retorno da função para double:

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

dará 8como saída.

sizeof(foo) tenta muito descobrir o tamanho de uma expressão em tempo de compilação:

6.5.3.4:

O operador sizeof gera o tamanho (em bytes) de seu operando, que pode ser uma expressão ou o nome entre parênteses de um tipo. O tamanho é determinado a partir do tipo do operando. O resultado é um número inteiro. Se o tipo do operando for um tipo de matriz de comprimento variável, o operando será avaliado; caso contrário, o operando não é avaliado e o resultado é uma constante inteira.

Em resumo: matrizes de comprimento variável, executadas em tempo de execução. (Nota: Matrizes de comprimento variável são um recurso específico - não matrizes alocadas com malloc(3).) Caso contrário, apenas o tipo da expressão é calculado e o mesmo no momento da compilação.

sizeofé um operador interno em tempo de compilação e não é uma função. Isso fica muito claro nos casos em que você pode usá-lo sem os parênteses:

(sizeof x)  //this also works

Nota

Esta resposta foi mesclada a partir de uma duplicata, o que explica a data final.

Original

Exceto para matrizes de comprimento variável, sizeof não avalia seus argumentos. Podemos ver isso a partir da seção padrão projecto C99 6.5.3.4 O operador sizeof parágrafo 2 , que diz:

O operador sizeof gera o tamanho (em bytes) de seu operando, que pode ser uma expressão ou o nome entre parênteses de um tipo. O tamanho é determinado a partir do tipo do operando. O resultado é um número inteiro. Se o tipo do operando for um tipo de matriz de comprimento variável, o operando será avaliado; caso contrário, o operando não é avaliado e o resultado é uma constante inteira.

Um comentário ( agora removido ) perguntou se algo assim seria avaliado em tempo de execução:

sizeof( char[x++]  ) ;

e, de fato, algo assim também funcionaria ( veja os dois ao vivo ):

sizeof( char[func()]  ) ;

já que ambos são matrizes de comprimento variável. Embora eu não veja muito uso prático em nenhum deles.

Observe que as matrizes de comprimento variável são abordadas no parágrafo 4 da seção C99 da seção padrão do rascunho :6.7.5.2

[...] Se o tamanho for uma expressão constante inteira e o tipo de elemento tiver um tamanho constante conhecido, o tipo de matriz não será um tipo de matriz de comprimento variável; caso contrário, o tipo de matriz é um tipo de matriz de comprimento variável.

Atualizar

Em C11, a resposta muda para o caso VLA; em certos casos, não é especificado se a expressão de tamanho é avaliada ou não. Na seção 6.7.6.2 Declaradores de matriz, que diz:

[...] Quando uma expressão de tamanho faz parte do operando de um operador sizeof e a alteração do valor da expressão de tamanho não afetaria o resultado do operador, não é especificado se a expressão de tamanho é avaliada ou não.

Por exemplo, em um caso como este ( veja ao vivo ):

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

Como o operando do sizeofoperador não é avaliado, você pode fazer isso:

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

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

Demonstração on-line: http://ideone.com/S8e2Y

Ou seja, você não precisa definir a função fse ela for usada sizeofapenas. Essa técnica é usada principalmente na metaprogramação de modelos C ++, pois mesmo em C ++, o operando de sizeofnão é avaliado.

Por que isso funciona? Funciona porque o sizeofoperador não opera com valor , mas com o tipo de expressão. Portanto, quando você escreve sizeof(f()), ele opera com o tipo de expressão f()e que nada mais é do que o tipo de retorno da função f. O tipo de retorno é sempre o mesmo, independentemente do valor que a função retornaria se realmente fosse executada.

No C ++, você pode até isso:

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;
}

No entanto, parece que, sizeofprimeiro, eu estou criando uma instância de A, escrevendo A()e depois chamando a função fna instância, escrevendo A().f(), mas isso não acontece.

Demonstração: http://ideone.com/egPMi

Aqui está outro tópico que explica algumas outras propriedades interessantes de sizeof:

• sizeof tendo dois argumentos

A execução não pode acontecer durante a compilação. Então ++i/ i++não vai acontecer. Também sizeof(foo())não executará a função, mas retornará o tipo correto.

sizeofé executado em tempo de compilação, mas x++só pode ser avaliado em tempo de execução. Para resolver isso, o padrão C ++ determina que o operando de sizeofnão seja avaliado. O Padrão C diz:

Se o tipo do operando [of sizeof] for um tipo de matriz de comprimento variável, o operando será avaliado; caso contrário, o operando não é avaliado e o resultado é uma constante inteira.

sizeof() O operador fornece apenas o tamanho do tipo de dados; ele não avalia os elementos internos.