Discussion :

[tendertender]

Bonjour,

J'ai un probleme a linker mon application qui contient deux fichiers sources : un pour l'application et l'autre pour le Frame.

Mon application roule correctement sou windows avec devc++ toutefois sous linux j'ai des erreurs de linkage (enfin je pense)

voila mon make file

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
 
CXX = $(shell wx-config --cxx)
 
PROGRAM1 = prog1
PROGRAM2 = prog1Frame
# wx-config --libs
WX_LIBS = $(shell wx-config --libs)
 
# wx-config --cxxflags
 
WX_CXXFLAGS = $(shell wx-config --cxxflags)
OBJECTS = $(PROGRAM1).o
# implementation
.SUFFIXES:      .o .cpp
 
.cpp.o :
 
	$(CXX) $(WX_CXXFLAGS) -c  -o $@ $<
 
all:	$(PROGRAM1) $(PROGRAM2)
$(PROGRAM2) :$(PROGRAM2).o
$(PROGRAM1) :$(OBJECTS)
 
	$(CXX) $(WX_LIBS) -o $(PROGRAM1) $(PROGRAM2).o $(OBJECTS)

un type d'erreur affiché

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
 
undefined reference to `wxSizerItem::wxSizerItem(wxWindow*, int, int, int, wxObject*)'

Merci pour votre attention

[kwariz]

Bonjour,

Oui le type d'erreur affichée est bien une erreur de link. Cela provient de ton Makefile aux lignes 17 et 23. Quand tu définis une recette celle-ci doit suivre immédiatement les dépendances et doit commencer par un caractère tabulation. De plus je ne comprends pas ce que tu as voulu faire dans cette partie :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
all:	$(PROGRAM1) $(PROGRAM2)
$(PROGRAM2) :$(PROGRAM2).o
$(PROGRAM1) :$(OBJECTS)
 
	$(CXX) $(WX_LIBS) -o $(PROGRAM1) $(PROGRAM2).o $(OBJECTS)

As-tu voulu dire «que ce soit pour PROGRAM2 ou PROGRAM1 lance la recette $(CXX) ...» ?
Cherches-tu à créer deux exécutables ?

Quoi qu'il en soit, ton Makefile n'est pas correct dans l'état.

[tendertender]

Honnêtement j'a récupérer ce makefile du wiki de wxWdigets.

ce que je veux faire simplement est de compiler mes deux fichiers en tenant en compte la libraire wxWidgets.

Est ce qu'il y a une manière plus facile de le faire ?

merci

[kwariz]

Non le Makefile est une bonne option, nous allons en construire un qui devrait faire l'affaire.
La syntaxe d'un Makefile est simple (enfin souvent) mais rigide.
Il y a la partie déclaration de variables (nom=valeur), la partie directives (en gros modification du comportement de make, dans ton exemple .SUFFIXES) et la partie boulot (la description des dépendances ainsi que les commandes à exécuter).

Dans la partie déclaration il est d'usage de déclarer dans des variables différentes le compilateur ainsi que les options que tu vas lui donner pour les différentes étapes.
Dans ton cas je te propose :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
# Compilateur et options de base                                                                                                                
CXX      = g++
CXXFLAGS = -g -Wall -Wextra
LDFLAGS  = -g
LDLIBS   = -lm

CXX est le nom usuel de la variable contenant le compilateur c++, CXXFLAGS celui de la variable pour passer les options pour le préprocesseur et de compilation, LDFLAGS pour les bibliothèques que tu vas utiliser et LDLIBS ce qui va aller en bout de ligne de commande (-lm doit souvent se trouver en fin).
Ensuite on passe «aux trucs qu'on rajoute», dans ton cas ce qu'il faut pour utiliser la bibliothèque wxWidgets :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
# Options pour la bibliothèque wxWidgets                                                                                                        
CXXFLAGS += $(shell wx-config --cxxflags)
LDFLAGS  += $(shell wx-config --libs)

Remarque l'utilisation de += pour ajouter.

Maintenant on peut commencer à décrire ce qui concerne nos programmes. Nous allons aussi passer par des variables :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
# Déclaration variables programmes                                                                                                              
PROG1     = prog1
PROG1_SRC = prog1.cpp
PROG1_OBJ = $(PROG1_SRC:.cpp=.o)
 
PROG2     = prog1Frame
PROG2_SRC = prog1Frame.cpp
PROG2_OBJ = $(PROG2_SRC:.cpp=.o)

Ici rien de magique : PROG1 contient le nom de l'exécutable final, PROG1_SRC la liste de toutes les sources que tu vas compiler pour créer PROG1 et PROG1_OBJ la liste des objets à lier pour construire PROG1. Souvent la liste des fichiers objets à lier est simplement la liste des sources auxquels on a substitué l'extension .cpp par un .o, c'est ce qui est décrit par $(PROG1_SRC:.cpp=.o) = on prend la valeur de PROG1_SRC et on remplace les .cpp par des .o.
Le même schéma est appliqué à PROG2.

Maintenant passons à la partie boulot.
Make a une liste de comportement pas défaut (comment créer un objet à aprtir d'un source c ou fortran ou c++, comment créer un exécutable à partir d'un fichier objet, etc). Nous allons commencer par lui dire de tout oublier et de ne suivre que nos directives :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
# On oublie les règles implicites                                                                                                               
.SUFFIXES =

Ensuite nous allons définir une cible qui ne va pas créer de fichier mais qui est une cible virtuelle pour lancer la construction des deux programmes. Cette cible s'appelle usuellement all. Cette cible ne va pas lancer de commandes et ne va pas créer de fichier nommé all, mais comme nous allons lister les deux exécutables en dépendances make va devoir satisfaire les dépendances et les créer. Ce type de cible (qui ne construit pas de fichiers du nom de la cible et qui doit s'exécuter à chaque fois même si un fichier du nom de la cible existe) est une cible dite phony ce qu'il va falloir préciser.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
# La règle principale                                                                                                                           
.PHONY: all
 
all: $(PROG1) $(PROG2)

Ici on voit que pour lister les dépendances on utilise la syntaxe cible: dep1 dep2 qui signifie simplement cible dépend de dep1 et dep1.

On va expliquer comment créer les exécutables :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
# Les dépendances des programmes                                                                                                                
$(PROG1): $(PROG1_OBJ)
        $(CXX) $(LDFLAGS) -o $@ $^ $(LDLIBS)
 
$(PROG2): $(PROG2_OBJ)
        $(CXX) $(LDFLAGS) -o $@ $^ $(LDLIBS)

Chaque programme dépend uniquement de ses objets, et pour créer l'exécutable on lance la commande de la recette. ATTENTION c'est là qu'il faut mettre des tab ... Ici tu remarques l'utilisation de variables (nommée automatiques) $@ (qui est remplacé par le nom de la cible) et $^ (qui est remplacé par la totalité de la liste des dépendances)

Nous pourrions aussi faire de même pour chaque fichier objet mais nous allons utiliser des raccourcis : on va dire comment construire de manière générique un objet à partir d'un source puis seulement ensuite on va lister les dépendances pour chaque objet.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
# Nouvelle règle implicite pour créer un objet à partir d'un source c++                                                                         
%.o: %.cpp
        $(CXX) $(CXXFLAGS) -o $@ -c $<
 
# Description des dépendances                                                                                                                   
prog1.o: prog1.cpp
 
prog1Frame.o: prog1Frame.cpp

La règle générique dit simplement «si on a besoin de truc.o alors on vérifie si truc.cpp existe et si c'est le cas on exécute la commande de la recette qui suit». Le est un peu comme une * en shell.
Ici une nouvelle variable automatique apparaît $<, elle est remplacée par la tête de la liste des dépendances, et comme dans la règle implicite il n'y a qu'une dépendances ...

Attention ! Dans le description des dépendances qui finit le bout de code, il ne faut pas oublier de préciser les headers (si dans prog1.cpp tu utilises truc.h alors truc.h doit apparaître dans la liste).

On peut finir avec une petite cible clean (qui elle aussi doit être phony, tu vois pourquoi ?) pour nettoyer rapidement les fichiers générés.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
# Autres cibles classiques                                                                                                                      
.PHONY: clean
 
clean:
        rm -f $(PROG1) $(PROG2)
        rm -f $(PROG1_OBJ) $(PROG2_OBJ)

Je te joins le fichier Makefile en entier, tapé à la volée sans vérification. Mais ça devrait te faire une bonne base de départ.

Makefile.gz

[tendertender]

Merci pour ta réponse et ton cours sur les makefile

Je viens juste de le tester mais j'ai un erreur de linkage sur la fonction main !!!

undefined reference to `main'

