Comprendre le Makefile (Exemple avec langage C).
Tags: makefile, c
Published: 2024-07-14 07:37:37

Un Makefile est un fichier utilisé par l'outil `make` pour automatiser la compilation de programmes. Voici les règles standards et les bonnes pratiques pour rédiger un Makefile efficace :

### Structure de Base d'un Makefile

1. **Cible (Target)** : Ce que tu veux construire (ex. un fichier exécutable).
2. **Prérequis (Prerequisites)** : Les fichiers nécessaires pour construire la cible (ex. fichiers source).
3. **Règle (Rule)** : La commande à exécuter pour créer la cible.

### Exemple Simple

```makefile
target: prerequisites
    command
```

### Règles Standards

1. **Règle par défaut** : La première cible dans le Makefile est celle qui sera construite par défaut.

2. **Compilation des fichiers source** :
   - Utiliser des variables pour les compilateurs et les options.
   - Exemple :

   ```makefile
   CC = gcc
   CFLAGS = -Wall -g
   SOURCES = main.c utils.c
   OBJECTS = $(SOURCES:.c=.o)
   TARGET = mon_programme

   $(TARGET): $(OBJECTS)
       $(CC) -o $@ $^

   %.o: %.c
       $(CC) $(CFLAGS) -c $< -o $@
   ```

3. **Phonies** : Utilise `.PHONY` pour les cibles qui ne correspondent pas à des fichiers.

   ```makefile
   .PHONY: clean
   clean:
       rm -f $(OBJECTS) $(TARGET)
   ```

4. **Variables** : Utilise des variables pour simplifier la gestion des chemins et des options.

   ```makefile
   CC = gcc
   CFLAGS = -Wall
   ```

5. **Gestion des dépendances** : Utilise des règles implicites et des modèles pour réduire la répétition.

6. **Dépendances automatiques** : Tu peux générer des dépendances automatiquement pour les fichiers `.o`.

   ```makefile
   -include $(OBJECTS:.o=.d)
   ```

### Exemple Complet

Voici un exemple complet de Makefile :

```makefile
# Variables
CC = gcc
CFLAGS = -Wall -g
SOURCES = main.c utils.c
OBJECTS = $(SOURCES:.c=.o)
TARGET = mon_programme

# Règle par défaut
all: $(TARGET)

# Lien de l'exécutable
# $@ -> $(TARGET)
# $^ -> $(OBJECTS)
$(TARGET): $(OBJECTS)
	$(CC) -o $@ $^

# Compilation des fichiers .c en .o
# $< -> Premier element des pr
%.o: %.c
	$(CC) $(CFLAGS) -c $< -o $@

# Déclaration des cibles phony
.PHONY: all clean fclean re

# Nettoyage des fichiers objets
clean:
	rm -f $(OBJECTS)

# Nettoyage complet (fichiers objets et exécutable)
fclean: clean
	rm -f $(TARGET)

# Refaire la compilation
re: fclean all
```

### Bonnes Pratiques

1. **Indenter avec des tabulations** : Les commandes dans les règles doivent être indentées avec des tabulations, pas des espaces.

2. **Commenter le code** : Utilise des commentaires pour expliquer les sections du Makefile.

3. **Regrouper les fichiers** : Si ton projet contient plusieurs fichiers, organise-les dans des sous-répertoires et utilise des variables pour gérer les chemins.

4. **Utiliser des règles implicites** : Profite des règles intégrées de `make` pour éviter de réécrire des règles courantes.

### Pourquoi utiliser .PHONY ?

- **Eviter les conflits :** Si un fichier avec le même nom qu'une cible existe, make pensera que la cible est à jour et n'exécutera pas les commandes associées. .PHONY évite cela.

- **Amélioration des performances :** Les cibles phony sont toujours considérées comme "à faire", ce qui peut améliorer la vitesse d'exécution des commandes associées.

### Pourquoi utiliser %.o: %.c pour la compilation ?

- Efficacité : Utiliser %.o: %.c permet de bénéficier de l'optimisation de make pour ne recompiler que ce qui est nécessaire.

- Pratique : Pour les projets de taille plus importante, %.o: %.c est beaucoup plus adaptée.

### Conclusion

Un Makefile bien structuré rend la gestion de projet plus facile et évite les erreurs de compilation. En respectant ces règles et bonnes pratiques, tu peux créer un Makefile efficace et maintenable.