¿Por qué "sizeof (a? True: false)" da una salida de cuatro bytes?

Tengo un pequeño fragmento de código sobre el sizeofoperador con el operador ternario:

#include <stdio.h>
#include <stdbool.h>

int main()
{
    bool a = true;
    printf("%zu\n", sizeof(bool));  // Ok
    printf("%zu\n", sizeof(a));     // Ok
    printf("%zu\n", sizeof(a ? true : false)); // Why 4?
    return 0;
}

Salida ( GCC ):

1
1
4 // Why 4?

Pero aquí,

printf("%zu\n", sizeof(a ? true : false)); // Why 4?

el operador ternario devuelve booleantipo y el tamaño del booltipo es 1byte en C.

Entonces, ¿por qué sizeof(a ? true : false)da una salida de cuatro bytes?

Es porque tienes #include <stdbool.h>. Ese encabezado define macros true y falseto be 1and 0, por lo que su declaración se ve así:

printf("%zu\n", sizeof(a ? 1 : 0)); // Why 4?

sizeof(int) es 4 en su plataforma.

Aquí, booleantipo de retorno de operador ternario ,

OK, ¡hay más en eso!

En C, el resultado de esta operación ternaria es de tipo int. ^{[notas a continuación (1,2)]}

Por lo tanto, el resultado es el mismo que el de la expresión sizeof(int)en su plataforma.

Nota 1: Citando C11, capítulo §7.18,Boolean type and values <stdbool.h>

[....] Las tres macros restantes son adecuadas para su uso en #ifdirectivas de preprocesamiento. Son

true

que se expande a la constante entera 1,

false

que se expande a la constante entera 0, [....]

Nota 2: Para operador condicional, capítulo §6.5.15, ( énfasis mío )

Se evalúa el primer operando; hay un punto de secuencia entre su evaluación y la evaluación del segundo o tercer operando (el que se evalúe). El segundo operando se evalúa sólo si el primero no es igual a 0; el tercer operando se evalúa solo si el primero se compara con 0; el resultado es el valor del segundo o tercer operando (el que se evalúe), [...]

y

Si tanto el segundo como el tercer operandos tienen tipo aritmético, el tipo de resultado que estaría determinado por las conversiones aritméticas habituales, si se aplicaran a esos dos operandos, es el tipo de resultado. [....]

por lo tanto, el resultado será de tipo entero y debido al rango de valores, las constantes son precisamente de tipo int.

Dicho esto, un asesoramiento genérico, int main()debe ser mejor int main (void)para ser verdaderamente sigan los estándares.

El operador ternario es una pista falsa.

    printf("%zu\n", sizeof(true));

imprime 4 (o lo sizeof(int)que sea ​​que esté en su plataforma).

Lo siguiente supone que booles un sinónimo charo un tipo similar de tamaño 1, y intes mayor que char.

La razón por la cual sizeof(true) != sizeof(bool)y sizeof(true) == sizeof(int)es simplemente porque notrue es una expresión de tipo . Es una expresión de tipo . Es d como en .boolint#define1stdbool.h

No hay valores r de tipo boolen C en absoluto. Cada rvalor se promueve inmediatamente a int, incluso cuando se usa como argumento para sizeof. Editar: este párrafo no es cierto, argumentos a los sizeofque no debes promocionar int. Sin embargo, esto no afecta ninguna de las conclusiones.

Con respecto al tipo booleano en C

Un tipo booleano se introdujo bastante tarde en el lenguaje C, en el año 1999. Antes, C no tenía un tipo booleano, sino que se usaba intpara todas las expresiones booleanas. Por lo tanto, todos los operadores lógicos como, por ejemplo, > == !devuelven un intvalor 1o 0.

Era costumbre que las aplicaciones usaran tipos caseros como typedef enum { FALSE, TRUE } BOOL;, que también se reduce a inttipos de tamaño.

C ++ tenía un tipo booleano mucho mejor y explícito bool, que no tenía más de 1 byte. Mientras que los tipos o expresiones booleanos en C terminarían en 4 bytes en el peor de los casos. Se introdujo alguna forma de compatibilidad con C ++ en C con el estándar C99. C luego obtuvo un tipo booleano _Booly también el encabezado stdbool.h.

