Compilation en gcc.(langage C)

[invitebf26947a]

Bonjour,

je n'arrive pas à très bien compiler. Par exemple, si j'ai:

/*Le fichier est enregistre sous le nom de essai.c*/
#include <stdio.h>

int addition( int a, int b){
 int res;

 res = a + b;

return res;
}


int soustraction(int a, int b){
 int res = a - b; 
 return res;
}


int main(){
 int a = 1, b = 2, c =4, d = 3, e, f;

 e = addition(a,b);
 f = sousstraction(c, d) ;

 return 0;
}

je ne sais pas comment le compiler.

Je fais comme ça:

/*Si je n'ai aucun header*/
gcc -Wall - g -o main.o main.c
gcc - Wall main.o -o main

Mais pourquoi c'est faux?


Merci.
-----

[invitebf26947a]

Pardon, j'ai fais une erreur:

/*Si pas de header*/
gcc - Wall -g -c - o main.o main.c
gcc- Wall main.o main

Merci

[invite7a96054d]

Bonjour,

En fait la compilation passe par plusieurs étapes. En simplifiant, on écrit un source (le .c), puis gcc le préprocesse (traite toutes les lignes qui commencent par # en gros, en appelant le préprocesseur) et crée un fichier objet (le .o, en appelant l'assembleur). Ensuite gcc fait appel au linker qui à partir de fichier .o et de bibliothèques crée un exécutable.
Pour guider gcc dans le processus on lui fournit des options (les argument qui commencent par le caractère -).
-Wall par exemple demande à gcc de te signaler plus de warnings que par défaut ce qui est très important surtout lorsqu'on débute ; je ne peux que te conseiller d'y rajouter un -Wextra.
-g demande à gcc de préparer l'exécutable de manière à pouvoir le débugguer facilement avec un débuggueur (important aussi, mais on s'en passe dans les versions finales).
-c indique à gcc qu'il s'arrête après l'étape de création du fichier objet sans essayer de créer un exécutable, sans cette option gcc essayera d'aller jusqu'au bout et de créer un exécutable.
-o permet de donner un nom au fichier créé.

Donc tu as un fichier main.c, tu désires créer le fichier main.o et pas plus. La commande sera :

gcc -Wall -Wextra -g -c -o main.o main.c

Par défaut quand gcc crée un fichier objet à partir d'un fichier source c, le nom du fichier objet sera celui du fichier source dans lequel l'extension finale .c aura été remplacée par un .o . La commande peut donc se simplifier en :

gcc -Wall -Wextra -g -c main.c

Ensuite pour créer un exécutable à partir du seul fichier main.o, la commande est :

gcc -g -o main main.o

Ici l'option -o n'est pas inutile car par défaut le nom de l'exécutable est a.out.


Compiler en tapant les commandes à la main passe quand tu n'as qu'un fichier pour un exo simple. Lorsque que le nombre de sources augmente et que les dépendances (=quel .c appelle quel .h par exemple) cela devient compliqué. Pour gérer ça plus efficacement il faut créer un fichier makefile. Le fichier makefile est un fichier qui va dire quoi faire avec quel fichier et surtout décrire les dépendances entre les fichiers. Ensuite l'utilitaire make lit ce fichier et fait ce qu'il faut suivant les modifications apportées à ton projet. Make est relativement répandu, surtout utilisé sur les plateformes unix/linux. En environnement windows cette partie est prise en charge (en général) par ton IDE (cela se fait aussi sous linux/unix).

Par exemple un Makefile (quick and dirty) pour ton petit projet serait :

main: main.o
        gcc -g -o main main.o

main.o: main.c
        gcc -Wall -Wextra -g -c main.c

Mais tu te doutes que si ce n'était que ça un petit script ferait l'affaire ... En fait make est (bien que très vieux avec un syntxe lourde comme l'obligation d'utiliser des <tab> ...) plus puissant.
Si tu veux ou si tu as besoin de plus d'infos sur ça n'hésite pas.

[invite7a96054d]

