Types de donnée du langage C

Les types de donnée du langage C définissent les caractéristiques de stockage et les opérations disponibles pour chaque valeur et chaque variable d'un code source en langage C. Les types fondamentaux du langage C sont conçus pour pouvoir correspondre aux types supportés par l'architecture de processeur cible. Le langage C possède une vingtaine de types fondamentaux pour représenter des nombres naturels, entiers et réels. Le langage offre une syntaxe pour construire des types d'adresse mémoire (pointeurs) vectoriels (tableaux) et composés (structures). En outre, la bibliothèque standard du C fournit des types supplémentaires qui permettent de s'abstraire des types liés aux caractéristiques techniques de l'ordinateur cible.

Types standards

Types principaux

Le langage C fournit quatre spécificateurs arithmétiques de base char, int, float et double ainsi que leurs versions modifiés signed, unsigned, short et long. Le tableau suivant liste les combinaisons et la plage de valeurs permises pour chaque déclaration[1].

Type	Explication courte
`char`	Plus petite unité adressable d'une machine, elle peut contenir les caractères de base. C'est une valeur entière qui peut être signée ou non.
`signed char`	Type char signé, capable de représenter au moins les nombres [−127 ; +127].
`unsigned char`	Type char non-signé, capable de représenter au moins les nombres [0 ; 255].
`short` `short int` `signed short` `signed short int`	Type entier minimum, court, entier et signé, capable de représenter au moins les nombres [−32 767 ; +32 767].
`unsigned short` `unsigned short int`	Type entier minimum, court, idem que le type entier standard non signé.
`int` `signed` `signed int`	Type entier standard, signé, capable de représenter au moins les nombres [−32 767 ; +32 767].
`unsigned` `unsigned int`	Idem que le type entier standard, mais non signé, capable de représenter au moins les nombres [0 ; 65 535].
`long` `long int` `signed long` `signed long int`	Type entier long, entier et signé, capable de représenter au moins les nombres [−2 147 483 647 ; +2 147 483 647].
`unsigned long` `unsigned long int`	Idem type entier long mais non signé, capable de représenter au moins les nombres [0 ; 4 294 967 295].
`long long` `long long int` `signed long long` `signed long long int`	Type entier long long, entier et signé, capable de représenter au moins les nombres [−9 223 372 036 854 775 807 ; +9 223 372 036 854 775 807].
`unsigned long long` `unsigned long long int`	Idem type entier long long mais non signé, capable de représenter au moins les nombres [0 ; +18 446 744 073 709 551 615].
`float`	Type flottant. Simple précision (4 octets, ou 32 bits) sur quasiment tous les systèmes.
`double`	Type flottant. Double précision (8 octets, ou 64 bits) sur quasiment tous les systèmes.
`long double`	Type flottant. En pratique, selon le système, de la double précision à la quadruple précision.

Type booléen

C99 (anglais) a ajouté le type booléen _Bool (vrai / faux). De plus, l'en-tête <stdbool.h> définit bool comme un alias pratique pour ce type et fournit également des macros pour true et false . _Bool fonctionne de manière similaire à un type entier normal, à une exception près : toutes les affectations à _Bool qui ne sont pas 0 (faux) sont stockées comme 1 (vrai). Ce comportement existe pour éviter les dépassements d'entier dans les conversions de rétrécissement implicites. Par exemple, dans le code suivant :

unsigned char b = 256;
if (b) {
	/* faire quelque chose */
}

La variable b contient false (faux, ou 0) si le caractère unsigned char a une taille de 8 bits. Cela est dû au fait que la valeur 256 ne correspond pas au type de données, ce qui entraîne l'utilisation des 8 bits inférieurs, donc la valeur est nulle. Cependant, la modification du type fait que le code précédent se comporte normalement :

_Bool b = 256;
if (b) {
	/* faire quelque chose */
}

Le type _Bool garantit aussi que les vraies valeurs soient toujours comparables les unes aux autres :

_Bool a = 1, b = 2;
if (a == b) {
	/* faire quelque chose */
}

Mesure de la taille

La taille de chaque type dépend du matériel informatique : ainsi, le type int mesure souvent 4 octets, mais peut mesurer 2 octet sur certains modèles, et 8 sur d'autres. L'opérateur sizeof donne la taille d'un type par rapport au type char qui a par définition une taille de 1 :