stdbool.hproporciona cierta compatibilidad con C ++. Este encabezado define la macro bool(la misma ortografía que la palabra clave C ++) que se expande a _Bool, un tipo que es un tipo entero pequeño, probablemente 1 byte más grande. De manera similar, el encabezado proporciona dos macros truey la falsemisma ortografía que las palabras clave de C ++, pero con compatibilidad con programas C anteriores . Por lo tanto truey falseampliar a 1y 0en C y su tipo es int. Estas macros no son en realidad del tipo booleano como lo serían las correspondientes palabras clave de C ++.

De manera similar, por motivos de compatibilidad con versiones anteriores, los operadores lógicos en C todavía devuelven an inthasta el día de hoy, aunque C hoy en día tiene un tipo booleano. Mientras que en C ++, los operadores lógicos devuelven un bool. Por tanto, una expresión como sizeof(a == b)da el tamaño de a inten C, pero el tamaño de a boolen C ++.

Respecto al operador condicional ?:

El operador condicional ?:es un operador extraño con un par de peculiaridades. Es un error común creer que equivale al 100% a if() { } else {}. No exactamente.

Hay un punto de secuencia entre la evaluación del primer y segundo o tercer operando. Se ?:garantiza que el operador solo evaluará el segundo o el tercer operando, por lo que no puede ejecutar ningún efecto secundario del operando que no se evalúe. El código como true? func1() : func2()no se ejecutará func2(). Hasta ahora tan bueno.

Sin embargo , existe una regla especial que establece que el segundo y el tercer operando deben ser promocionados y equilibrados de forma implícita entre sí con las conversiones aritméticas habituales . ( Reglas de promoción de tipo implícito ). Esto significa que el segundo o tercer operando siempre será al menos tan grande como un int.

Entonces no importa eso truey falseresulta ser de tipo inten C porque la expresión siempre daría al menos el tamaño de un intno importa.

Incluso si reescribiera la expresión , todavía devolvería el tamaño de un !sizeof(a ? (bool)true : (bool)false) int

Esto se debe a la promoción de tipos implícita a través de las conversiones aritméticas habituales.

Respuesta rápida:

• sizeof(a ? true : false)evalúa 4porque truey falsese definen en <stdbool.h>como 1y 0respectivamente, por lo que la expresión se expande a sizeof(a ? 1 : 0)cuál es una expresión entera con tipo int, que ocupa 4 bytes en su plataforma. Por la misma razón, sizeof(true)también evaluaría 4en su sistema.

Sin embargo, tenga en cuenta que:

• sizeof(a ? a : a)también evalúa a 4porque el operador ternario realiza las promociones de enteros en su segundo y tercer operandos si se trata de expresiones enteras. Lo mismo sucede, por supuesto, para sizeof(a ? true : false)y sizeof(a ? (bool)true : (bool)false), pero echando toda la expresión como boolse comporta como se esperaba: sizeof((bool)(a ? true : false)) -> 1.

• También señalan que los operadores de comparación albergar valores booleanos 1o 0, mas tenga intTipo: sizeof(a == a) -> 4.

Los únicos operadores que mantienen la naturaleza booleana de aserían:

• el operador de coma: ambos sizeof(a, a)y sizeof(true, a)evaluar a 1en tiempo de compilación.

• los operadores de asignación: ambos sizeof(a = a)y sizeof(a = true)tienen un valor de 1.

• los operadores de incremento: sizeof(a++) -> 1

Finalmente, todo lo anterior se aplica solo a C: C ++ tiene una semántica diferente con respecto al booltipo, los valores booleanos truey los falseoperadores de comparación y el operador ternario: todas estas sizeof()expresiones se evalúan 1en C ++.

Aquí hay un fragmento de lo que se incluye en la fuente.

#ifndef __cplusplus

#define bool    _Bool
#define true    1
#define false   0

#else /* __cplusplus */

Hay macros truey falsese declaran como 1 y 0 respectivamente.

sin embargo, en este caso, el tipo es el tipo de las constantes literales. Tanto 0 como 1 son constantes enteras que encajan en un int, por lo que su tipo es int.

y sizeof(int)en tu caso es 4.