Comportement confus de sizeof avec les caractères

Question

#include <stdio.h>
#include <string.h>

int main(void)
{
    char ch='a';

    printf("sizeof(ch)          = %d\n", sizeof(ch));
    printf("sizeof('a')         = %d\n", sizeof('a'));
    printf("sizeof('a'+'b'+'C') = %d\n", sizeof('a'+'b'+'C'));
    printf("sizeof(\"a\")       = %d\n", sizeof("a"));
}

Ce programme utilise sizeof pour calculer les tailles. Pourquoi la taille de 'a' différente de la taille de ch (où ch='a' ) ?

sizeof(ch)          = 1
sizeof('a')         = 4
sizeof('a'+'b'+'C') = 4
sizeof("a")         = 2

Answer 1

TL;DR - sizeof travaille sur le type de l'opérande.

• sizeof(ch) == sizeof (char) -------------------(1)
• sizeof('a') == sizeof(int) --------------------(2)
• sizeof ('a'+ 'b' + 'c') == sizeof(int) ---(3)
• sizeof ("a") == sizeof (char [2]) ----------(4)

Voyons maintenant chaque cas.

1. ch est défini comme étant de char donc, c'est assez simple.

2. En C, sizeof('a') est la même chose que sizeof (int) comme une constante de caractère de type entier.

   Citation : C11 ,

   Une constante de caractère entier a le type int . [...]

   En C++, un caractère littéral a un type char .

3. sizeof est un opérateur de compilation (sauf lorsque l'opérande est un VLA), donc le type de l'expression est utilisé. Comme précédemment, toutes les constantes de caractères entiers sont de type int donc int + int + int produit int . Ainsi, le type de l'opérande est pris comme suit int .

4. "a" est un tableau de deux char s, 'a' y 0 (terminateur nul) ( non, il ne se désintéresse pas du pointeur vers le premier élément du type tableau ), donc la taille est la même que celle d'un tableau avec deux char éléments.

---

Cela dit, enfin, sizeof produit un résultat de type size_t vous devez donc utiliser %zu spécificateur de format pour imprimer le résultat.

Answer 2

En C, 'a' es constant de type int . Il est no a char . Donc sizeof('a') sera le même que sizeof(int) .

sizeof(ch) est la même chose que sizeof(char) . (La norme C garantit que toutes les constantes alphanumériques - et quelques autres - de la forme 'a' peut tenir dans un char donc char ch='a'; est toujours bien défini).

Notez qu'en C++, 'a' est un littéral de type char ; encore une autre différence entre C et C++.

En C, sizeof("a") es sizeof(char[2]) qui est de 2. sizeof n'est pas à l'origine de la décroissance d'un type de tableau à un pointeur.

En C++, sizeof("a") es sizeof(const char[2]) qui est de 2. sizeof n'est pas à l'origine de la décroissance d'un type de tableau à un pointeur.

Dans les deux langues, 'a'+'b'+'C' est un int en raison, en C++, de la promotion implicite des types intégraux.

Answer 3

Tout d'abord, le résultat de sizeof est le type size_t qui doit être imprimée avec le %zu spécificateur de format. En ignorant cette partie et en supposant int est de 4 octets, alors

• printf("sizeof(ch) %d\n",sizeof(ch)); imprimera 1 en C et 1 en C++.

  En effet, un char est par définition garantie à 1 octet dans les deux langues.

• printf("sizeof('a') %d\n",sizeof('a')); imprimera 4 en C et 1 en C++.

  C'est parce que les littéraux de caractères sont de type int en C, pour des raisons historiques 1) mais ils sont de type char en C++, car c'est ce que le bon sens (et la norme ISO 14882) impose.

• printf("sizeof('a'+'b'+'C) %d\n",sizeof('a'+'b'+'C')); imprimera 4 dans les deux langues.

  En C, le type résultant de int + int + int est naturellement int . En C++, on a char + char + char . Mais le + invoque règles implicites de promotion de type donc on se retrouve avec int à la fin, peu importe.

• printf("sizeof(\"a\") %d\n",sizeof("a")); imprimera 2 dans les deux langues.

  La chaîne littérale "a" est de type char[] en C et const char[] en C++. Dans les deux cas, nous disposons d'un tableau composé de a et un terminateur nul : deux caractères.

  À titre d'information, cela se produit parce que le tableau "a" ne se décompose pas en un pointeur vers le premier élément lorsque l'opérande à sizeof . Devrions-nous provoquer une désintégration du tableau en écrivant par exemple sizeof("a"+0) alors nous obtiendrions la taille d'un pointeur à la place (probablement 4 ou 8).

---

1) Quelque part dans les âges sombres, il n'y avait pas de types et tout ce que vous écriviez se résumait à int aucune importance. Puis, lorsque Dennis Ritchie a commencé à préparer une sorte de norme de facto pour le C, il a apparemment décidé que les littéraux de caractères devaient toujours être promu a int . Et plus tard, quand C a été standardisé, ils ont dit que les littéraux de caractères sont simplement int .

Lors de la création du C++, Bjarne Stroustrup a reconnu que tout cela n'avait pas beaucoup de sens et a fait des littéraux des caractères de type char comme ils devraient l'être. Mais le comité C refuse obstinément de corriger ce défaut de langage.

Answer 4

Comme d'autres l'ont mentionné, la norme du langage C définit le type d'une constante de caractère comme étant int . La raison historique est que C, et son prédécesseur B, ont été développés à l'origine sur des mini-ordinateurs DEC PDP avec différentes tailles de mots, qui supportaient l'ASCII 8 bits mais ne pouvaient effectuer des opérations arithmétiques que sur des registres. Les premières versions de C définissaient int pour être la taille de mot native de la machine, et toute valeur inférieure à un int devait être élargi à int afin d'être transmis à une fonction ou à partir d'une fonction, ou utilisé dans une expression logique, arithmétique ou par bit, car c'est ainsi que le matériel sous-jacent fonctionne.

C'est également la raison pour laquelle les règles de promotion des entiers stipulent toujours que tout type de données plus petit qu'un int est promu à int . Les implémentations C sont également autorisées à utiliser les mathématiques à complément à un au lieu de celles à complément à deux pour des raisons historiques similaires, et le fait que les échappements de caractères sont par défaut en octal et que les constantes octales commencent par juste 0 et les besoins hexagonaux \x o 0x est que les premiers mini-ordinateurs DEC avaient des tailles de mots divisibles en morceaux de trois octets, mais pas en morceaux de quatre octets.

Promotion automatique vers int ne cause que des problèmes aujourd'hui. (Combien de programmeurs sont conscients que multiplier deux uint32_t ensemble est un comportement non défini, parce que certaines implémentations définissent int de 64 bits de large, le langage exige que tout type de rang inférieur à int doit être promu à un signé int le résultat de la multiplication de deux int multiplicandes a le type int la multiplication peut déborder un produit signé de 64 bits, ce qui constitue un comportement indéfini). Mais c'est la raison pour laquelle C et C++ sont coincés avec cela.

Answer 5

Je suppose que le code a été compilé en C.
En C, 'a' est traité comme un int et int a une taille de 4. En C++, 'a' est traité comme un char et si vous essayez de compiler votre code dans cpp.sh, il devrait retourner 1.