Tout comme un fichier de code contient une ou plusieurs lignes de code comme contenu pour le rendre intéressant, le makefile de base est construit à l'aide de variables, de règles et de cibles. En dehors de cela, d’autres facteurs sont également nécessaires pour créer un makefile complet sans aucun problème. Dans ce guide, nous discuterons de la syntaxe de base du makefile et des problèmes courants lors de l'écriture d'un makefile et fournirons des solutions pour résoudre ces problèmes.
Comprendre la syntaxe de base du Makefile
Pour commencer la création d'un makefile, nous expliquons les propriétés de base d'un makefile via l'exemple de code makefile. Il est nécessaire d'inclure les propriétés de syntaxe suivantes dans le contenu du makefile pour obtenir un fichier exécutable :
Variable s : données de base stockant les objets qui doivent être utilisés dans le makefile. Ces variables sont utilisées pour spécifier un compilateur, des indicateurs, des fichiers source, des fichiers objets et des fichiers cible. Dans l'exemple de makefile suivant, il y a un total de cinq variables qui sont CXX (pour définir un compilateur C++), CXXFLAGSc (indicateurs du compilateur), TARGET (pour définir un nom de fichier exécutable cible), SRCS (pour définir un fichier de code source) , OBJS (pour contenir les fichiers objets générés via le fichier de code source).
Cibles : Une sortie attendue à construire à partir de la source. Il peut s'agir d'un fichier cible ou de n'importe quel nom symbolique : 'all' est la cible par défaut qui doit être construite via la variable 'TARGET', '$TARGET' dépend des variables 'OBJS', et la cible 'clean' supprime la cible et fichiers objets du répertoire de travail.
Règles et commandes de construction : Ensemble d'instructions de base à exécuter pour créer une cible à partir du fichier source ou des dépendances. Par exemple, la règle « %o : %.cpp » affiche que le fichier avec l'extension « cpp » est utilisé pour créer un fichier objet avec l'extension « o » alors que les deux fichiers contiennent le même nom. Par contre, la commande build $(CXX) $(CXXFLAGS) -o $(CIBLE) $(OBJS) est utilisé pour lier un fichier objet et un nouveau fichier cible ensemble. De la même manière, la commande build $(CXX) $(CXXFLAGS) -c $< -o $@ compile le fichier source dans un fichier objet.
Dépendances : Les dépendances sont toujours là lorsque vous souhaitez créer un makefile. Par exemple, la cible « all » dépend de la variable « TARGET » tandis que la « TARGET » dépend de la variable « OBJS ». Parallèlement, la variable « OBJS » est dépendante du fichier source via la variable « SRCS ».
Commentaires: Des instructions compréhensibles par l'homme sont généralement utilisées pour expliquer le but de la ligne de code au cas où vous utiliseriez un fichier après une longue période. Dans le makefile suivant, nous utilisons les commentaires commençant par le signe « # » pour expliquer chaque ligne.
CXX = g++
CXXFLAGS = -std =c++ onze -Mur
CIBLE = Nouveau
SRCS = main.cpp
OBJS = $ ( SRCS :.cpp=.o )
tout : $ ( CIBLE )
$ ( CIBLE ) : $ ( OBJS )
$ ( CXX ) $ ( CXXFLAGS ) -O $ ( CIBLE ) $ ( OBJS )
% .O : % .cpp
$ ( CXX ) $ ( CXXFLAGS ) -c $ < -O $ @
faire le ménage:
rm -F $ ( CIBLE ) $ ( OBJS )
Problèmes courants et solutions
Lors de l’écriture d’un makefile, il est nécessaire de prendre en compte chaque détail mineur pour obtenir le résultat souhaité à la fin. Certains problèmes courants sont fréquemment rencontrés par les utilisateurs lors de la création d'un makefile. Dans cette section, nous discuterons de ces problèmes et suggérerons les solutions possibles comme suit :
1 : Ne pas utiliser de variables
L'utilisation des variables dans un makefile est indispensable car elle est nécessaire pour définir les compilateurs, la cible, les fichiers source, etc. Le problème le plus courant qui peut être rencontré est de ne pas utiliser de variable dans un makefile. Par conséquent, assurez-vous d'utiliser les variables essentielles telles que CXX, CXXFLAGSc (indicateurs du compilateur), TARGET, SRCS et OBJS dans l'exemple de makefile précédent.
2 : Problème de séparateur manquant
Lors de l'écriture d'un makefile, il est nécessaire de considérer très attentivement les règles d'indentation car l'utilisation d'espaces au lieu de tabulations vous mènera à un problème de « séparateur manquant » lors de l'exécution de l'instruction « make ». Par exemple, nous ajoutons l'espace au début d'une règle à la ligne 13 et supprimons la tabulation.
$ ( CIBLE ) : $ ( OBJS )$ ( CXX ) $ ( CXXFLAGS ) -O $ ( CIBLE ) $ ( OBJS )
Lors de l'exécution de la requête « make », nous obtenons une erreur « séparateur manquant » à la ligne 13 et le fichier s'arrête. Pour éviter ce problème, assurez-vous d'utiliser « tabulation » au lieu d'espaces.
faire 
Pour éviter ce problème, assurez-vous d'utiliser « tabulation » au lieu d'espaces, comme illustré dans l'image suivante :
$ ( CIBLE ) : $ ( OBJS )$ ( CXX ) $ ( CXXFLAGS ) -O $ ( CIBLE ) $ ( OBJS )
3 : Problème « Point d'entrée introuvable »
Cette erreur se produit principalement en raison du fichier source et non du makefile, comme lorsque vous manquez l'utilisation de la fonction « main() » dans le fichier de code source. Par exemple, nous remplaçons la définition de la fonction main() par une simple déclaration de fonction définie par l'utilisateur.
#includespectacle international ( ) {
char v;
std :: cout << 'Entrez une valeur : ' ;
std :: cin >> dans;
std :: cout << dans << std::endl;
retour 0 ;
}
Lors de l'exécution de l'instruction « make » sur l'invite de commande de Windows, nous rencontrons la « référence non définie à « WinMain » ». En effet, le compilateur ne trouve aucun point d’entrée pour démarrer l’exécution du fichier C++. Pour résoudre ce problème, remplacez « show » par « main ».
4 : Utilisation d'extensions incorrectes
Parfois, un utilisateur peut involontairement utiliser les mauvaises extensions pour qu'un fichier source soit utilisé dans le makefile. L’utilisation d’une mauvaise extension entraînera des erreurs d’exécution, c’est-à-dire aucune règle pour créer une cible. Nous créons un makefile pour construire l'exécutable et le fichier objet du fichier C++. Dans la septième ligne, nous fournissons le fichier source avec l'extension « c ».
CXX := g++CXXFLAGS := -std =c++ onze -Mur
CIBLE = nouveau
SRCS = main.c
OBJS = $ ( SRCS :.cpp=.o )
Tout : $ ( CIBLE )
$ ( CIBLE ) : $ ( OBJS )
L’exécution de l’instruction « make » nous conduit à l’erreur « Aucune règle pour créer la cible ‘main.c’ ». Pour éviter ce problème, assurez-vous d'utiliser la bonne extension de fichier source.
faire 
5 : Dépendances manquantes
Lors de l'écriture d'un makefile, vous devez inclure toutes les dépendances d'un fichier source pour obtenir le résultat souhaité. Par exemple, notre fichier de code C++ utilise le fichier « myheader.h » comme dépendance. Par conséquent, nous le mentionnons dans le fichier de code C++ comme suit :
#include#include 'monen-tête.h'
spectacle international ( ) {
char v;
std :: cout << 'Entrez une valeur : ' ;
std :: cin >> dans;
std :: cout << dans << std::endl;
retour 0 ;
}
Dans le makefile, nous ignorons intentionnellement l'utilisation du fichier « myheader.h » dans la règle de construction écrite à la ligne 9.
% .O : % .cpp$ ( CXX ) $ ( CXXFLAGS ) -c $ < -O $ @
Maintenant, en utilisant l'instruction « make », nous rencontrons l'erreur « Rien à faire pour « tous » ».
faire 
$ ( CXX ) $ ( CXXFLAGS ) -c $ < -O $ @
Pour éviter ce problème et exécuter le code source avec succès, mentionnez le nom de fichier « myheader.h » sur la neuvième ligne du makefile, comme illustré ci-dessous :
Conclusion
Dans ce guide, nous avons expliqué en détail la syntaxe du makefile en utilisant son contenu nécessaire comme les variables, les commandes de construction, les règles, etc. L'exemple de code est inclus pour élaborer la syntaxe plus clairement. En fin de compte, nous avons discuté de certains problèmes courants et de leurs solutions qu'un utilisateur peut rencontrer lors de la création d'un makefile.