Comment utiliser les outils de construction automatisés Linux make et Makefile

1. Le rôle de make et Makefile

Les fichiers sources d'un projet ne sont pas comptés. Ils sont placés dans plusieurs répertoires selon le type, la fonction et le module. Le makefile définit une série de règles pour spécifier quels fichiers doivent être. compilé en premier, quels fichiers doivent être post-compilés, quels fichiers doivent être recompilés et des opérations fonctionnelles encore plus complexes peuvent être effectuées.

Ainsi, l'avantage apporté par makefile est - "compilation automatisée". Une fois écrite, une seule commande make est nécessaire et l'ensemble du projet est entièrement compilé automatiquement, ce qui améliore considérablement l'efficacité du développement logiciel.

make est un outil de commande qui interprète les instructions du makefile. De manière générale, la plupart des IDE ont cette commande, comme : le make de Delphi, le nmake de Visual C++ et le make de GNU sous Linux. On voit que makefile est devenu une méthode de compilation en ingénierie. make est une commande et makefile est un fichier Lorsqu'ils sont utilisés ensemble, vous pouvez terminer la construction automatisée du projet.

2. Utilisation de make et Makefile

Avant de comprendre les dépendances et les méthodes de dépendance, écrivons un petit programme en langage C.

Nous avons créé un fichier make.c et écrit un code hello make.

Ensuite, créons un autre Makefile (makefile est également possible, mais non recommandé).

Ensuite, nous éditons le Makefile et écrivons le code suivant :

Ensuite, nous sauvegardons et quittons.

Ensuite, nous pouvons exécuter la commande make. S'il indique que make n'existe pas, c'est parce qu'il n'est pas installé. Vous pouvez passer à l'installation en tant que root. Code d'installation : yum install make ou sudo install make. yum install make 或者 sudo install make。

正常执行make后会出现如下显示。

然后我们ll来查看当前目录下的文件。

我们可以发现多了一个可执行程序make。那我们运行用 ./make 运行试试。

我们会发现这个可执行程序输出make。

这就是我们的自动化构建工具，只需要在Makefile里面配置一下。往后直接输入make即可编译代码。那我们再输入一次make试试。

提示我们 make程序是最新的。 也就是说，如果你没有修改或者更新程序的话。 那么则不会为你编译，因为你程序都没动呀，编译它干嘛。

那么此时我们回过来分析一下 Makefile里面写的代码。

首先我们把它分为三部分

make

make.c

gcc make.c -o make -std=c99

这三者的关系就是， make 是依赖于 make.c 产生的。 它们两者有依赖关系 ， 而gcc make.c -o make -std=c99则是 make 依赖于 make.c的方法，叫依赖方法。

什么是依赖关系和依赖方法?

打个比方。

月底了，你的生活费用光了。 这个时候你给你爸爸打电话，和他说:“爸，月底了。我没钱了。"。此时你的爸爸就知道了，会给你打生活费。 这里面，你和你的父亲是父子关系，所以你依赖于你的父亲，你们之间有依赖关系。而你的父亲给你生活费，这是你依赖父亲的一种方式，所以这就是依赖方法。如果此时你给你室友的父亲打电话要生活费，他会直接让你滚。因为你们根本不构成依赖关系，不构成依赖关系就没有依赖方法。

所以我的程序也是一样的。 make 是生成的可执行程序。 而它依赖于make.c，因为它是从 make.c编译来的。而依赖方法则是 执行 gcc make.c -o make -std=c99

Après avoir exécuté make normalement, l'affichage suivant apparaîtra.

Ensuite, nous allons afficher les fichiers dans le répertoire courant.

Nous pouvons constater qu'il existe un programme exécutable supplémentaire make. Essayons ensuite d'exécuter ./make.

• 

  🎜 Nous trouverons ce programme exécutable en sortie. 🎜🎜Il s'agit de notre outil de build automatisé, il vous suffit de le configurer dans le Makefile. Tapez ensuite make directement pour compiler le code. Essayons ensuite de taper à nouveau make. 🎜🎜🎜🎜 Invitez-nous Le programme make est à jour. Autrement dit, si vous n'avez pas modifié ou mis à jour le programme. Ensuite, il ne sera pas compilé pour vous, car votre programme n’a pas été touché, alors pourquoi le compiler ? 🎜🎜Maintenant, revenons en arrière et analysons le code écrit dans le Makefile. 🎜🎜🎜🎜 Nous le divisons d'abord en trois parties🎜🎜make🎜🎜make.c🎜🎜gcc make.c -o make -std=c99🎜 🎜 La relation entre les trois est que make dépend de make.c. Les deux ont une 🎜relation de dépendance🎜, et gcc make.c -o make -std=c99 est une méthode de make qui dépend de make.c, qui est appelée une 🎜méthode de dépendance🎜 . 🎜🎜🎜Que sont les dépendances et les méthodes de dépendance ?🎜🎜🎜Une analogie. 🎜🎜C'est la fin du mois et vos frais de subsistance ont disparu. A ce moment-là, tu appelles ton papa et tu lui dis : "Papa, c'est la fin du mois. Je n'ai pas d'argent." Votre père le saura à ce moment-là et vous paiera les frais de subsistance. Ici, vous et votre père avez une relation père-fils, vous êtes donc dépendant de votre père, et il y a une 🎜relation de dépendance🎜 entre vous. Et ton père te donne des frais de subsistance, ce qui est une façon pour toi de compter sur ton père, c'est donc la 🎜méthode de la dépendance🎜. Si vous appelez le père de votre colocataire pour lui demander les frais de subsistance à ce moment-là, il vous dira de sortir. Parce que vous n'avez pas du tout de relation de dépendance. Si vous n'avez pas de relation de dépendance, il n'y aura pas de méthode de dépendance. 🎜🎜🎜🎜 Donc, la procédure est la même. make est le programme exécutable généré. Et cela dépend de make.c car il est compilé à partir de make.c. La méthode de dépendance consiste à exécuter la commande gcc make.c -o make -std=c99. 🎜🎜🎜Le principe de dépendance🎜🎜🎜🎜🎜🎜make cherchera un fichier nommé "Makefile" ou "makefile" dans le répertoire courant. 🎜

