Formation Unix/Linux

Ce document présente une introduction à la programmation en langage C sous Unix/Linux, destinée aux étudiants et développeurs souhaitant comprendre les bases du développement C dans cet environnement. Il couvre la compilation, la création et l’utilisation de librairies, la compilation séparée, ainsi que l’utilisation des fichiers make pour automatiser la gestion des projets.

Le langage C

Le langage C est incontournable dans l’univers Unix/Linux. Le noyau du système, les interprètes de commandes (comme csh, bash) ainsi que les commandes système (ls, cp, rm, etc.) sont écrits en C. Pour développer des applications ou enrichir le système, il est donc essentiel de maîtriser ce langage et sa compilation.

Le C est un langage d’intérêt général, portable et non limité à un type spécifique de programmation. Il permet d’effectuer des opérations de bas niveau, nécessaires à l’écriture de systèmes d’exploitation. Il possède un jeu d’instructions limité, complété par de nombreuses bibliothèques. La plupart des systèmes disposent d’un compilateur C, souvent conforme à la norme ANSI. Sous Linux, le compilateur GNU C (gcc) est intégré dans toutes les distributions.

Construction d’un programme C

Déroulement d’une compilation

Un programme C est constitué d’un ou plusieurs fichiers sources avec l’extension .c. Des fichiers header personnels (.h) peuvent définir des fonctions créées par l’utilisateur. Pour compiler, on utilise la commande gcc :

gcc source.c

Cette commande génère un exécutable nommé a.out par défaut. Pour spécifier un nom d’exécutable, on utilise l’option -o :

gcc -o binaire source.c

La compilation fait intervenir plusieurs étapes :

• Le précompilateur (cpp) supprime les commentaires et interprète les directives de compilation.
• Le compilateur (cc ou gcc) génère du code assembleur.
• L’assembleur (as) crée un fichier objet (.o).
• L’éditeur de lien (ld) réunit les fichiers objets et les bibliothèques pour produire l’exécutable final.

Options du compilateur

Option	Caractéristiques
-v	Affiche toutes les actions effectuées lors de la compilation.
-c	Compile sans édition de lien, génère uniquement les fichiers objets (.o).
-o	Spécifie le nom de l’exécutable à générer.
-S	Génère un fichier assembleur (.s) sans créer l’exécutable.
-L	Indique un chemin supplémentaire pour la recherche de bibliothèques lors de l’édition de lien.
-l	Indique une bibliothèque à charger.
-I	Indique un chemin supplémentaire pour la recherche de fichiers header (.h).

Exemple d’exercice

Créez un fichier bonjour.c contenant :

#include <stdio.h>

int main(void)
{
    printf("bonjour\n");
    exit(0);
}

Compilez-le avec :

gcc -o bonjour bonjour.c

Exécutez l’exécutable bonjour. Recompilez avec l’option -v pour observer les étapes de compilation. Essayez aussi l’option permettant de générer uniquement le fichier assembleur, puis le fichier objet.

Construction de librairies

Création d’une librairie

Pour réutiliser des fonctions fréquemment utilisées, on peut créer une librairie statique. Voici deux fonctions à placer dans bonjour.c et revoir.c :

void bonjour(int nbre)
{
    int i;
    for(i=0; i<nbre; i++) printf("Bonjour ...\n");
    return;
}

void revoir(int nbre)
{
    int i;
    for(i=0; i<nbre; i++) printf("Au revoir ...\n");
    return;
}

Compilez ces fichiers en fichiers objets :

gcc -c bonjour.c revoir.c

Créez la librairie statique libsalut.a avec :

ar r libsalut.a bonjour.o revoir.o

Vérifiez le contenu de la librairie :

ar t libsalut.a

Utilisation de la librairie

Placez libsalut.a dans le répertoire de compilation. Créez un fichier exemple2.c :

#include <stdio.h>

void main(void)
{
    int a=0;
    while (a<1 || a>5)
    {
        printf("Donnez un nombre entre 1 et 5 compris: ");
        scanf("%d", &a);
        printf("\n");
    }
    bonjour(a);
    revoir(--a);
    exit(0);
}

Compilez avec :

gcc -o exemple exemple2.c libsalut.a

Ou, si la librairie est dans un autre répertoire (par exemple ~/librairies) :

gcc -o exemple exemple2.c -L~/librairies -lsalut

Compilation séparée

