print · rss · source

< Quelques fonctions standards sous UNIX | TutoCFrench | Débogage à l'aide de gdb >


Compilation séparée

Notions :

  • compilation séparée
  • librairies
  • fichier objet .o
  • options de gcc (-l, -L, -I, etc.)
  • make

La compilation séparée permet de produire du code réutilisable (bibliothèques) et plus fiable. Indispensable pour les gros projets.

Un premier exemple de compilation séparée

Reprenont le code de la fonction longueur qui renvoie la taille d'une chaîne de caractères. Cette fonction est très utile et devrait pouvoir être réutilisable dans n'importe quel autre programme.

Compiler un fichier objet qui contient les fonctions

Voici le code du fichier longueur.c. Il faut le remanier afin qu'il ne contienne que le code de la fonction qui nous intéresse :

#include<stdio.h>

int longueur(char tab[])
{
    int i=0;
    while(tab[i])
        i++;
    return i;
}

On compile ce fichier afin de produire un fichier "objet" qui se termine par .o :

$ gcc -Wall -c longueur.c

On obtient le fichier longueur.o qui contient le code compilé de la fonction longueur. La commande UNIX nm nous permet de vérifier que la fonction longueur est bien définie dans le fichier longueur.o :

$ nm longueur.o
00000000 t gcc2_compiled.
00000000 T longueur

Utiliser le fichier objet

Attention, le fichier objet obtenu ne peut être exécuté directement. Pour ce faire, il faut créer un programme, dans un autre fichier, qui va faire appel à la fonction que nous avons définie. Exemple, le fichier main.c :

#include <stdio.h>

extern int longueur(char *);

int main()
{
    char chaine[]="hello";
    printf("%s fait %d caractères\n", chaine, longueur(chaine));     
    return 0;
}

Pour pouvoir utiliser la fonction longueur, il faut déclarer son prototype au début du programme en mettant la directive extern devant. Cette directive indique au compilateur que la fonction est présente dans un autre fichier que dans celui du programme principal. Pour compiler le programme contenu dans main.c :

$ gcc -Wall main.c longueur.o -o prog

Un code plus propre

A chaque fois que nous voulons utiliser une fonction externe, il faut déclarer son prototype. Il existe un moyen propre de faire cela : utiliser un fichier d'entête. Voici, dans le cas présent, ce fichier que nous appelerons fonc.h :

int longueur(char *);

On inclue le code du fichier d'entête dans le code source du programme avec la directive #include :

#include <stdio.h>
#include "fonc.h"

int main()
{
    char chaine[]="hello";     
    printf("%s fait %d caractères\n", chaine, longueur(chaine));
    return 0;
}

Automatiser la compilation avec make

Exemple de fichier Makefile :

OBJ=prog

prog : main.c longueur.o
       gcc -Wall $^ -o $@

%.o : %.c
       gcc -Wall -c $^

clean :
       rm -f *.o $(OBJ)

Variables prédéfinies

  • $^ : dépendances
  • $@ : cible
  • $< : nom de la première dépendance
  • $(basename filename) : préfixe de la cible courante

< Quelques fonctions standards sous UNIX | TutoCFrench | Débogage à l'aide de gdb >

print · rss · source
Page last modified on January 30, 2008, at 02:22 PM