Compilation séparée

1. Commande de compilation

mcc -c module1.c -o module1.o

* avec alias mcc gcc -ansi -pedantic -W -Wall
* -o module1.o est optionnel puisque le nom est repris par défaut

2. Fichiers include

#include "votre_fichier.h" et non #include <fichier_systeme.h>

A. Comment partager une variable globale ?

La déclarer dans le main : int i;
Y faire référence dans un module : extern int i;

B. Comment ne pas répéter une partie des déclarations ?

Créer un fichier vars.h contenant :

NOMEM int i;
Dans le main, écrire :

#define NOMEM /* rien */
#include "vars.h"
Dans le module, écrire :

#define NOMEM extern
#include "vars.h"

C. Comment ne pas inclure plusieurs fois le même fichier ?

Exemple de problème :

`Rationnel.h`	`operations.h`	`entrees-sorties.h`	`rationnel.c`
`typedef struct` `{ int num, den; }` `Rationnel;`	`#include "Rationnel.h"` `Rationnel ajoute( Rationnel, Rationnel );`	`#include "Rationnel.h"` `void affiche( Rationnel );`	`#include "operations.h"` `#include "entrees-sorties.h"`

Erreur de compilation de rationnel.c : type Rationnel déjà défini !
car operations.h et entrees-sorties.h incluent tous les deux Rationnel.h

Solution dans Rationnel.h :

#ifndef _RATIONNEL_H
#define _RATIONNEL_H
typedef struct { int num, den; } Rationnel;
#endif

Explication : si la constante _RATIONNEL_H n'est pas définie, on la définit et on définit le type Rationnel ; si elle est définie, on ne fait rien.
A systématiser dans tous les fichiers include

3. Commande d'édition de liens

mcc -lm -o executable module1.o ... moduleN.o

-lm est optionnel et demande le lien avec la bibliothèque mathématique (utile uniquement lorsque l'inclusion de <math.h> a été nécessaire lors de la compilation d'au moins un des modules)
L'exécution s'obtient par : ./executable

4. `makefile` typique en C : à télécharger (pas de copier/coller !)

Le fichier doit s'appeler makefile sans extension !

# definitions du projet TARGET = exe OBJECTS = main.o proc.o # # premiere regle: commande d'edition de liens $(TARGET) : $(OBJECTS) $(CC) $(LFLAGS) -o $@ $(OBJECTS) # # dependances d'includes main.o : main.h prototypes.h proc.o : proc.h prototypes.h # # commande generale de compilation %.o : %.c $(CC) $(CFLAGS) -o $@ -c $< # # parametres de gcc CC = gcc CFLAGS = -ansi -pedantic -W -Wall LFLAGS = -lm # # commandes de nettoyage TOCLEAN = $(OBJECTS) *~ clean : rm $(TOCLEAN) cleanall : rm $(TARGET) $(TOCLEAN)

Les lignes commençant par # sont des commentaires.
Il suffit de taper make pour reconstruire le programme.
Il est possible de taper make clean pour supprimer les fichiers inutiles, ou make cleanall pour ne conserver que les sources.
Les seules choses à modifier sont les valeurs des variables TARGET (nom de l'exécutable) et OBJECTS (liste des fichiers .o).
Il est également conseillé d'ajouter des règles du type module.o : f1.h f2.h pour spécifier les dépendances particulières de certains modules.
Voir également la commande imake