Operador sizeof C/C++: ¿Por qué sizeof ('a') devuelve valores diferentes?

Question

Duplicar posible:
Size of character ('a') in C/C++

yo soy un principiante en C, y fue confundido por esto.

C: I intentaron imprimir la sizeof ('a') en C usando el modificador "% zu", y se imprime un valor 4.

C++: impresión sizeof ('a') en C++ utilizando cout, y printf (utilizando el formato anterior) ambos imprimieron un valor 1.

Creo que el valor correcto debería ser 1, ya que 'a' se tomará como una char. ¿Por qué no devuelve 4 en C? ¿El tamaño de las operaciones de ambos es diferente en ambos idiomas? Si es así, ¿cuál es la diferencia, y por qué devuelve un valor diferente? Usé los compiladores gcc en ambos casos.

Answer 1

En C, el 'a' es una constante de caracteres, que se trata como un entero, por lo que obtiene un tamaño de 4, mientras que en C++ se trata como char. Este es un duplicado de la pregunta aquí:

Size of character ('a') in C/C++

Answer 2

En un carácter literal C (constante) tiene tipo int. lo tanto, considerar el siguiente programa

#include <stdio.h> 

main(int argc, char *argv[]) 
{ 
    printf("%zu\n", sizeof('a')); 
    printf("%zu\n", sizeof('ab')); 
    printf("%zu\n", sizeof('abc')); 
    printf("%zu\n", sizeof('abcd')); 

    printf("%u\n", 'a'); 
    printf("%u\n", 'ab'); 
    printf("%u\n", 'abc'); 
    printf("%u\n", 'abcd'); 

    printf("%x\n", 'a'); 
    printf("%x\n", 'ab'); 
    printf("%x\n", 'abc'); 
    printf("%x\n", 'abcd'); 

    printf("%c\n", 'a'); 
    printf("%c\n", 'ab'); 
    printf("%c\n", 'abc'); 
    printf("%c\n", 'abcd'); 
} 

Los primeros cuatro estados consideran todos los literales como uno carácter constante y todos ellos de impresión 4 SizeF == (int), al menos en gcc (Ubuntu 4.4.3- 4ubuntu5.1) 4.4.3. Tenga en cuenta que este compilador imprime varias señales de advertencia para el programa anterior:

warning: multi-character character constant 

Básicamente, un carácter literal especifica los cuatro bytes que componen un int, de izquierda a derecha, el byte de orden superior en primer lugar. Los principales bytes que faltan se rellenan con 0. Por lo tanto, en mi máquina el segundo y tercer grupo de sentencias printf imprimir

97 
24930 
6382179 
1633837924 
61 
6162 
616263 
61626364 

En la salida hexadecimal que se ve la disposición de los cuatro caracteres en el literal (la Códigos ASCII de izquierda a derecha): la 'a' está mapeada al byte de orden superior 0x61).

Por último, el cuarto grupo impresiones:

a 
b 
c 
d 

es decir, los caracteres literales son empujadas en la pila como números enteros, pero printf sólo imprime el byte más bajo de ese int como un char.

C++ se comporta de manera similar, pero los literales de caracteres de un byte se consideran de tipo char, no int. El programa

#include <iostream> 

using namespace std; 

main(int argc, char *argv[]) 
{ 
    cout << sizeof('a') << endl; 
    cout << sizeof('ab') << endl; 
    cout << sizeof('abc') << endl; 
    cout << sizeof('abcd') << endl; 

    cout << 'a' << endl; 
    cout << 'ab' << endl; 
    cout << 'abc' << endl; 
    cout << 'abcd' << endl; 
} 

se compilará utilizando GCC y emitirá una advertencia similar.Su salida es diferente de la de C:

1 
4 
4 
4 
a 
24930 
6382179 
1633837924 

Así literales de caracteres de un byte son tratados como char, mientras que los literales multi-byte son tratados como int.

NOTA IMPORTANTE

me encontré con mis pruebas en un sistema Linux de 32 bits en el que un int tiene 4 bytes. Sería interesante ver lo que sucede en otros sistemas, p. en un sistema de 64 bits.

EDITAR

una respuesta fija (gracias por la sugerencia): caracteres literales tienen tipo int en C, que no se fundido a int.