đ Retour au Sommaire
Le langage C existe depuis plus de 50 ans, mais il nâest pas restĂ© figĂ©. Au fil des dĂ©cennies, il a Ă©voluĂ© Ă travers diffĂ©rentes normes (ou standards) qui dĂ©finissent prĂ©cisĂ©ment ce qui constitue le langage C et comment il doit se comporter.
Comprendre ces différentes versions est essentiel pour :
Dans cette section, nous allons explorer lâĂ©volution du C Ă travers ses normes principales, de la premiĂšre standardisation en 1989 jusquâĂ la toute rĂ©cente norme C23.
đĄ Rassurez-vous : Vous nâavez pas besoin de connaĂźtre tous les dĂ©tails de chaque version. Lâimportant est de comprendre les diffĂ©rences majeures et de savoir quelle version utiliser.
Une norme du langage C est un document officiel publiĂ© par lâISO (International Organization for Standardization) qui dĂ©finit :
Sans norme, chaque compilateur pourrait interpréter le C différemment :
// Ce code pourrait faire des choses différentes selon le compilateur !
int x = 5 / 2; // 2 ou 2.5 ? Arrondi ou troncature ?
Avec une norme, tous les compilateurs conformes produisent le mĂȘme rĂ©sultat :
int x = 5 / 2; // Toujours 2 (division entiÚre définie par la norme)
1972 âââââââââââââââââââââââââââââââââââââââââââââââââââââââ 2025
â â
â C crĂ©Ă© (K&R C)
â
ââââ 1978: "The C Programming Language" (Kernighan & Ritchie)
â
ââââ 1989: ANSI C (C89) âââ PremiĂšre standardisation
â
ââââ 1990: ISO C (C90) âââ Version internationale
â
ââââ 1999: C99 âââ Ăvolution majeure
â
ââââ 2011: C11 âââ Threads & atomiques
â
ââââ 2017: C17 âââ Corrections
â
ââââ 2023: C23 âââ Moderne
| Année | Nom officiel | Nom courant | Type | Importance |
|---|---|---|---|---|
| 1978 | - | K&R C | Livre | đĄ Historique |
| 1989 | ANSI X3.159-1989 | C89 | Norme ANSI | đą Legacy |
| 1990 | ISO/IEC 9899:1990 | C90 | Norme ISO | đą Legacy |
| 1999 | ISO/IEC 9899:1999 | C99 | RĂ©vision majeure | đ” Largement utilisĂ© |
| 2011 | ISO/IEC 9899:2011 | C11 | RĂ©vision majeure | đŁ Standard actuel â |
| 2017 | ISO/IEC 9899:2018 | C17 (ou C18) | Corrections | đŁ Standard actuel â |
| 2024 | ISO/IEC 9899:2024 | C23 | RĂ©vision majeure | đ Nouvelle norme |
đŻ Ă retenir : En 2025, C11/C17 est la version la plus utilisĂ©e en production, bien que C23 soit dĂ©sormais disponible.
Contexte : Dennis Ritchie crĂ©e le C pour Ă©crire UNIX. Le langage est dĂ©crit dans le livre « The C Programming Language » de Kernighan et Ritchie (dâoĂč « K&R C »).
Caractéristiques :
Exemple K&R C (syntaxe ancienne) :
/* DĂ©claration de fonction Ă l'ancienne */
int add(a, b)
int a, b; /* Types déclarés séparément */
{
return a + b;
}
Ătat en 2025 : ObsolĂšte, mais vous pouvez encore trouver du vieux code Ă©crit ainsi.
Contexte : Le C devient populaire. Pour Ă©viter la fragmentation, lâANSI (American National Standards Institute) crĂ©e le premier standard officiel en 1989, adoptĂ© par lâISO en 1990.
Innovation majeure : Normalisation du langage et de la bibliothĂšque standard.
Nouveautés principales :
const, volatile<stdio.h>, <stdlib.h>, <string.h>, etc.#define, #include, #ifdefvoid, enum, structuresExemple C89 (syntaxe moderne) :
#include <stdio.h>
/* Prototype avec types vérifiés */
int add(int a, int b);
int add(int a, int b) {
return a + b;
}
int main(void) {
printf("5 + 3 = %d\n", add(5, 3));
return 0;
}
Ătat en 2025 : Encore utilisĂ© dans certains systĂšmes embarquĂ©s ultra-contraints et code legacy trĂšs ancien.
Contexte : 10 ans aprÚs C89, le C évolue pour rester compétitif face à C++ et Java. C99 apporte de nombreuses améliorations.
Nouveautés majeures :
#include <stdint.h>
#include <stdbool.h>
int64_t big_number; // Entier 64 bits garanti
bool is_valid = true; // Type booléen natif
// Variables dĂ©clarĂ©es n'importe oĂč (pas seulement en dĂ©but de bloc)
int x = 10;
printf("%d\n", x);
int y = 20; // OK en C99 !
for (int i = 0; i < 10; i++) { // i déclaré dans le for
printf("%d ", i);
}
int n = 10;
int array[n]; // Taille définie à l'exécution !
// Commentaires sur une ligne (comme en C++)
int x = 5; // Au lieu de /* ... */
struct Point {
int x, y, z;
};
struct Point p = {.x = 10, .z = 30}; // y est implicitement 0
#include <complex.h>
double complex z = 1.0 + 2.0*I;
static inline int max(int a, int b) {
return a > b ? a : b;
}
Note : En C99/C11, une fonction
inlinesansstaticne fournit pas de définition externe. En pratique, utilisez toujoursstatic inlinepour éviter les erreurs de linkage.
Ătat en 2025 : TrĂšs largement utilisĂ©, excellent choix pour la compatibilitĂ© maximale.
Contexte : Lâinformatique devient multi-cĆurs. C11 intĂšgre le support natif du multithreading et de la programmation concurrente.
Nouveautés majeures :
#include <threads.h>
int thread_function(void *arg) {
(void)arg; // ParamÚtre non utilisé
printf("Thread en cours\n");
return 0;
}
int main(void) {
thrd_t thread;
thrd_create(&thread, thread_function, NULL);
thrd_join(thread, NULL);
return 0;
}
#include <stdatomic.h>
atomic_int counter = 0; // Initialisation directe (ATOMIC_VAR_INIT déprécié en C17)
void increment() {
atomic_fetch_add(&counter, 1); // Thread-safe !
}
_Generic)#define abs(x) _Generic((x), \
int: abs_int, \
float: fabsf, \
double: fabs \
)(x)
static_assert(sizeof(int) == 4, "int doit faire 4 octets");
struct {
int x, y;
} point = {10, 20};
#include <stdalign.h>
alignas(16) float vector[4]; // Aligné sur 16 octets
char16_t utf16_string[] = u"Hello äžç";
char32_t utf32_string[] = U"Hello äžç";
Ătat en 2025 : Standard recommandĂ© en production â. Support universel, mature et stable.
Contexte : C17 (officiellement publiĂ© en 2018, dâoĂč son nom alternatif C18) nâest pas une nouvelle version majeure. Câest une version de maintenance qui corrige des bugs et ambiguĂŻtĂ©s de C11.
Changements :
En pratique : C17 = C11 corrigé. Si votre compilateur supporte C17, utilisez-le plutÎt que C11.
gcc -std=c17 program.c # Identique Ă C11 en pratique, mais "officiel"
Ătat en 2025 : Ăquivalent Ă C11 pour les dĂ©veloppeurs. Version stable recommandĂ©e.
Contexte : AprÚs 12 ans sans évolution majeure, C23 apporte de nouvelles fonctionnalités pour moderniser le langage tout en restant compatible.
Nouveautés principales (aperçu) :
[[deprecated]], [[nodiscard]]nullptr (comme en C++)typeof standardisĂ©0b1010#embed pour inclure des fichiers binairesconstexprĂtat en 2025 : Support partiel par les compilateurs. Adoption progressive. Pas encore recommandĂ© pour la production.
đ Note : La section 1.3.1 dĂ©taille C23 en profondeur. Nous y reviendrons.
| Fonctionnalité | C89 | C99 | C11 | C17 | C23 |
|---|---|---|---|---|---|
| Commentaires // | â | â | â | â | â |
| Variables dĂ©clarĂ©es partout | â | â | â | â | â |
for (int i=0; ...) |
â | â | â | â | â |
<stdbool.h> (bool) |
â | â | â | â | Natif |
<stdint.h> (int64_t) |
â | â | â | â | â |
| VLA (tableaux longueur variable) | â | â | Optionnel | Optionnel | Optionnel |
| Initialisation dĂ©signĂ©e | â | â | â | â | â |
inline |
â | â | â | â | â |
_Generic |
â | â | â | â | â |
static_assert |
â | â | â | â | â |
| Threads natifs | â | â | â | â | â |
Atomiques (<stdatomic.h>) |
â | â | â | â | â |
Alignement (alignas) |
â | â | â | â | â |
nullptr |
â | â | â | â | â |
typeof |
Extension | Extension | Extension | Extension | â |
Binaires 0b... |
â | â | â | â | â |
Attributs [[...]] |
â | â | â | â | â |
#embed |
â | â | â | â | â |
C89/C90 â Presque tout compatible avec C99
â
C99 â Presque tout compatible avec C11
â
C11 â 100% compatible avec C17 (juste corrections)
â
C17 â TrĂšs compatible avec C23 (quelques breaking changes mineurs)
Principe général : Les normes C sont rétrocompatibles à ~95%. Un code C89 compile généralement en C99, C11, C17 et C23.
| Situation | Norme recommandée | Raison |
|---|---|---|
| Apprentissage (2025) | C11 ou C17 | Standard actuel, bien documenté |
| Nouveau projet pro | C11 ou C17 | Support universel, stable |
| Projet existant | Version actuelle | Ne changez pas sans raison |
| Embarqué contraint | C99 ou C11 | Selon toolchain disponible |
| Compatibilité maximale | C99 | Fonctionne partout |
| SystÚmes critiques | C11 | Maturité, certification |
| Expérimentation | C23 | Découvrir les nouveautés |
Nous utiliserons principalement C11 (avec C17) pour les raisons suivantes :
Mentions de C23 : Nous signalerons les nouveautés C23 quand pertinent, mais ne les utiliserons pas systématiquement.
Pour spécifier explicitement quelle norme utiliser :
# C89/C90
gcc -std=c90 program.c -o program
# C99
gcc -std=c99 program.c -o program
# C11
gcc -std=c11 program.c -o program
# C17
gcc -std=c17 program.c -o program
# C23 (si supporté)
gcc -std=c23 program.c -o program
GCC supporte aussi des versions « GNU » qui ajoutent des extensions :
# C11 + extensions GNU
gcc -std=gnu11 program.c -o program
# C11 strict (sans extensions)
gcc -std=c11 program.c -o program
Différence :
-std=c11 : C11 strict, conforme Ă la norme ISO-std=gnu11 : C11 + extensions GNU (plus flexible)-pedanticPour respecter strictement la norme (portable) :
gcc -std=c11 -pedantic -Wall -Wextra program.c -o program
Lâoption -pedantic Ă©met des warnings si vous utilisez des extensions non standard.
Dans votre code, vous pouvez détecter quelle version de C est utilisée :
#include <stdio.h>
int main(void) {
#if defined(__STDC__)
printf("Compilateur conforme au standard C\n");
#ifdef __STDC_VERSION__
#if __STDC_VERSION__ == 199409L
printf("Version: C94 (amendement)\n");
#elif __STDC_VERSION__ == 199901L
printf("Version: C99\n");
#elif __STDC_VERSION__ == 201112L
printf("Version: C11\n");
#elif __STDC_VERSION__ == 201710L
printf("Version: C17\n");
#elif __STDC_VERSION__ == 202311L
printf("Version: C23\n");
#else
printf("Version: %ld\n", __STDC_VERSION__);
#endif
#else
printf("Version: C89/C90 (pas de __STDC_VERSION__)\n");
#endif
#else
printf("Compilateur non conforme au standard C\n");
#endif
return 0;
}
Compilation et test :
gcc -std=c11 detect_version.c -o detect && ./detect
# Sortie: Version: C11
gcc -std=c99 detect_version.c -o detect && ./detect
# Sortie: Version: C99
C89 (1989) â PremiĂšre standardisation
â
C99 (1999) â Modernisation (10 ans aprĂšs)
â
C11 (2011) â Concurrence native (12 ans aprĂšs)
â
C17 (2017) â Corrections (6 ans aprĂšs)
â
C23 (2023) â NouveautĂ©s modernes (6 ans aprĂšs)
Pour dĂ©buter en 2025 : C11 ou C17 â
gcc -std=c11 -Wall -Wextra -pedantic program.c -o program
Ou pour ĂȘtre encore plus rĂ©cent :
gcc -std=c17 -Wall -Wextra -pedantic program.c -o program
Maintenant que vous avez une vue dâensemble des normes C, nous allons approfondir :
Ces sections dĂ©tailleront les aspects pratiques du choix et de lâutilisation des diffĂ©rentes normes.
Vous avez maintenant une vision claire de lâĂ©volution du langage C et savez vous repĂ©rer parmi les diffĂ©rentes normes ! đ