printf("taille de int : %zu", sizeof(int));

ce qui renvoie par exemple :

taille de int : 4

Généralités

Le langage C a un typage statique : toute variable doit être déclarée avec un type, qui ne peut pas être changé ensuite ; toute constante a un type ; la norme du langage définit pour chaque opérateur quels sont les types admissibles des opérandes, et comment déduire le type du résultat.

Histoire

Dans sa description des origines du langage C, Dennis Ritchie explique que C a été créé pour supporter différents types de donnée[2]. Les ancêtres du langage C, le langage B, et avant BCPL, n'avaient pas de types de données ; ils opéraient sur des mots machine.

Le langage B était conçu pour fonctionner sur un mini-ordinateur PDP-7 qui avait des mots de 18 bits. Ce n'est que l'ordinateur suivant pour lequel le langage B a été conçu, le PDP-11, qui a été capable d'adresser des octets en mémoire. En outre, le fabricant annonçait le futur support de nombres à virgule flottante. Afin de supporter efficacement le traitement des caractères et des nombres flottants, le langage B a été profondément remanié, ce qui a donné le langage C.

Catégories de type de donnée

Type	Catégories
`_Bool`	booléen	entier	arithmétique	scalaire
`enum`	énuméré
`char`	caractère
`signed char`, `short`, `int`, `long`, `long long`	entier signé
`unsigned char`, `unsigned short`, `unsigned int`, `unsigned long`, `unsigned long long`	entier non signé
`float`, `double`, `long double`	virgule flottante
`float _Complex`, `double _Complex`, `long double _Complex`, `float _Imaginary`, `double _Imaginary`, `long double _Imaginary`	virgule flottante
`T*`	pointeur
`T[]`	tableau			aggrégé
`struct T`	structure			aggrégé
`union T`	union
`void`	vide

Les noms des types _Bool, _Complex et _Imaginary commencent par un caractère de soulignement et une majuscule car ils n'ont été normalisés qu'en 1999, et des noms plus naturels auraient pu être incompatibles avec le code existant. Les synonymes bool, complex et imaginary sont définis dans les en-têtes standard <stdbool.h> et <complex.h>.

Le type char peut être signé ou non, selon l'implémentation. Dans tous les cas, il est distinct des types signed char et unsigned char.

Les types entiers peuvent être de différentes tailles. La norme garantit que :
1 = sizeof(char) ≤ sizeof(short) ≤ sizeof(int) ≤ sizeof(long) ≤ sizeof(long long).

Les types short, long et long long, signés ou non, peuvent optionnellement contenir le mot int dans leur nom. Par exemple short int, int long long, etc.

Les types short, int, long et long long peuvent optionnellement contenir le mot signed dans leur nom. Par exemple signed int.

La norme garantit que la précision du type float est inférieure ou égale à celle du type double, qui est inférieure ou égale à celle du type long double.

Toute valeur scalaire utilisée dans un contexte booléen est considérée comme fausse si sa valeur est nulle, et vraie autrement.

Conversions usuelles de type

Le langage C est faiblement typé dans le sens où il existe de nombreuses conversions automatiques de type.

Promotion des entiers

Le type int est le type entier par défaut du langage. C'est le type des constantes littérales comme 123 et 'a', ainsi que des constantes de listes énumérées.

La plupart des opérateurs du langage impliquent une conversion préalable de leurs opérandes vers un type commun, qui a au moins la précision d'un int. Même si deux opérandes sont de même type de précision inférieure à int, comme short, il y a une conversion en int avant l'opération. Ainsi dans :

short a, b, c;
c = a + b;

les valeurs de a et b sont converties en int avant d'être additionnées. Le résultat, aussi de type int, est ensuite affecté à la variable c de type short, ce qui peut potentiellement tronquer le résultat.

Notes et références

« « Sizes of integer types », ISO-IEC 9899, 5.2.4.2.1. », p. 454
(en) Thomas J. Bergin Jr et Richard G. Gibson Jr, History of Programming Languages - II, ACM Press, 1996 (ISBN 0-201-89502-1, présentation en ligne), chap. XIV (« C Session »)

Cet article est issu de wikipedia. Text licence: CC BY-SA 4.0, Des conditions supplémentaires peuvent s’appliquer aux fichiers multimédias.