đ Retour au Sommaire
En C, chaque donnĂ©e que vous manipulez doit avoir un type. Le type indique au compilateur comment interprĂ©ter les donnĂ©es en mĂ©moire et combien dâespace elles occupent. Contrairement Ă des langages comme Python ou JavaScript, C est un langage fortement typĂ© : vous devez dĂ©clarer explicitement le type de chaque variable.
Cette rigueur offre deux avantages majeurs :
Le C propose plusieurs types de base, appelés types primitifs. Voici les principaux :
int)Le type int représente un nombre entier signé (positif ou négatif).
int age = 25;
int temperature = -10;
Taille typique : 4 octets (32 bits) sur la plupart des systĂšmes modernes (Linux, Windows 64 bits)
Plage de valeurs : environ -2 147 483 648 Ă 2 147 483 647
char)Le type char stocke un caractĂšre unique ou un petit nombre entier.
char lettre = 'A';
char chiffre = '7';
Taille : 1 octet (8 bits) â câest le plus petit type en C
Plage de valeurs : -128 à 127 (signé) ou 0 à 255 (non signé)
Note : En C, les caractÚres sont en réalité des nombres entiers correspondant à leur code ASCII.
'A'vaut 65,'0'vaut 48, etc.
float)Le type float représente un nombre décimal en simple précision.
float prix = 19.99;
float pi = 3.14159;
Taille : 4 octets (32 bits)
Précision : environ 6-7 chiffres significatifs
Plage approximative : ±3.4 Ă 10Âłâž
double)Le type double offre une précision accrue pour les calculs décimaux.
double distance = 384400.5; // Distance Terre-Lune en km
double constante = 2.718281828459045;
Taille : 8 octets (64 bits)
Précision : environ 15-16 chiffres significatifs
Plage approximative : ±1.7 Ă 10Âłâ°âž
Conseil : Utilisez
doublepar défaut pour les calculs scientifiques ou financiers. Lefloatest surtout utile pour économiser de la mémoire dans les tableaux trÚs volumineux.
Le C offre plusieurs modificateurs pour ajuster la taille et la plage des entiers.
| Type | Taille typique | Plage de valeurs (signée) |
|---|---|---|
short ou short int |
2 octets | -32 768 Ă 32 767 |
int |
4 octets | -2 147 483 648 Ă 2 147 483 647 |
long ou long int |
4 ou 8 octets* | DĂ©pend du systĂšme |
long long |
8 octets | -9 223 372 036 854 775 808 Ă 9 223 372 036 854 775 807 |
*Sur Linux 64 bits, long fait 8 octets. Sur Windows 64 bits, il fait 4 octets.
Exemples :
short compteur = 100;
int population = 67000000;
long long distance_etoile = 9460730472580800LL; // 1 année-lumiÚre en mÚtres
Note : Le suffixe
LLindique un littérallong long.
long doublePour une précision encore supérieure :
long double precision_extreme = 3.141592653589793238L;
Taille : 8, 12 ou 16 octets selon lâarchitecture
PrĂ©cision : jusquâĂ 18-19 chiffres significatifs
sizeofLâopĂ©rateur sizeof renvoie la taille dâun type en octets :
#include <stdio.h>
int main(void) {
printf("Taille de char : %zu octets\n", sizeof(char));
printf("Taille de int : %zu octets\n", sizeof(int));
printf("Taille de float : %zu octets\n", sizeof(float));
printf("Taille de double : %zu octets\n", sizeof(double));
printf("Taille de long long : %zu octets\n", sizeof(long long));
return 0;
}
RĂ©sultat typique sur Ubuntu 64 bits :
Taille de char : 1 octets
Taille de int : 4 octets
Taille de float : 4 octets
Taille de double : 8 octets
Taille de long long : 8 octets
Important : Le spécificateur de format
%zuest prévu pour afficher des valeurs de typesize_t(le type de retour desizeof).
| Type | Taille (octets) | Plage typique | Usage recommandé |
|---|---|---|---|
char |
1 | -128 Ă 127 | CaractĂšres, petits entiers |
unsigned char |
1 | 0 Ă 255 | Octets bruts, pixels |
short |
2 | -32 768 à 32 767 | Entiers modérés |
unsigned short |
2 | 0 Ă 65 535 | Compteurs positifs |
int |
4 | ±2 milliards | Type entier par défaut |
unsigned int |
4 | 0 Ă 4 milliards | IDs, flags |
long |
4 ou 8* | Variable | Ăviter (portabilitĂ©) |
long long |
8 | ±9 Ă 10Âčâž | TrĂšs grands entiers |
float |
4 | ±3.4 à 10³➠| Calculs simples, graphisme |
double |
8 | ±1.7 Ă 10Âłâ°âž | Calculs scientifiques/financiers |
long double |
8-16 | Variable | PrĂ©cision extrĂȘme (rare) |
*Attention à la portabilité : préférez int32_t, int64_t (voir section suivante).
La norme C ne garantit pas des tailles fixes pour tous les types, seulement des minimums :
char : au moins 8 bitsshort : au moins 16 bitsint : au moins 16 bitslong : au moins 32 bitslong long : au moins 64 bitsEn pratique, sur les systÚmes modernes (Linux, Windows, macOS), les tailles sont standardisées comme indiqué ci-dessus. Mais pour du code portable nécessitant des tailles exactes, on utilise des types à largeur fixe.
Depuis C99, le header <stdint.h> fournit des types garantissant une taille précise :
#include <stdint.h>
int8_t petit = -100; // Exactement 8 bits (1 octet)
int16_t moyen = 30000; // Exactement 16 bits (2 octets)
int32_t grand = 2000000000; // Exactement 32 bits (4 octets)
int64_t enorme = 9000000000000000000LL; // Exactement 64 bits (8 octets)
uint8_t octet = 255; // Non signé 8 bits
uint32_t compteur = 4000000000U; // Non signé 32 bits
Avantages :
Quand les utiliser :
#include <stdio.h>
#include <stdint.h>
int main(void) {
// Types classiques
char initiale = 'J';
int age = 30;
float taille = 1.75;
double salaire = 45000.50;
// Types Ă largeur fixe
uint32_t timestamp = 1704067200; // Epoch Unix
int64_t population_mondiale = 8000000000LL;
// Affichage
printf("Initiale : %c\n", initiale);
printf("Age : %d ans\n", age);
printf("Taille : %.2f m\n", taille);
printf("Salaire : %.2f âŹ\n", salaire);
printf("Timestamp : %u\n", (unsigned)timestamp);
printf("Population : %lld personnes\n", (long long)population_mondiale);
return 0;
}
Sortie :
Initiale : J
Age : 30 ans
Taille : 1.75 m
Salaire : 45000.50 âŹ
Timestamp : 1704067200
Population : 8000000000 personnes
printf essentielsLors de lâaffichage avec printf, utilisez le bon spĂ©cificateur :
| Type | Spécificateur | Exemple |
|---|---|---|
int |
%d |
printf("%d", x); |
unsigned int |
%u |
printf("%u", x); |
long |
%ld |
printf("%ld", x); |
long long |
%lld |
printf("%lld", x); |
float / double |
%f |
printf("%.2f", x); |
char |
%c |
printf("%c", x); |
size_t |
%zu |
printf("%zu", sizeof(x)); |
Attention : Utiliser le mauvais spécificateur (ex:
%dpour unlong long) provoque un comportement indéfini.
â
Toujours déclarer le type : int nombre; et non nombre = 5;
â
sizeof est votre ami : VĂ©rifiez les tailles sur votre systĂšme
â
Préférez double à float sauf contrainte mémoire
â
Utilisez les types à largeur fixe (int32_t, uint64_t) pour la portabilité
â
Attention aux limites : Un int ne peut pas stocker 5 milliards
â Ne pas mĂ©langer les types sans conversion explicite (nous verrons ça plus tard)
Dans les prochaines sections, nous explorerons :
đŻ Maintenant que vous connaissez les types primitifs, vous pouvez commencer Ă manipuler des donnĂ©es en C ! La suite du module vous apprendra Ă les combiner et les convertir efficacement.
âïž Signed vs Unsigned