Présentation

Pour les projets volumineux, il est conseillé de découper le programme en plusieurs fichiers sources. Cela permet de ne recompiler que les fichiers modifiés, ce qui accélère le processus. Par exemple, pour un projet avec sourc1.c, sourc2.c et sourc3.c, on compile avec :

gcc -o exec sourc1.c sourc2.c sourc3.c

Pour ne recompiler que sourc3.c après modification :

gcc -c sourc3.c
gcc -o exec sourc3.o sourc1.o sourc2.o

Exercice

Téléchargez les fichiers menu.c, header.h, date.c et fichier.c. Ils composent une application affichant la date locale et la date de dernière modification d’un fichier. Compilez en un exécutable nommé prog et vérifiez son fonctionnement.

Modifiez la neuvième ligne de fichier.c en ajoutant :

printf("Affichage de la date de modification d’un fichier.\n");

Recompilez en ne recompilant que les fichiers nécessaires.

Les fichiers make

Intérêt et syntaxe

Pour gérer automatiquement la compilation dans un projet découpé en plusieurs modules, la commande make est utilisée. Elle s’appuie sur un fichier de description appelé makefile ou Makefile, qui contient les dépendances et les actions à effectuer.

Syntaxe :

make [-f nom_fichier] [-options] [cible]

Options courantes :

• -s : mode silencieux (pas d’affichage des commandes)
• -n : affiche les commandes sans les exécuter
• -d : mode debug, affiche beaucoup d’informations

Contenu d’un fichier Makefile

Un Makefile contient :

• Les dépendances entre fichiers sources
• Les actions à effectuer lors de modifications
• Des variables pour définir chemins, noms d’exécutables, etc.

Description d’un exemple de Makefile

OBJS=menu.o fichier.o date.o
EXEC=prog
INSTALLDIR=.
LIBS=~/librairie
CC=gcc

prog: $(OBJS)
	$(CC) $(OBJS) -o $(EXEC)

date.o: date.c header.h
	$(CC) -c date.c

menu.o: menu.c header.h
	$(CC) -c menu.c

fichier.o: fichier.c header.h
	$(CC) -c fichier.c

install:
	cp $(EXEC) $(INSTALLDIR)/prog2

clean:
	rm *.o prog

Explications :

• OBJS : liste des fichiers objets nécessaires
• EXEC : nom de l’exécutable à générer
• La cible prog dépend des fichiers objets. Si un objet est modifié, la compilation et l’édition de lien sont lancées.
• Les fichiers objets dépendent des fichiers sources et du header header.h. Si ce dernier change, tous les objets sont recompilés.
• Les cibles install et clean ne dépendent d’aucun fichier et exécutent des actions spécifiques.

Exercice

Créez ce Makefile dans votre répertoire. Supprimez tous les fichiers objets, lancez make pour compiler entièrement. Modifiez un fichier source, relancez make et observez que seule la partie modifiée est recompilée.

Glossaire des termes clés

• Compilateur : programme qui traduit le code source C en code machine exécutable.
• Précompilateur (cpp) : étape qui supprime les commentaires et traite les directives (#include, #define).
• Fichier source (.c) : fichier contenant le code écrit en langage C.
• Fichier header (.h) : fichier contenant des déclarations de fonctions et des macros.
• Fichier objet (.o) : fichier intermédiaire produit par l’assembleur, avant édition de lien.
• Éditeur de lien (ld) : programme qui assemble les fichiers objets et bibliothèques en un exécutable.
• Librairie statique (.a) : archive contenant des fichiers objets réutilisables dans plusieurs programmes.
• Makefile : fichier décrivant les dépendances et commandes pour automatiser la compilation.
• Commande make : outil qui exécute les règles du Makefile pour compiler uniquement ce qui est nécessaire.

Points clés à retenir

• Le langage C est essentiel pour le développement sous Unix/Linux, notamment pour le système lui-même.
• La compilation C se fait en plusieurs étapes : précompilation, compilation, assemblage, édition de lien.
• Les options du compilateur gcc permettent de contrôler la compilation, la génération de fichiers objets et assembleur.
• Créer des librairies statiques facilite la réutilisation de fonctions communes.
• La compilation séparée accélère le développement en recompilant uniquement les fichiers modifiés.
• Les fichiers Makefile automatisent la gestion des dépendances et des compilations dans les projets complexes.