Types de données en C

Définition — Type de données Un type de données définit la nature des valeurs qu'une variable peut stocker, la quantité de mémoire allouée et l'ensemble des opérations applicables. En C, chaque variable doit avoir un type déclaré explicitement — le compilateur refuse toute variable sans type.

Famille	Types	Usage principal
Entiers	`char`, `short`, `int`, `long`, `long long`	Nombres entiers, caractères ASCII
Réels	`float`, `double`, `long double`	Nombres à virgule flottante
Vide	`void`	Absence de valeur (retour de fonction, pointeur générique)

1. Types de base

a. `char` — Caractère

char Type entier le plus petit (1 octet). Stocke un code ASCII compris entre 0 et 127. Chaque caractère est représenté entre apostrophes : 'A', '0', '\n'.

char lettre  = 'A';    /* code ASCII 65  */
char chiffre = '5';    /* code ASCII 53  */
char newline = '\n';   /* code ASCII 10  */

printf("%c → %d\n", lettre, lettre);   /* A → 65 */

b. `int` — Entier

int Type entier signé, de taille 4 octets sur la plupart des architectures 32/64 bits. Plage habituelle : −2 147 483 648 à 2 147 483 647.

c. `float` et `double` — Réels

Type	Taille	Précision	Spécificateur	Exemple
`float`	4 octets	~7 chiffres significatifs	`%f`	`3.14f`
`double`	8 octets	~15 chiffres significatifs	`%lf`	`3.14159265`
`long double`	12 ou 16 octets	~18–19 chiffres significatifs	`%Lf`	`3.14159265358979L`

Astuce — Choisir entre float et double Préférer double par défaut pour les calculs numériques : la précision supplémentaire évite les erreurs d'arrondi cumulées. N'utiliser float que lorsque la mémoire est contrainte (tableaux massifs, GPU). Les littéraux réels sont de type double par défaut en C — ajouter le suffixe f pour un littéral float : 3.14f.

2. Tableau complet des types (gcc 32 bits)

Type	Taille (octets)	Plage de valeurs	Spécificateur `printf`
`signed char`	1	−128 à 127	`%c` / `%hhd`
`unsigned char`	1	0 à 255	`%c` / `%hhu`
`short int`	2	−32 768 à 32 767	`%hd`
`unsigned short int`	2	0 à 65 535	`%hu`
`int`	4	−2 147 483 648 à 2 147 483 647	`%d`
`unsigned int`	4	0 à 4 294 967 295	`%u`
`long int`	4	−2 147 483 648 à 2 147 483 647	`%ld`
`unsigned long int`	4	0 à 4 294 967 295	`%lu`
`long long int`	8	−(2⁶³) à (2⁶³)−1	`%lld`
`unsigned long long int`	8	0 à 18 446 744 073 709 551 615	`%llu`
`float`	4	±3.4 × 10⁻³⁸ à ±3.4 × 10³⁸ (~7 chiffres)	`%f`
`double`	8	±1.7 × 10⁻³⁰⁸ à ±1.7 × 10³⁰⁸ (~15 chiffres)	`%lf`
`long double`	12	±3.4 × 10⁻⁴⁹³² à ±3.4 × 10⁴⁹³² (~18 chiffres)	`%Lf`

Tailles dépendantes de l'architecture Les tailles indiquées correspondent à un compilateur gcc 32 bits. Sur un système 64 bits, certains types peuvent différer (notamment long qui fait 8 octets sous Linux 64 bits). Pour écrire du code portable avec des tailles garanties, utiliser les types de <stdint.h>:

#include <stdint.h>

int8_t   a;   /* exactement 1 octet signé   */
uint16_t b;   /* exactement 2 octets non signé */
int32_t  c;   /* exactement 4 octets signé  */
int64_t  d;   /* exactement 8 octets signé  */

3. Le type `void`

void — Absence de type void est un type incomplet signifiant l'absence de valeur. Il est utilisé dans trois contextes distincts : type de retour d'une fonction sans résultat, paramètre d'une fonction sans argument, et pointeur générique (void *).

Usage	Syntaxe	Signification
Retour de fonction	`void afficher(void)`	La fonction ne retourne rien
Paramètre vide	`int main(void)`	La fonction n'accepte aucun argument
Pointeur générique	`void *ptr`	Pointeur sans type précis (`malloc`)