Bon, après cette petite intro sur comment compiler rapidement, je suppose que tu reçois des messages d'erreurs (en regardant ton source en diagonale je vois que tu définis soustraction et que tu utilises sousstraction par exemple).
Pour pouvoir t'aider il est plus facile que tu expliques mieux ce qui ne vas pas ... les messages d'erreurs que tu reçois, TA PLATEFORME (linux, windows, max ...) etc ...
Parce qu'un «pourquoi c'est faux» c'est vague et ça ne nous permet pas de t'aider.

[A voir en vidéo sur Futura]

[invitebf26947a]

Bonjour, et merci encore

mes Makefile plante toujours!!
Pour en revenir à la compilation, ce que vous avez fait me laisse penser que vous avez qu'un seul fichier .c(le main.c), et que vous avez un truc comme calcul.h qui contient les signatures, et calcul.c qui contient les fonctions.

Est-ce cela?

[invite7a96054d]

Bonjour, et merci encore

mes Makefile plante toujours!!
Pour en revenir à la compilation, ce que vous avez fait me laisse penser que vous avez qu'un seul fichier .c(le main.c), et que vous avez un truc comme calcul.h qui contient les signatures, et calcul.c qui contient les fonctions.

Est-ce cela?

J'ai simplement repris ton exemple, rien de plus.
Il faut absolument arriver à faire des Makefile ... sinon tu seras rapidement chauve.
On va donc supposer que ton projet se compose des fichiers main.c, calcul.h et calcul.c :

main.c :

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

int main()                                                                                       
{                                                                                                
  int a = 1, b = 2, c =4, d = 3, e, f;                                                           
                                                                                                 
  e = addition(a,b);                                                                             
  f = soustraction(c, d) ;                                                                       
                                                                                                 
  return 0;                                                                                      
}

calcul.h :

#ifndef CALCUL_H__
#define CALCUL_H__

int addition(int, int);
int soustraction(int , int);


#endif /* CALCUL_H__ */

calcul.c :

#include "calcul.h"

int addition( int a, int b){
  int res;

  res = a + b;

  return res;
}


int soustraction(int a, int b){
  int res = a - b; 
  return res;
}

Le Makefile (on va en faire une version simple sans variables ou raccourcis ...) devra comporter au moins une règle pour créer l'exécutable. Celui-ci est créé à partir des fichiers objets main.o et calcul.o : il dépend donc d'eux

main: main.o calcul.o
	gcc -g -o main main.o calcul.o

ATTENTION: il y a un caractère tabulation avant gcc ... si tu mets des espaces ça va planter !!!!

Pour chacun des sources, on va créer des règles pour générer les fichiers objets :

main.o: main.c calcul.h
	gcc -g -Wall -Wextra -c main.c

calcul.o: calcul.c calcul.h
	gcc -g -Wall -Wextra -c calcul.c

Voilà ! tu as tout en main ... Tu remarqueras que j'ai fait dépendre chaque fichier objet non seulement du source associés mais aussi de calcul.h ... tu vois pourquoi ?

[invitebf26947a]

Bonjour,

merci bien. Que c'est clair!!!!
Je sens que mes makefiles qui plantent toujours, vont se transformer en makefile qui fontionne toujours.

Juste une precision:
Dans mes Makefile, je devais marquer quelquechose comme :

GCC_FLAGS =  -Wall -g

/*et des trucs du genres:*/
gcc $(GCC_FLAGS)

/*Et une commande comme*/
clean :
       rm -rf + pleins de trucs

A quoi correspondent ces choses?

Le calcul.h car , c'est là qu'est écrit mes fonctions.

[invite7a96054d]

Bonjour,

merci bien. Que c'est clair!!!!
Je sens que mes makefiles qui plantent toujours, vont se transformer en makefile qui fontionne toujours.

Juste une precision:
Dans mes Makefile, je devais marquer quelquechose comme :

GCC_FLAGS =  -Wall -g

/*et des trucs du genres:*/
gcc $(GCC_FLAGS)

/*Et une commande comme*/
clean :
       rm -rf + pleins de trucs

A quoi correspondent ces choses?

Ce sont les fameuses variables ...
Elles vont être utilisées pour simplifier l'écriture et la modification des règles. Repartons du Makefile :

main: main.o calcul.o
	gcc -g -o main main.o calcul.o

main.o: main.c calcul.h
	gcc -g -Wall -Wextra -c main.c

