¿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 el 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 falseser 1y 0, por lo que su declaración se ve así:

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

sizeof(int) es 4 en tu plataforma.

Aquí, booleantipo de retorno del operador ternario ,

OK, hay más que 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 la expresión sizeof(int), en su plataforma.

Nota 1: Cita 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 (lo que se evalúe). El segundo operando se evalúa solo si el primero se compara desigual a 0; el tercer operando se evalúa solo si el primero se compara igual a 0; el resultado es el valor del segundo o tercer operando (lo que se evalúe), [...]

y

Si tanto el segundo como el tercer operando tienen un tipo aritmético, el tipo de resultado que se determinaría mediante las conversiones aritméticas habituales, si se aplicaran a esos dos operandos, es el tipo del 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 consejo genérico, int main()debería ser mejor cumplir int main (void)con los estándares.

El operador ternario es un arenque rojo.

    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 de tipo boolen C en absoluto. Todos estos valores se promueven de inmediato int, incluso cuando se usan como argumento para sizeof. Editar: este párrafo no es cierto, argumentos para sizeofno ser promovido int. Sin embargo, esto no afecta a ninguna de las conclusiones.

En cuanto al tipo booleano en C

Un tipo booleano se introdujo bastante tarde en el lenguaje C, en el año 1999. Antes de eso, 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 > == !etc. devuelven un intvalor 1o 0.

Fue personalizado para las aplicaciones utilizar 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 era mayor de 1 byte. Mientras que los tipos booleanos o expresiones en C terminarían como 4 bytes en el peor de los casos. Se introdujo algún tipo 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 grande. Del mismo modo, la cabecera proporciona dos macros truey false, misma ortografía como palabras clave C ++, pero con compatibilidad con versiones anteriores de los programas en C de más edad . 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 palabras clave correspondientes de C ++.

Del mismo modo, para fines de compatibilidad con versiones anteriores, los operadores lógicos en C aún devuelven un inthasta el día de hoy, a pesar de que C actualmente tiene un tipo booleano. Mientras que en C ++, los operadores lógicos devuelven a bool. Por lo tanto, una expresión tal como sizeof(a == b)dará el tamaño de an inten C, pero el tamaño de a boolen C ++.

Sobre el operador condicional ?:

El operador condicional ?:es un operador extraño con un par de peculiaridades. Es un error común creer que es 100% equivalente 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. Código como true? func1() : func2()no se ejecutará func2(). Hasta aquí todo bien.

Sin embargo , hay una regla especial que establece que los operandos segundo y tercero deben obtener implícitamente el tipo promocionado y equilibrado entre sí con las conversiones aritméticas habituales . ( Las reglas de promoción de tipo implícito en C se explican aquí ). Esto significa que el segundo o tercer operando siempre será al menos tan grande como un int.

Por lo tanto, no importa eso truey falseresulta ser de tipo intC porque la expresión siempre daría al menos el tamaño de un intno importa.

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

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

Respuesta rápida:

• sizeof(a ? true : false)se evalúa como 4porque truey falsese definen <stdbool.h>como 1y 0respectivamente, por lo que la expresión se expande a sizeof(a ? 1 : 0)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 4porque el operador ternario realiza las promociones enteras en su segundo y tercer operandos si son 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 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 del cual es 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 caben en un int, por lo que su tipo es int.

y el sizeof(int)en tu caso es 4.

No hay ningún tipo de datos booleanos en C, en su lugar, las expresiones lógicas se evalúan a valores enteros 1cuando es verdadero de lo contrario 0.

Las expresiones condicionales como if, for, while, o c ? a : besperar un entero, si el número no es cero se considera truea excepción de algunos casos especiales, he aquí una función suma recursiva en la que el operador ternario-evaluará truehasta que nalcance 0.

int sum (int n) { return n ? n+sum(n-1) : n ;

También se puede usar para NULLverificar un puntero, aquí hay una función recursiva que imprime el contenido de una Lista enlazada individualmente.

void print(sll * n){ printf("%d -> ",n->val); if(n->next)print(n->next); }