Comprendre les types de données en C : Guide complet

Les types de données en C définissent un système complet pour déclarer variables ou fonctions de différents types. Le type d'une variable détermine l'espace mémoire occupé et l'interprétation du motif binaire stocké.

Les types en C se classent ainsi :

N°	Types et description
1	Types de base : arithmétiques, subdivisés en (a) types entiers et (b) types à virgule flottante.
2	Types énumérés : arithmétiques, pour variables ne prenant que certaines valeurs entières discrètes.
3	Type void : indique l'absence de valeur.
4	Types dérivés : (a) Pointeurs, (b) Tableaux, (c) Structures, (d) Unions, (e) Fonctions.

Les types tableau et structure sont collectivement appelés types agrégés. Le type d'une fonction spécifie son type de retour. Nous détaillons les types de base ci-dessous.

Types entiers

Le tableau suivant donne les tailles de stockage et plages de valeurs des types entiers standards :

Type	Taille	Plage de valeurs
char	1 octet	-128 à 127 ou 0 à 255
unsigned char	1 octet	0 à 255
signed char	1 octet	-128 à 127
int	2 ou 4 octets	-32 768 à 32 767 ou -2 147 483 648 à 2 147 483 647
unsigned int	2 ou 4 octets	0 à 65 535 ou 0 à 4 294 967 295
short	2 octets	-32 768 à 32 767
unsigned short	2 octets	0 à 65 535
long	8 octets (4 sur OS 32 bits)	-9 223 372 036 854 775 808 à 9 223 372 036 854 775 807
unsigned long	8 octets	0 à 18 446 744 073 709 551 615

Pour obtenir la taille exacte sur une plateforme, utilisez l'opérateur sizeof : sizeof(type) renvoie la taille en octets. Exemple avec les constantes de limits.h et float.h :

#include <stdio.h>
#include <stdlib.h>
#include <limits.h>
#include <float.h>

int main() {
    printf("CHAR_BIT  : %d\n", CHAR_BIT);
    printf("CHAR_MAX  : %d\n", CHAR_MAX);
    printf("CHAR_MIN  : %d\n", CHAR_MIN);
    printf("INT_MAX   : %d\n", INT_MAX);
    printf("INT_MIN   : %d\n", INT_MIN);
    printf("LONG_MAX  : %ld\n", (long) LONG_MAX);
    printf("LONG_MIN  : %ld\n", (long) LONG_MIN);
    printf("SCHAR_MAX : %d\n", SCHAR_MAX);
    printf("SCHAR_MIN : %d\n", SCHAR_MIN);
    printf("SHRT_MAX  : %d\n", SHRT_MAX);
    printf("SHRT_MIN  : %d\n", SHRT_MIN);
    printf("UCHAR_MAX : %d\n", UCHAR_MAX);
    printf("UINT_MAX  : %u\n", (unsigned int) UINT_MAX);
    printf("ULONG_MAX : %lu\n", (unsigned long) ULONG_MAX);
    printf("USHRT_MAX : %d\n", (unsigned short) USHRT_MAX);
    return 0;
}

Résultat typique sur Linux 64 bits :

CHAR_BIT  : 8
CHAR_MAX  : 127
CHAR_MIN  : -128
INT_MAX   : 2147483647
INT_MIN   : -2147483648
LONG_MAX  : 9223372036854775807
LONG_MIN  : -9223372036854775808
SCHAR_MAX : 127
SCHAR_MIN : -128
SHRT_MAX  : 32767
SHRT_MIN  : -32768
UCHAR_MAX : 255
UINT_MAX  : 4294967295
ULONG_MAX : 18446744073709551615
USHRT_MAX : 65535

Types à virgule flottante

Type	Taille	Plage de valeurs	Précision
float	4 octets	1.2E-38 à 3.4E+38	6 décimales
double	8 octets	2.3E-308 à 1.7E+308	15 décimales
long double	10 octets	3.4E-4932 à 1.1E+4932	19 décimales

float.h définit des macros pour ces valeurs. Exemple affichant la taille et la plage de float :

#include <stdio.h>
#include <float.h>

int main() {
    printf("Taille de float : %zu octets\n", sizeof(float));
    printf("FLT_MAX : %g\n", FLT_MAX);
    printf("FLT_MIN : %g\n", FLT_MIN);
    printf("Précision (FLT_DIG) : %d\n", FLT_DIG);
    return 0;
}

Résultat typique :

Taille de float : 4 octets
FLT_MAX : 3.40282e+38
FLT_MIN : 1.17549e-38
Précision (FLT_DIG) : 6

Le type void

Indique qu'aucune valeur n'est disponible. Trois cas d'usage :

N°	Cas et description
1	Fonction retournant void : ne retourne rien. Ex: void exit(int status);
2	Fonction sans paramètre : utilise void. Ex: int rand(void);
3	Pointeurs vers void : void * représente une adresse sans type. Ex: void *malloc(size_t size); retourne un pointeur convertible vers n'importe quel type.