calcul.o: calcul.c calcul.h
	gcc -g -Wall -Wextra -c calcul.c

J'ai coloré ce qui est souvent répété : en rouge le compilateur (gcc), en vert les options passées à toutes les étapes de la compilation (-g) et en bleu les options passées uniquement lors de la création des fichiers objets.
Si tu changes de compilateurs (du genre tu arrives sur une machine où n'est disponible que icc le compilo intel ou cc le compilo par défaut) tu vas devoir modifier 3 règles, si tu ne veux plus de l'option pour le débuggage rebelotte et si tu as besoin d'une nouvelle option pour la phase d'assemblage tu auras 2 règles à modifier : pas pratique !
Donc comme le langage de make permet de définir des variables on va les utiliser pour simplifier la maintenance de ton Makefile. Pour déclarer une variable rien de plus simple :

NOM = valeur

Par convention, les noms de variables sont écrits en majuscules. Toujours par convention les variables suivantes sont souvent définies :
CC : l'exécutable pour compiler avec les options pour toutes les étapes
CFLAGS : les options passées à CC lors de la création du fichier objet
CPPFLAGS : les options passées à CC lors de l'étape du préprocesseur
LDFLAGS : les options passées à CC lors de la création de l'exécutable
LDLIBS : les options pour les bibliothèques

Pour utiliser la valeur de la variable il suffit d'écrire $(CC)

Cela se traduirait par :

CC = gcc -g                                                                                      
CPPFLAGS =                                                                                       
CFLAGS = -Wall -Wextra                                                                           
LDFLAGS =                                                                                        
LDLIBS =
main: main.o calcul.o                                                                            
        $(CC) $(LDFLAGS) -o main main.o calcul.o $(LDLIBS)                                                            

main.o: main.c calcul.h                                                                          
        $(CC) $(CFLAGS) $(CPPFLAGS) -c main.c                                                    

calcul.o: calcul.c calcul.h                                                                      
        $(CC) $(CFLAGS) $(CPPFLAGS) -c calcul.c

clean:                                                                                           
        rm -rf main calcul.o main.o

Tu remarqueras que tu peux laisser certines variables vides. Ces conventions peuvent te sembler lourdes mais on retrouve ces noms partout, et pour une bonne raison qui s'appelle les règles implicites (on verra sans doute ça plus tard).
Quand tu invoques make, il va lire le fichier Makefile (pour plus de détails essaye un man make), et va essayer de construire la cible de la première règle qu'il trouve. Dans notre cas, un make va provoquer tout ce qui faut pour créer main. Les règles ne sont lancées que si la cible (le côté gauche du est plus vieille qu'une des dépendances (la liste du côté droit du
S'il n'y a aucune dépendance alors la régle est toujours invoquée.
Tu peux spécifier la règle par laquelle make doit commencer sur la ligne de commande :

make clean

comme la cible clean de dépend de rien (en gros ... c'est un poil plus complexe), la commande de la règle sera toujours exécutée, en l'occurence on efface les fichiers générés ...

Le calcul.h car , c'est là qu'est écrit mes fonctions.

En fait si tu modifies calcul.c tu n'as pas besoin de recompiler main.c car les signatures des fonctions n'ont pas changé ; alors que si tu modifies la signature des fonctions alors il faudra recompiler main.c.

[invitebf26947a]

Rebonjour,

J'ai réussi un make!!!!
C'était sur un tri rapide!
Mon 1er makefile qui marche.

En suivant vos conseils j'ai réussi comme un grand mon exercice avec le Makefile.

Merci de vos conseils.

[invite7a96054d]

Well done !

[invitebf26947a]

Merci bien kwariz!!

[inviteb91afb9d]

Merci en effet pour les infos

[invite7a96054d]

Bonjour,

on a peine effleuré le sujet, il y a encore une tonne de fonctionnalités avec les makefiles :
-> les variables $@ $< $^
-> les règles implicites
-> les cibles spéciales
-> la technique du VPATH
-> générer automatiquement les dépendances

Et j'en passe des meilleures

Il y a une source à consulter le manuel de Make (version gnu).
C'est un vieil outil (1977, ça lui fait 35 ans le bougre) mais toujours aussi utile et puissant.