Attention — On ne peut pas déclarer une variable void voidest un type incomplet — aucune variable de ce type ne peut être créée :

void x;          /* Erreur : variable de type void interdite */
void *p = NULL;  /* Correct : pointeur générique sur void    */

4. L'opérateur `sizeof`

sizeof — Taille en mémoire L'opérateur sizeof retourne la taille en octets d'un type ou d'une variable. Il est évalué à la compilation (pas à l'exécution) et retourne une valeur de type size_t (entier non signé — spécificateur %zu ou %lu).

Syntaxe C

sizeof(type)      /* taille du type          */
sizeof(variable)  /* taille de la variable   */
sizeof(expression)/* taille du résultat      */

Exemple n°1 — Tailles des types fondamentaux

#include <stdio.h>

int main(void)
{
    int    a = 2;
    double b = 3.14;
    char   c = 'A';

    /* sizeof sur types */
    printf("sizeof(char)        = %lu octet(s)\n", sizeof(char));
    printf("sizeof(short)       = %lu octet(s)\n", sizeof(short));
    printf("sizeof(int)         = %lu octet(s)\n", sizeof(int));
    printf("sizeof(long)        = %lu octet(s)\n", sizeof(long));
    printf("sizeof(long long)   = %lu octet(s)\n", sizeof(long long));
    printf("sizeof(float)       = %lu octet(s)\n", sizeof(float));
    printf("sizeof(double)      = %lu octet(s)\n", sizeof(double));
    printf("sizeof(long double) = %lu octet(s)\n", sizeof(long double));

    /* sizeof sur variables */
    printf("\nsizeof(a) = %lu octet(s)\n", sizeof(a));   /* int  → 4 */
    printf("sizeof(b) = %lu octet(s)\n", sizeof(b));     /* double → 8 */
    printf("sizeof(c) = %lu octet(s)\n", sizeof(c));     /* char → 1 */

    return 0;
}

Sortie

sizeof(char)        = 1 octet(s)
sizeof(short)       = 2 octet(s)
sizeof(int)         = 4 octet(s)
sizeof(long)        = 4 octet(s)
sizeof(long long)   = 8 octet(s)
sizeof(float)       = 4 octet(s)
sizeof(double)      = 8 octet(s)
sizeof(long double) = 12 octet(s)

sizeof(a) = 4 octet(s)
sizeof(b) = 8 octet(s)
sizeof(c) = 1 octet(s)

Exemple n°2 — Débordement de type (overflow)

#include <stdio.h>

int main(void)
{
    unsigned char uc = 255;
    printf("uc = %d\n", uc);     /* 255 */

    uc = uc + 1;                 /* 255 + 1 = 256 → débordement */
    printf("uc + 1 = %d\n", uc); /* 0  — retour à zéro (modulo 256) */

    int max = 2147483647;
    printf("max     = %d\n", max);      /*  2147483647 */
    printf("max + 1 = %d\n", max + 1);  /* -2147483648 — comportement indéfini pour int signé */

    return 0;
}

Sortie

uc = 255
uc + 1 = 0
max     = 2147483647
max + 1 = -2147483648

Danger — Débordement entier (integer overflow) Dépasser la plage d'un type produit un débordement. Pour les types non signés, le résultat est garanti modulo 2ⁿ (comportement bien défini). Pour les types signés, le débordement est un comportement indéfini en C — le compilateur peut produire n'importe quel résultat. Vérifier toujours les bornes avant une opération critique, ou utiliser un type plus grand.

Récapitulatif

Type	Taille	Usage recommandé	Spécificateur
`char`	1 octet	Caractère ASCII, petit entier	`%c`
`short`	2 octets	Entier court (mémoire contrainte)	`%hd`
`int`	4 octets	Entier courant (compteurs, indices)	`%d`
`long long`	8 octets	Grands entiers, calculs 64 bits	`%lld`
`float`	4 octets	Réel simple précision (GPU, tableaux)	`%f`
`double`	8 octets	Réel double précision (usage général)	`%lf`
`void`	—	Retour de fonction, pointeur générique	—
`sizeof`	—	Connaître la taille d'un type à la compilation	`%lu`

Précédent Mots-clés et identificateurs en C

Suivant Variables et constantes en C-C++

Types de données en C