• S'il est trouvé, il trouvera le premier fichier cible (cible) dans le fichier. Dans l'exemple ci-dessus, il trouvera le fichier "hello" et utilisera ce fichier comme fichier cible final.

• Si le fichier hello n'existe pas, ou si l'heure de modification du fichier test.o suivant dont dépend hello est plus récente que le fichier test (vous pouvez utiliser touch pour tester), alors il exécutera la commande définie plus tard pour générer le fichier de test.

• Si le fichier test.o dont dépend le test n'existe pas, alors make recherchera la dépendance du fichier test.o dans le fichier actuel. S'il est trouvé, il générera le fichier test.o en fonction de cela. règle. (C'est un peu comme un processus de pile)

• Bien sûr, votre fichier C et votre fichier H existent, donc make générera le fichier test.o, puis utilisera le fichier test.o pour déclarer la tâche ultime de make , Il suffit également d'exécuter le test du fichier.

• Il s'agit de la dépendance de l'ensemble du make. Make recherchera les dépendances de fichiers couche par couche jusqu'à ce que le premier fichier cible soit finalement compilé.

• Pendant le processus de recherche, si une erreur se produit, par exemple si le dernier fichier dépendant est introuvable, make se fermera directement et signalera une erreur. En cas d'erreur dans la commande définie ou si la compilation échoue, make Ignore. ça du tout.

• make ne se soucie que des dépendances de fichiers, c'est-à-dire que si le fichier après les deux points n'est toujours pas là après avoir trouvé les dépendances, alors je suis désolé, je ne travaillerai pas.

Nettoyage

Lorsque nous écrivons habituellement du code, nous devons souvent compiler et exécuter le code à plusieurs reprises.

Avant de recompiler la prochaine fois, vous devez nettoyer le programme exécutable généré la dernière fois. Cependant, vous pourriez commettre une erreur lors du nettoyage et supprimer accidentellement le fichier source, ce qui pourrait à nouveau provoquer des problèmes.

Alors avons-nous une solution ? La réponse est bien sûr.

Continuons à éditer le Makefile.

Nous avons ajouté

.PHONY:clean

clean:

	rm -f make

à celui d'origine Alors, que fait PHONY ?

.PHONY modifie une pseudo cible, et la pseudo cible est toujours exécutée. clean est une commande make auto-définie. La méthode d'utilisation est make clean.PHONY修饰的是一个伪目标的，伪目标总是被执行的。clean是自己定义的一条make指令，使用方法为 make clean

那我们来试试吧这条指令

我们可以看到它被清理了，那为什么说伪目标它总是被执行的呢？我们多次执行它看看。

我们可以一直执行它，那么我们多次执行make呢？

我们会发现，make执行了一次，就无法执行了，因为没有被.PHONY修饰。那么我用.PHONY修饰它再试试。

然后我们保存退出，多次执行make

我们就可以看到它被多次执行了。但我觉得没有这个必要，因为文件没有被修改的话。重新编译没有意义，所以自动化编译不建议加上.PHONY

我们保存退出，多次执行make

我们就可以看到它被多次执行了。但我觉得没有这个必要，因为文件没有被修改的话。重新编译没有意义，所以自动化编译不建议加上.PHONY

Essayons cette commande🎜🎜🎜🎜On voit qu'il a été nettoyé, alors pourquoi la pseudo cible est-elle toujours exécutée ? Tissu de laine ? Exécutons-le plusieurs fois et voyons. 🎜🎜🎜🎜 Nous pouvons continuer à l'exécuter, et si nous exécutons make plusieurs fois ? 🎜🎜🎜🎜 Nous le ferons Il a été constaté qu'après que make ait été exécuté une fois, il ne pouvait pas être exécuté car il n'avait pas été modifié par .PHONY. Ensuite je le modifie avec .PHONY et je réessaye. 🎜🎜🎜🎜 Ensuite, nous enregistrons et quittons, exécutons make🎜🎜🎜🎜On voit qu'il est exécuté plusieurs fois. Mais je ne pense pas que ce soit nécessaire, car le fichier n'a pas été modifié. La recompilation n'a aucun sens, il n'est donc pas recommandé d'ajouter .PHONY à la compilation automatisée🎜🎜Nous enregistrons et quittons, et exécutons make🎜🎜🎜🎜Nous pouvons voir que c'est exécuté plusieurs fois. Mais je ne pense pas que ce soit nécessaire, car le fichier n'a pas été modifié. Cela ne sert à rien de recompiler, il n'est donc pas recommandé d'ajouter .PHONY pour une compilation automatisée🎜

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!