🔝 Retour au Sommaire
Avant de commencer à programmer en C, il est essentiel de savoir quel compilateur vous avez sur votre système et quelles versions du standard C il supporte. Cela vous évitera des surprises et des erreurs difficiles à comprendre.
Dans cette section, nous allons apprendre Ă :
💡 Rassurez-vous : Cette section peut sembler technique, mais nous allons procéder pas à pas. Vous n’avez besoin d’aucune connaissance préalable en ligne de commande !
Sur Ubuntu (et Linux en général), vous avez principalement deux compilateurs C :
| Compilateur | Description | Origine |
|---|---|---|
| GCC | GNU Compiler Collection | Projet GNU (Free Software Foundation) |
| Clang | C Language Family Frontend | LLVM Project (Apple, Google, etc.) |
GCC est généralement installé par défaut sur Ubuntu. Clang peut être installé facilement si besoin.
Pour débuter : GCC
Clang est une alternative intéressante pour :
🎯 Recommandation : Commencez avec GCC. Une fois à l’aise, vous pourrez essayer Clang pour comparer.
Ouvrez un terminal (Ctrl+Alt+T sur Ubuntu) et tapez :
gcc --version
RĂ©sultat typique sur Ubuntu 24.04 :
gcc (Ubuntu 13.2.0-23ubuntu4) 13.2.0
Copyright (C) 2023 Free Software Foundation, Inc.
This is free software; see the source for copying conditions. There is NO
warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
Interprétation :
13.2.0Si vous voyez gcc: command not found, installez-le :
sudo apt update
sudo apt install build-essential
Le paquet build-essential installe :
💡 sudo : Commande pour exécuter avec les droits administrateur. Ubuntu vous demandera votre mot de passe.
Chaque version de GCC a un standard C par défaut. Voici un tableau de correspondance :
| Version GCC | Standard par défaut | Année de sortie |
|---|---|---|
| GCC 4.x | gnu90 (basé sur C89/C90) |
~2005-2015 |
| GCC 5-10 | gnu11 (basé sur C11) |
2015-2020 |
| GCC 11-14 | gnu17 (basé sur C17) |
2021-2024 |
| GCC 15+ | gnu23 (basé sur C23) |
2025+ |
⚠️ Note :
gnu11,gnu17= C11/C17 + extensions GNU. On verra la différence plus bas.
Pour connaître le standard par défaut :
gcc -dM -E - < /dev/null | grep __STDC_VERSION__
RĂ©sultat possible :
#define __STDC_VERSION__ 201710L
DĂ©codage :
201710L = C17 (publié en 2017-10)201112L = C11 (publié en 2011-12)199901L = C99 (publié en 1999-01)202311L = C23 (publié en 2023-11)Créons un petit programme test pour vérifier les standards supportés.
Créez un fichier test_std.c :
#include <stdio.h>
int main(void) {
#ifdef __STDC_VERSION__
printf("Standard C détecté : ");
#if __STDC_VERSION__ == 199901L
printf("C99\n");
#elif __STDC_VERSION__ == 201112L
printf("C11\n");
#elif __STDC_VERSION__ == 201710L
printf("C17\n");
#elif __STDC_VERSION__ == 202311L
printf("C23\n");
#else
printf("Version : %ld\n", __STDC_VERSION__);
#endif
#else
printf("C90 ou antérieur\n");
#endif
return 0;
}
Testez différents standards :
# C89/C90
gcc -std=c90 test_std.c -o test_std && ./test_std
# C99
gcc -std=c99 test_std.c -o test_std && ./test_std
# C11
gcc -std=c11 test_std.c -o test_std && ./test_std
# C17
gcc -std=c17 test_std.c -o test_std && ./test_std
# C23 (si supporté)
gcc -std=c23 test_std.c -o test_std && ./test_std
RĂ©sultats attendus :
Standard C détecté : C99
Standard C détecté : C11
Standard C détecté : C17
Standard C détecté : C23
💡 Si C23 échoue avec une erreur, c’est normal ! Cela signifie simplement que votre version de GCC ne le supporte pas encore complètement.
clang --version
RĂ©sultat typique :
Ubuntu clang version 18.1.3 (1ubuntu1)
Target: x86_64-pc-linux-gnu
Thread model: posix
InstalledDir: /usr/bin
sudo apt update
sudo apt install clang
Pour une version spécifique (exemple : Clang 18) :
sudo apt install clang-18
Utilisez le mĂŞme fichier test_std.c :
# C11
clang -std=c11 test_std.c -o test_std && ./test_std
# C17
clang -std=c17 test_std.c -o test_std && ./test_std
# C23
clang -std=c23 test_std.c -o test_std && ./test_std
| Standard | GCC min. | Clang min. | Disponibilité |
|---|---|---|---|
| C90/C89 | Toutes versions | Toutes versions | âś… Universel |
| C99 | GCC 3.0+ (2001) | Clang 3.0+ (2011) | âś… Universel |
| C11 | GCC 4.6+ (2011) | Clang 3.1+ (2012) | âś… Universel |
| C17 | GCC 8.0+ (2018) | Clang 6.0+ (2018) | âś… Universel |
| C23 | GCC 14+ (2024) | Clang 18+ (2024) | 🟡 Partiel |
| Ubuntu | Année | GCC par défaut | Clang disponible |
|---|---|---|---|
| 20.04 LTS | 2020 | GCC 9.4 | Clang 10-12 |
| 22.04 LTS | 2022 | GCC 11.4 | Clang 13-15 |
| 23.10 | 2023 | GCC 13.2 | Clang 16-17 |
| 24.04 LTS | 2024 | GCC 13.2 | Clang 18 |
| 24.10 | 2024 | GCC 14.x | Clang 18-19 |
🎯 Conclusion : Si vous êtes sur Ubuntu 22.04 ou plus récent, vous avez un excellent support de C11 et C17.
Créez test_threads.c :
#include <stdio.h>
#include <threads.h> // C11
int thread_func(void *arg) {
(void)arg;
printf("Thread C11 fonctionne !\n");
return 0;
}
int main(void) {
thrd_t thread;
thrd_create(&thread, thread_func, NULL);
thrd_join(thread, NULL);
return 0;
}
Compilation :
gcc -std=c11 test_threads.c -o test_threads -pthread
./test_threads
⚠️ Note : Certaines implémentations de glibc n’incluent pas
<threads.h>. Si ça échoue, c’est un problème de bibliothèque, pas de compilateur. Utilisez plutôtpthread.h(POSIX threads).
Créez test_atomics.c :
#include <stdio.h>
#include <stdatomic.h> // C11
int main(void) {
atomic_int counter = 0; // Initialisation directe (ATOMIC_VAR_INIT déprécié en C17)
atomic_fetch_add(&counter, 5);
printf("Compteur atomique : %d\n", atomic_load(&counter));
return 0;
}
Compilation :
gcc -std=c11 test_atomics.c -o test_atomics
./test_atomics
RĂ©sultat attendu :
Compteur atomique : 5
_Generic (C11)Créez test_generic.c :
#include <stdio.h>
#define print_type(x) _Generic((x), \
int: "int", \
float: "float", \
double: "double", \
char *: "string", \
default: "unknown" \
)
int main(void) {
printf("Type de 42 : %s\n", print_type(42));
printf("Type de 3.14f : %s\n", print_type(3.14f));
printf("Type de \"Hello\" : %s\n", print_type("Hello"));
return 0;
}
Compilation :
gcc -std=c11 test_generic.c -o test_generic
./test_generic
RĂ©sultat :
Type de 42 : int
Type de 3.14f : float
Type de "Hello" : string
Créez test_c23.c :
#include <stdio.h>
// Test des attributs C23
[[nodiscard]] int compute(int x) {
return x * 2;
}
int main(void) {
// Constantes binaires C23
int flags = 0b1010;
// nullptr C23
int *ptr = nullptr;
printf("Flags : %d\n", flags);
printf("Pointer is null : %s\n", ptr == nullptr ? "oui" : "non");
return 0;
}
Compilation :
gcc -std=c23 test_c23.c -o test_c23
./test_c23
Si ça fonctionne → Vous avez C23 ! 🎉
Si erreur → Votre GCC ne supporte pas encore complètement C23.
-std= : Choisir le standard| Option | Description |
|---|---|
-std=c90 ou -std=c89 |
C89/C90 strict |
-std=c99 |
C99 strict |
-std=c11 |
C11 strict |
-std=c17 |
C17 strict |
-std=c23 |
C23 strict (si supporté) |
-std=gnu90 |
C90 + extensions GNU |
-std=gnu99 |
C99 + extensions GNU |
-std=gnu11 |
C11 + extensions GNU |
-std=gnu17 |
C17 + extensions GNU |
-std=gnu23 |
C23 + extensions GNU |
Différence :
c11) : Respecte strictement la norme ISOgnu11) : Ajoute des fonctionnalités GNU (plus flexible)Exemple :
# Strict C11 (erreur si on utilise des extensions GNU)
gcc -std=c11 -pedantic program.c -o program
# C11 + extensions GNU (plus permissif)
gcc -std=gnu11 program.c -o program
-pedantic : Mode strictActive les avertissements pour le code non-standard :
gcc -std=c11 -pedantic -Wall -Wextra program.c -o program
Pourquoi utiliser -pedantic ?
Pour voir toutes les macros définies par le compilateur :
gcc -dM -E - < /dev/null
Macros importantes :
| Macro | Signification |
|---|---|
__STDC__ |
Compilateur conforme au standard C |
__STDC_VERSION__ |
Version du standard (199901L, 201112L, etc.) |
__GNUC__ |
Version majeure de GCC |
__clang__ |
DĂ©fini si compilateur Clang |
__linux__ |
Système Linux |
__x86_64__ |
Architecture 64 bits |
Exemple d’utilisation dans le code :
#include <stdio.h>
int main(void) {
#ifdef __GNUC__
printf("Compilé avec GCC %d.%d.%d\n",
__GNUC__, __GNUC_MINOR__, __GNUC_PATCHLEVEL__);
#endif
#ifdef __clang__
printf("Compilé avec Clang\n");
#endif
printf("Version C : %ld\n", __STDC_VERSION__);
return 0;
}
Sur Ubuntu 24.04+ :
sudo apt update
sudo apt install gcc-14 g++-14
MĂ©thode 1 : Appel direct
gcc-14 -std=c23 program.c -o program
Méthode 2 : Alternatives système
# Installer gcc-14 comme alternative
sudo update-alternatives --install /usr/bin/gcc gcc /usr/bin/gcc-14 100
sudo update-alternatives --install /usr/bin/gcc gcc /usr/bin/gcc-13 90
# Choisir la version Ă utiliser
sudo update-alternatives --config gcc
Interface de sélection :
Il existe 2 choix pour l'alternative gcc.
Sélection Chemin Priorité État
------------------------------------------------------------
* 0 /usr/bin/gcc-14 100 mode automatique
1 /usr/bin/gcc-13 90 mode manuel
2 /usr/bin/gcc-14 100 mode manuel
Appuyez sur <Entrée> pour conserver la valeur par défaut[*] ou choisissez le numéro sélectionné :
gcc --version
which gcc
Configuration recommandée :
Commande de compilation Ă utiliser :
gcc -std=c11 -Wall -Wextra -Werror -pedantic program.c -o program
Explication des options :
-std=c11 : Utilise le standard C11-Wall : Active tous les warnings standards-Wextra : Active des warnings supplémentaires-Werror : Traite les warnings comme des erreurs (code plus propre)-pedantic : Mode strict conforme à la normeConfiguration conservatrice :
gcc -std=c99 -Wall -Wextra -O2 program.c -o program
-O2 pour optimisationsConfiguration moderne :
gcc -std=c17 -Wall -Wextra -O2 -g program.c -o program
-g pour symboles de débogageCréez un script check_compiler.sh pour tout vérifier automatiquement :
#!/bin/bash
echo "=== VĂ©rification du compilateur C ==="
echo
# VĂ©rifier GCC
echo "1. GCC"
if command -v gcc &> /dev/null; then
gcc --version | head -n1
echo " Standard par défaut :"
gcc -dM -E - < /dev/null | grep __STDC_VERSION__
else
echo " GCC non installé ❌"
fi
echo
# VĂ©rifier Clang
echo "2. Clang"
if command -v clang &> /dev/null; then
clang --version | head -n1
else
echo " Clang non installé ❌"
fi
echo
# Tester les standards C
echo "3. Support des standards C (GCC)"
for std in c90 c99 c11 c17 c23; do
if gcc -std=$std -xc - -o /dev/null <<< "int main(){}" 2>/dev/null; then
echo " $std : âś…"
else
echo " $std : ❌"
fi
done
echo
echo "=== Vérification terminée ==="
Utilisation :
chmod +x check_compiler.sh
./check_compiler.sh
RĂ©sultat typique :
=== VĂ©rification du compilateur C ===
1. GCC
gcc (Ubuntu 13.2.0-23ubuntu4) 13.2.0
Standard par défaut :
#define __STDC_VERSION__ 201710L
2. Clang
Ubuntu clang version 18.1.3 (1ubuntu1)
3. Support des standards C (GCC)
c90 : âś…
c99 : âś…
c11 : âś…
c17 : âś…
c23 : âś…
=== Vérification terminée ===
gcc --versiongcc -dM -E - < /dev/null | grep __STDC_VERSION__# VĂ©rifier GCC
gcc --version
# Compiler avec C11 (recommandé)
gcc -std=c11 -Wall -Wextra program.c -o program
# Compiler avec C17 (version corrigée de C11)
gcc -std=c17 -Wall -Wextra program.c -o program
# Mode strict
gcc -std=c11 -pedantic -Wall -Wextra program.c -o program
Sur Ubuntu 22.04 LTS ou plus récent :
-Wall -Wextra -pedanticVous êtes prêt(e) ! 🚀
Maintenant que vous avez vérifié votre compilateur, passons à la section suivante :
Vous allez comprendre pourquoi, malgré l’existence de C23, nous allons principalement utiliser C11/C17 dans ce tutoriel.
man gcc # Documentation GCC
man clang # Documentation Clang
info gcc # Manuel complet GCC (format Info)
Félicitations ! Vous savez maintenant vérifier et configurer votre environnement de compilation C. 🎉
âŹď¸Ź Pourquoi C11 reste la base recommandĂ©e en production