Compiler et exécuter un programme C

Pour compiler et exécuter un programme C simple, on utilise les commandes suivantes:

		$$ gcc -Wall programme.c -o programme -lm
		$$ ./programme

On peut écrire ces deux commandes sur la même ligne:

$$ gcc -Wall programme.c -o programme -lm && ./programme

Avec la notation &&, le programme n'est lancé que s'il a compile sans erreurs.

Configurer Geany

Geany propose des boutons pour compiler (build) et exécuter (run) le programme:

Pour utiliser ces boutons, vérifiez la configuration sous Build → Set Build Commands:

C commands
Compile	`gcc -Wall -c "%f"`
Build	`gcc -Wall -o "%e" "%f" -lm`
Execute commands
Execute	`"./%e"`

Makefile

A l'aide d'un Makefile, on peut automatiser la compilation et l'exécution. Pour utiliser ça, créez un fichier Makefile (M majuscule, sans extension) avec le contenu suivant à côte de votre programme.c:

all: programme
	./programme

programme: programme.c
	gcc -Wall programme.c -o programme -lm

Ce Makefile contient deux règles, qui se lisent comme suit:

Pour faire tout, on a besoin du fichier programme, et on doit exécuter la commande ./programme.
Pour créer le fichier programme (l'exécutable), on a besoin du fichier programme.c, et on doit exécuter la commande gcc -Wall ... comme indiqué. Cette règle n'est exécutée que si programme.c a été modifié.

Une fois le Makefile est prêt, il suffit de taper:

$$ make

pour recompiler (si nécessaire) et lancer le programme.

Geany et Makefile

Geany vous propose un menu à côté du bouton Build. Si vous y selectionnez Make All, Geany va lancer make lorsque vous cliquez sur le bouton Build, et compiler et exécuter le programme d'un seul coup.

Compiler plusieurs fichiers

Si le programme englobe plusieurs fichiers *.c, on les passe tous à gcc:

$$ gcc -Wall fichier1.c fichier2.c fichier3.c -o programme -lm

Pour les projets de plusieurs 10'000 lignes de code, le temps de compilation devient important (plusieurs minutes). Dans ce cas-là, on peut compiler fichier par fichier au format intermédiaire *.o (object file), puis combiner ces derniers:

		$$ gcc -Wall -c fichier1.c -o fichier1.o
		$$ gcc -Wall -c fichier2.c -o fichier2.o
		$$ gcc -Wall -c fichier3.c -o fichier3.o
		$$ gcc -Wall fichier1.o fichier2.o fichier3.o -o programme

Si on modifie le fichier2.c seulement, il suffit de relancer les lignes 2 et 4 pour recompiler le programme, ce qui fait gagner du temps lors du développement et debogage du programme.

Avec cette approche, on utilise généralement un Makefile qui détermine automatiquement les fichiers modifiés. Voici un Makefile simple pour cette tâche:

SOURCEFILES = $(wildcard *.c)
OBJECTFILES = $(SOURCEFILES:.c=.o)

.PHONY: all
all: programme
	./programme

%.o: %.c
	gcc -Wall -c $< -o $@

programme: $(OBJECTFILES)
	gcc -Wall $^ -o $@ -lm

Plus d'informations sur les Makefiles:

Lancer un fichier *.c comme un script

Un peu ésotérique, et rarement utilisé en pratique, il est possible de lancer un fichier programme.c comme un script. Pour cela, il faut ajouter les commandes pour compiler le programme en-dessus du programme:

#! /bin/sh
EXE=`basename -s .c "$0"`
tail -n +5 "$0" | cc -x c -o $EXE - && exec ./$EXE "$@"
exit

		#include <stdio.h>

		int main(int argc, char * argv[]) {
			printf("Hello world!\n");
			return 0;
		}

Il faut encore marquer le fichier exécutable:

$$ chmod 755 programme.c

Puis, on peut le lancer comme un script:

$$ ./programme.c