¿Por qué sizeof (x ++) no incrementa x?

Aquí está el código compilado en dev c ++ windows:

#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 después de ejecutar la nota 1 . Sin embargo, la salida es:

4 and 5

¿Alguien puede explicar por qué xno se incrementa después de la nota 1 ?

Del estándar C99 (el énfasis es mío)

6.5.3.4/2

El operador sizeof produce el tamaño (en bytes) de su operando, que puede ser una expresión o el nombre entre paréntesis de un tipo. El tamaño se determina a partir del tipo de operando. El resultado es un entero. Si el tipo del operando es un tipo de matriz de longitud variable, se evalúa el operando; de lo contrario, el operando no se evalúa y el resultado es una constante entera.

sizeofes un operador en tiempo de compilación, por lo que en el momento de la compilación sizeofy su operando se reemplaza por el valor del resultado. El operando no se evalúa (excepto cuando es una matriz de longitud variable); solo importa el tipo de resultado.

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

Salida:

2

como shortocupa 2 bytes en mi máquina.

Cambiar el tipo de retorno de la función a double:

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

dará 8como salida.

sizeof(foo) intenta realmente descubrir el tamaño de una expresión en tiempo de compilación:

6.5.3.4:

El operador sizeof produce el tamaño (en bytes) de su operando, que puede ser una expresión o el nombre entre paréntesis de un tipo. El tamaño se determina a partir del tipo de operando. El resultado es un entero. Si el tipo del operando es un tipo de matriz de longitud variable, se evalúa el operando; de lo contrario, el operando no se evalúa y el resultado es una constante entera.

En resumen: matrices de longitud variable, ejecutar en tiempo de ejecución. (Nota: Las matrices de longitud variable son una característica específica, no matrices asignadas con malloc(3)). De lo contrario, solo se calcula el tipo de expresión, y eso en tiempo de compilación.

sizeofes un operador integrado en tiempo de compilación y no es una función. Esto se vuelve muy claro en los casos en que puede usarlo sin el paréntesis:

(sizeof x)  //this also works

Nota

Esta respuesta se fusionó a partir de un duplicado, lo que explica la fecha de retraso.

Original

A excepción de las matrices de longitud variable sizeof no evalúa sus argumentos. Podemos ver esto en el borrador de la sección estándar C99 6.5.3.4 El tamaño del párrafo 2 del operador que dice:

El operador sizeof produce el tamaño (en bytes) de su operando, que puede ser una expresión o el nombre entre paréntesis de un tipo. El tamaño se determina a partir del tipo de operando. El resultado es un entero. Si el tipo del operando es un tipo de matriz de longitud variable, se evalúa el operando; de lo contrario, el operando no se evalúa y el resultado es una constante entera.

Un comentario ( ahora eliminado ) preguntaba si algo como esto se evaluaría en tiempo de ejecución:

sizeof( char[x++]  ) ;

y de hecho lo haría, algo como esto también funcionaría ( verlos a ambos en vivo ):

sizeof( char[func()]  ) ;

ya que ambos son matrices de longitud variable. Aunque, no veo mucho uso práctico en ninguno de los dos.

Nota, las matrices de longitud variable están cubiertos en el proyecto de norma C99 sección 6.7.5.2 de matriz declaradores párrafo 4 :

[...] Si el tamaño es una expresión constante entera y el tipo de elemento tiene un tamaño constante conocido, el tipo de matriz no es un tipo de matriz de longitud variable; de lo contrario, el tipo de matriz es un tipo de matriz de longitud variable.

Actualizar

En C11, la respuesta cambia para el caso de VLA, en ciertos casos no se especifica si la expresión de tamaño se evalúa o no. De la sección 6.7.6.2 Declaradores de matriz que dice:

[...] Cuando una expresión de tamaño es parte del operando de un operador de sizeof y cambiar el valor de la expresión de tamaño no afectaría el resultado del operador, no se especifica si se evalúa o no la expresión de tamaño.

Por ejemplo, en un caso como este ( verlo en vivo ):

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

Como el operando del sizeofoperador no se evalúa, puede hacer esto:

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

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

Demostración en línea: http://ideone.com/S8e2Y

Es decir, no necesita definir la función fsi solo se usa sizeof. Esta técnica se usa principalmente en la metaprogramación de plantillas de C ++, ya que incluso en C ++, el operando de sizeofno se evalúa.

¿Por qué funciona esto? Funciona porque el sizeofoperador no opera según el valor , sino que funciona según el tipo de expresión. Entonces, cuando escribe sizeof(f()), opera sobre el tipo de expresión f(), y que no es más que el tipo de retorno de la función f. El tipo de retorno es siempre el mismo, sin importar qué valor devolvería la función si realmente se ejecuta.

En C ++, puedes incluso esto:

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

Sin embargo, parece que, en primer lugar sizeof, estoy creando una instancia de A, escribiendo A(), y luego llamando a la función fen la instancia, escribiendo A().f(), pero no sucede tal cosa.

Demostración: http://ideone.com/egPMi

Aquí hay otro tema que explica algunas otras propiedades interesantes de sizeof:

• tamaño de tomar dos argumentos

La ejecución no puede ocurrir durante la compilación. Entonces ++i/ i++no sucederá. Tampoco sizeof(foo())ejecutará la función pero devolverá el tipo correcto.

sizeofse ejecuta en tiempo de compilación, pero x++solo se puede evaluar en tiempo de ejecución. Para resolver esto, el estándar C ++ dicta que el operando de sizeofno se evalúa. El estándar C dice:

Si el tipo del operando [de sizeof] es un tipo de matriz de longitud variable, se evalúa el operando; de lo contrario, el operando no se evalúa y el resultado es una constante entera.

sizeof() El operador solo da el tamaño del tipo de datos, no evalúa los elementos internos.