Compiler en C sous Ubuntu : guide pratique de la commande cc

Introduction et prise en main

Ce guide détaille l’ensemble du flux de travail permettant de concevoir et générer des binaires exécutables en langage C à l’aide de l’utilitaire système standard cc sous Linux. De l’approvisionnement de la chaîne d’outils logicielle à la compilation multi-fichiers, en passant par la génération d’exécutables simples et la configuration d’indicateurs indispensables comme -o ou -Wall, chaque étape est abordée de façon méthodique et accessible.

Préparation de la chaîne de compilation et vérification de cc

Afin de doter votre distribution Ubuntu de tous les composants requis pour transformer du code C en exécutable binaire, déployez le métapaquet de référence via l’instruction sudo apt-get update -qq && sudo apt-get install -y build-essential.

sudo apt-get update -qq && sudo apt-get install -y build-essential

Localisez l’emplacement physique du binaire utilisé par défaut sur votre machine en interrogeant le système avec which cc.

which cc

Dans l’écosystème Unix/Linux, cc constitue l’alias traditionnel du compilateur C chargé de convertir vos fichiers sources en programmes autonomes.
Pour consulter la version exacte ainsi que les métadonnées de l’outil actif sur le poste, lancez cc --version.
⚙️ [Paramètres fondamentaux]

-o : Définit expressément le nom attribué à l’exécutable binaire résultant.
-c : Produit un fichier objet intermédiaire (.o) sans déclencher l’étape d’édition de liens.
-Wall : Active la quasi-totalité des avertissements d’analyse afin de repérer les anomalies potentielles du code.
-g : Intègre les symboles de débogage pour faciliter l’analyse post-mortem ou l’usage de GDB.
-O2 : Applique un niveau d’optimisation équilibré visant à maximiser la vitesse d’exécution du programme.

cc –version

Création d’un premier programme C et compilation élémentaire

Commencez par isoler vos expérimentations en préparant un répertoire dédié au sein de votre dossier personnel à l’aide de mkdir -p ~/c_practice && cd ~/c_practice.

mkdir -p ~/c_practice && cd ~/c_practice

Générez ensuite le fichier source initial (hello.c) intégrant un affichage standard grâce à l’utilitaire cat.

![cat « ‘EOF’ > hello.c #include <stdio.h>

int main(void) { printf(“Hello, Linux cc!\n”); return 0; } EOF](captures/s02_c02_cat_____EOF____hello_c__include__stdio_h___int_mai.png)

Lancez à présent la compilation du fichier hello.c sans argument supplémentaire en saisissant cc hello.c.
Faute de paramètre d’export particulier, le compilateur génère automatiquement un exécutable nommé a.out dans l’espace courant.

cc hello.c

Validez le comportement du binaire ainsi produit en appelant ./a.out dans votre terminal.
Le message configuré dans votre fonction principale, « Hello, Linux cc! », s’affiche alors directement sur la sortie standard.

./a.out

Nommage de l’exécutable (-o) et drapeaux de build (-Wall, -O2)

Afin d’examiner l’impact des options de compilation avancées, concevez un second script source (calc.c) effectuant un calcul arithmétique simple via la commande cat.

![cat « ‘EOF’ > calc.c #include <stdio.h>

int main(void) { int a = 15, b = 25; printf(“Result: %d\n”, a + b); return 0; } EOF](captures/s03_c01_cat_____EOF____calc_c__include__stdio_h___int_main.png)

Combinez l’option -Wall pour scruter la moindre anomalie de syntaxe, le drapeau -O2 pour ordonner l’optimisation des performances par le compilateur, et -o pour nommer directement le fichier final calc_app avec la commande cc -Wall -O2 -o calc_app calc.c.
Lorsque le processus s’achève sans lever d’alerte, votre binaire personnalisé est prêt à l’emploi.

cc -Wall -O2 -o calc_app calc.c

Inspectez les caractéristiques du fichier calc_app nouvellement créé en soumettant ls -l calc_app.
Le retour console atteste de la taille du binaire ainsi que de la présence des permissions d’exécution (x) adéquates.

ls -l calc_app

Testez la bonne exécution du binaire assemblé en invoquant ./calc_app.
Le terminal renvoie fidèlement le résultat de l’addition définie dans le code source sous la forme « Result: 40 ».

./calc_app

Compilation séparée en fichiers objets (-c) et édition de liens

Pour aborder la structuration de projets modulaires, débutez par l’écriture du fichier d’en-tête (message.h) contenant la déclaration de la fonction à l’aide de cat.

cat « ‘EOF’ > message.h
#ifndef MESSAGE_H
#define MESSAGE_H
void print_msg(void);
#endif
EOF

Implémentez ensuite la logique de traitement correspondante au sein du module source (message.c) avec la commande cat.

$cat « ‘EOF’ > message.c #include <stdio.h> #include “message.h” void print_msg(void) { printf(“Modular Build Complete!\n”); } EOF$

Rédigez à présent le point d’entrée principal de l’application (main.c), qui importe l’en-tête et orchestre l’appel de la fonction, toujours via cat.

$cat « ‘EOF’ > main.c #include “message.h” int main(void) { print_msg(); return 0; } EOF$

Compilez chaque module source C (message.c et main.c) en fichiers objets intermédiaires sans déclencher l’édition de liens en lançant cc -c message.c main.c.
L’emploi de l’option -c suspend l’étape finale d’assemblage et génère un fichier objet unitaire (.o) pour chaque fichier source fourni.

cc -c message.c main.c

Assurez-vous de la présence effective de ces artefacts intermédiaires dans votre dossier avec ls -l *.o.
La liste détaille l’apparition des deux entités message.o et main.o, prêtes pour la phase d’association.

ls -l *.o

Reliez l’ensemble des modules précompilés (message.o et main.o) en un exécutable unique baptisé modular_app par le biais de cc -o modular_app message.o main.o.
Cette phase d’édition de liens résout les dépendances de symboles croisées pour forger le programme autonome final.

cc -o modular_app message.o main.o

Vérifiez le fonctionnement de l’application modulaire obtenue en exécutant ./modular_app.
Le bon déroulement de l’appel inter-modules se matérialise sur le terminal par la phrase « Modular Build Complete! ».

./modular_app

Ce guide a passé en revue les mécanismes fondamentaux de la commande cc sous Ubuntu, de la manipulation des options de build essentielles à la mise en œuvre de la compilation modulaire.
Grâce à ces notions et paramètres clés, vous disposez d’un socle technique solide pour concevoir et compiler des architectures logicielles C performantes et fiables sous Linux.