a ma connaissance les wxWidiget n ont pas de fonction main de moins explicite

[kwariz]

Tu veux bien créer deux exécutables non ? (je t'avais déjà posé la question au post précédent)
Si tu n'as qu'un exécutable à créer alors ma supposition est fausse.
Dans ce cas Prog1Frame.cpp est une dépendances de Prog1 et le Makefile est à revoir.

Combien d'exécutables veux-tu créer ?
Combien de sources ont une fonction main ?

[tendertender]

Peut etre que je me suis mal exprimé,

en effet

prog1 dépend de prog1Frame, (notion de wxwidget : une application qui va appeler un frame).

les deux sources prog1 et prog1Frame ne contiennent pas de main car si mes connaissance sont bonnes on ne devrait pas spécifier dans un projet wxwidget.

et enfin je voudrais créer un exécutable qui sera mon interface.

Le code se compile et s’exécute correctement sous windows avec wxDev

Merci pour ta patience

[kwariz]

Ok ... un seul exécutable donc.
Dans ce cas il faut modifier le Makefile ...
D'abord dans la partie description du programme, on décrit la liste des sources et on oublie tout à propos de PROG2

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
# Déclaration variables programmes                                                                                                              
PROG1     = prog1
PROG1_SRC = prog1.cpp prog1Frame.cpp
PROG1_OBJ = $(PROG1_SRC:.cpp=.o)

Un peu plus loin pareil :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
# La règle principale                                                                                                                           
.PHONY: all
 
all: $(PROG1)
 
# Les dépendances des programmes                                                                                                                
$(PROG1): $(PROG1_OBJ)
        $(CXX) $(LDFLAGS) -o $@ $^ $(LDLIBS)

Même si maintenant la cible all devient un peu inutile

Je suppose que tu dois avoir un Prog1Frame.h ? Dans ce cas ne pas oublier la dépendance :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
# Description des dépendances                                                                                                                   
prog1.o: prog1.cpp prog1Frame.h

prog1Frame.o: prog1Frame.cpp

Je ne connais pas l'utilisation exacte de cette bibliothèque ... mais en regardant rapidement en diagonale un tuto tu dois avoir un .cpp qui contient IMPLEMENT_APP je suppose ... c'est le main caché sans doute ...

Enfin, essaye déjà avec la version suivante

Makefile.gz

[tendertender]

ca marche nikel

merci vraiment de tout coeur