En programmation, une variable est un emplacement de la mémoire vive (RAM) auquel on donne un nom symbolique (identificateur) pour y stocker, lire et modifier des données pendant l'exécution d'un programme.
Le langage C est un langage à typage statique et fort : chaque variable doit impérativement être déclarée avec son type avant de pouvoir être utilisée. Le type renseigne le compilateur sur le nombre d'octets à réserver en mémoire et sur la manière d'interpréter les bits qui y sont stockés.
1. Les types de données primitifs en C#
Le standard ANSI C fournit plusieurs familles de types élémentaires adaptés aux nombres entiers, aux nombres réels et aux caractères :
graph TD
Types[Types de Données Primitifs en C]
Types --> Entiers[Entiers]
Types --> Flottants[Nombres à Virgule]
Types --> Booleens[Booléens C99]
Entiers --> char["char (1 octet)\n-128 à 127 ou 'A'"]
Entiers --> short["short int (2 octets)\n-32 768 à 32 767"]
Entiers --> int["int (4 octets)\n-2 147 483 648 à +2 147 483 647"]
Entiers --> long["long long (8 octets)\nGrands entiers"]
Flottants --> float["float (4 octets)\nPrécision simple (~7 décimales)"]
Flottants --> double["double (8 octets)\nPrécision double (~15 décimales)"]
Booleens --> bool["bool (1 octet)\ntrue (1) ou false (0) via stdbool.h"]
Récapitulatif technique et tailles mémoires#
| Type C | Taille typique | Plage de valeurs approximative | Spécificateur printf |
|---|---|---|---|
char |
1 octet (8 bits) | -128 à 127 (ou code ASCII 'A'-'Z') | %c |
unsigned char |
1 octet | 0 à 255 | %u |
short |
2 octets (16 bits) | -32 768 à 32 767 | %hd |
int |
4 octets (32 bits) | -2,14 milliards à +2,14 milliards | %d |
unsigned int |
4 octets | 0 à 4,29 milliards | %u |
long long |
8 octets (64 bits) | \(\approx \pm 9 \times 10^{18}\) | %lld |
float |
4 octets | \(\pm 3.4 \times 10^{38}\) | %f |
double |
8 octets | \(\pm 1.7 \times 10^{308}\) | %lf |
bool |
1 octet | true (1) ou false (0) |
%d |
2. Connaître la taille réelle avec sizeof#
La taille exacte des types peut varier selon l'architecture du processeur (32 bits ou 64 bits). L'opérateur sizeof permet d'interroger la mémoire de la machine :
#include <stdio.h>
#include <stdbool.h>
int main(void)
{
printf("Taille de char : %zu octet(s)\n", sizeof(char));
printf("Taille de int : %zu octet(s)\n", sizeof(int));
printf("Taille de float : %zu octet(s)\n", sizeof(float));
printf("Taille de double : %zu octet(s)\n", sizeof(double));
printf("Taille de bool : %zu octet(s)\n", sizeof(bool));
return 0;
}
3. Déclaration, Initialisation et Valeurs Déchets#
Une variable déclarée sans valeur initiale contient ce qu'on appelle une valeur déchet (garbage value) : c'est-à-dire l'état résiduel aléatoire des bits qui se trouvaient dans la case mémoire avant son affectation.
// 1. Déclaration seule (DANGER : contenu imprévisible !)
int quantite;
// 2. Déclaration avec initialisation (BONNE PRATIQUE)
int stock = 0;
float taux_tva = 0.20f;
char statut = 'A';
[!WARNING] Prendre l'habitude d'initialiser systématiquement vos variables à zéro ou à une valeur neutre dès leur déclaration élimine 80 % des comportements erratiques en C.
4. Règles de nommage des identificateurs#
Pour nommer vos variables, respectez les conventions du standard C :
- Seuls les caractères alphanumériques (a-z, A-Z, 0-9) et le tiret bas _ sont autorisés.
- Le premier caractère ne peut jamais être un chiffre (2notes est interdit, note_2 est valide).
- Le C est sensible à la casse : Total, total et TOTAL désignent trois variables distinctes.
- Les mots-clés du langage (int, return, for, if, while, struct) sont strictement réservés.
5. Les constantes : #define vs const#
Une constante est une valeur fixée dès la conception du programme, dont la modification ultérieure est formellement interdite par le compilateur.
Méthode 1 : La macro du préprocesseur (#define)#
Le mot-clé #define demande au préprocesseur de remplacer textuellement toutes les occurrences d'un mot par sa valeur avant la compilation :
Méthode 2 : Le qualificateur const (Recommandé)#
Le mot-clé const crée une véritable variable typée que le compilateur protège en lecture seule :
const double PI = 3.141592653589793;
const int NB_MOIS_ANNEE = 12;
// L'instruction suivante provoquera une erreur de compilation immédiate :
// PI = 3.0; // ERREUR : assignment of read-only variable 'PI'
| Critère | #define (Macro) |
const (Variable qualifiée) |
|---|---|---|
| Traitement | Par le préprocesseur (remplacement textuel). | Par le compilateur (respect du système de types). |
| Portée (Scope) | Globale à tout le fichier source. | Délimitée au bloc { ... } où elle est déclarée. |
| Débogage | Invisible dans le débogueur GDB. | Visible avec nom et type dans le débogueur. |
| Convention | TOUT_EN_MAJUSCULES | TOUT_EN_MAJUSCULES ou CamelCase |
6. Mise en pratique : Calcul géométrique#
Énoncé :
Déclarez une constante PI et une variable rayon (nombre réel saisi au clavier). Calculez et affichez le périmètre (\(2 \times \pi \times r\)) et l'aire (\(\pi \times r^2\)) d'un cercle avec 3 décimales.
??? tip "Solution complète"
#include <stdio.h>
int main(void)
{
const double PI = 3.141592653589793;
double rayon = 0.0;
printf("Entrez le rayon du cercle (en cm) : ");
if (scanf("%lf", &rayon) == 1 && rayon >= 0.0)
{
double perimetre = 2.0 * PI * rayon;
double aire = PI * rayon * rayon;
printf("\n--- RESULTATS GEOMETRIQUES ---\n");
printf("Rayon : %.3lf cm\n", rayon);
printf("Perimetre : %.3lf cm\n", perimetre);
printf("Aire : %.3lf cm²\n", aire);
}
else
{
printf("Erreur : Valeur de rayon invalide.\n");
}
return 0;
}
Vous maîtrisez les variables et types fondamentaux. Voyons à présent comment combiner ces variables avec les opérateurs arithmétiques, relationnels et logiques.
Commentaires