[Linux] Outil de construction d'automatisation de projet Linux—make/Makefile

1. Qu'est-ce que make/Makefile

Makefile

Sous Windows, après avoir utilisé des ides tels que VS et VS Code pour écrire des programmes C/C++ pour implémenter un projet, ces ides nous aideront à traiter et à générer des fichiers exécutables pour ces programmes.

Mais sous Linux, si nous avons besoin d'implémenter ce projet par nous-mêmes via des instructions, les fichiers sources d'un projet ne sont pas comptés, et ils sont placés dans plusieurs répertoires selon le type, la fonction et le module. Il est très peu pratique de les connecter un par un. pratique.

Et Linux fournit un outil de compilation automatique de projet - Makefile, qui définit une série de règles à spécifier, quels fichiers doivent être compilés en premier, quels fichiers doivent être compilés plus tard, quels fichiers doivent être recompilés, et même effectuer des opérations fonctionnelles plus complexes. Une fois le Makefile écrit, 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.

Par conséquent, que vous puissiez écrire un Makefile ou non, cela montre de côté si une personne a la capacité de réaliser des projets à grande échelle.

Fabriquer

make est un outil de commande qui explique les instructions dans le makefile. De manière générale, la plupart des IDE ont cette commande, comme : make en Delphi, nmake en Visual C++, make en GNU sous Linux. On peut voir que Makefile est devenu une méthode de compilation en ingénierie.

Comme suit : Nous utilisons Makefile pour générer le fichier exécutable du fichier en langage C hello.c.

Lorsque l'environnement de développement d'un programmeur c n'est qu'un seul Linux connecté via le terminal, Makefile est presque le seul choix pour construire des projets complexes, et il est également si le projet a un projet.Un tournant de la mondialisation, dans l'ensemble, pour apprendre Linux, Makefile est assez important.

Résumer:

Sous Linux, make est une commande, et Makefile est un fichier, les deux se complètent et réalisent conjointement la "construction automatisée" du projet.

2. Logique Makefile

1. Dépendance simple

Makefile se compose principalement de et 依赖关系, 依赖方法tandis que les dépendances consistent 目标en依赖

Le format le plus classique est le suivant :

target:dependence  #依赖关系
  command          #依赖方法

Parmi eux, targetse trouve la cible à générer, et dependenceest de générer les dépendances requises par la cible.Les deux forment une relation de dépendance, et commandil est de générer les commandes à exécuter par la cible.

Remarquer:

• Il peut y avoir plusieurs ou aucune des dépendances dans les dépendances
• Makefile peut également être écrit en tant que makefile, qui ne peut pas être reconnu par d'autres marques. (Cet article est Makefile)
• Chaque dépendance doit commencer par la touche [Tab]

Prenez notre code de test ci-dessus comme exemple :

Afin de générer le fichier hello, vous devez dépendre du fichier hello.c, et enfin générer le fichier cible hello via les dépendances suivantes.

2. Dépendances complexes

Dans le cas de test ci-dessus, il s'agit d'un fichier dans ce répertoire. Si le fichier qu'il contient 依赖关系n'est pas dans ce répertoire , le système recherchera automatiquement le même fichier dans le Makefile lors de sa génération. Si le fichier trouvé n'est toujours pas dans ce répertoire Ensuite, répétez l'opération ci-dessus. (Le système utilise le résultat de la pile pour fonctionner)依赖依赖关系依赖目标文件其它目标文件

Modifions d'abord le cas de test ci-dessus comme suit :

• Générer un fichier hello et dépendre du fichier hello.o
• Générer le fichier hello.o et dépendre du fichier hello.s
• Générer le fichier hello.s et dépendre du fichier hello.i
• Générer le fichier hello.i et dépendre du fichier hello.c
• Le fichier hello.c se trouve dans ce répertoire, utilisez-le directement

Lorsque nous générons un fichier hello, les trois autres sont générés 目标文件et stockés dans ce répertoire

Les dépendances sont les suivantes :

• Les changements dans d'autres 目标文件emplacements n'affecteront pas target1la génération, c'est 依赖la même recherche sous le fichier Makefile 目标文件, et n'a rien à voir avec le fichier cible 位置. Utilisez toujours la méthode ci-dessus pour générer des fichiers.

3. make commande

1. Utilisation de la marque

Sous Linux, après avoir entré la commande make, le système recherchera le Makefile dans le répertoire courant, exécutera la première dépendance et la méthode dépendante dans le fichier après l'avoir trouvée, imprimera la méthode dépendante à l'écran et générera le fichier cible.

Nous modifions le cas de test Makefile ci-dessus comme suit :

Générez deux ensembles de dépendances. (le nettoyage sera discuté ci-dessous)

Comme suit pour nous de passer le test de fabrication

Lorsque nous voulons supprimer d'autres fichiers cibles dans le Makefile généré, nous devons spécifier le fichier cible

make target1 target2   #make后可以有多个target目标文件

1. cibler

2. faire cible1 cible2

2. nettoyer

Dans un projet, certains fichiers inutiles sont toujours nettoyés et nous les utilisons souvent cleancomme fichiers cibles pour le nettoyage du projet.

Étant donné que les fichiers de nettoyage n'ont pas besoin de dépendre d'autres fichiers, clean n'a pas de dépendances.

Lorsque clean n'est pas le premier fichier cible du Makefile, nous devons ajouter clean après make pour le compiler, tout comme le test précédent.

3. Faux objectif

Utilisez .PHONYdes cibles modifiées, appelées pseudo-cibles, au format suivant

.PHONY:target

Fonction : Rendre le fichier toujours exécutable

Lorsque nous utilisons make plusieurs fois pour générer le même fichier cible, la compilation peut réussir pour la première fois, mais après cela, elle ne peut pas passer, et les résultats suivants seront donnés :

A ce moment, nous pouvons utiliser .PHONYpour modifier le fichier cible hello pour en faire une pseudo cible, qui peut toujours être compilée

Remarque : Non seulement .PHONYil peut toujours être compilé après l'utilisation de la modification, mais le fichier objet propre peut également être toujours compilé, comme suit :

4. Comment make détermine-t-il s'il faut compiler

Nous avons testé ci-dessus, s'il n'est pas utilisé .PHONY, make ne peut être utilisé qu'une seule fois, puis il ne peut pas être compilé, alors comment make détermine-t-il s'il faut compiler ?

Lorsque nous avons fini d'écrire un projet et que nous voulons l'implémenter (généralement, le projet est très volumineux, pas le point que nous avons testé), cela nous fera perdre beaucoup de temps et de performances. Nous ne pouvons pas le laisser s'exécuter sans scrupule, uniquement lorsque Après la source fichier est modifié, le projet peut être réimplémenté pour générer un fichier exécutable.

faire des juges s'il faut recompiler, sur la base de la comparaison de l'heure de modification du fichier source et du fichier cible.

1. Lorsque le temps de modification du fichier source est inférieur à celui du fichier cible, ne pas compiler
2. Compiler lorsque l'heure de modification du fichier source est supérieure à celle du fichier cible

Sous Linux, chaque fichier a trois temps, comme suit :

• Heure d'accès (Access): l'heure du dernier accès au contenu du fichier, tel que cat, vim, less;
• Heure de modification (Modify) : l'heure à laquelle le contenu du fichier a été modifié pour la dernière fois, comme nano, vim ;
• Heure de changement (Modifier) ​​: L'heure à laquelle les attributs du fichier ont été modifiés récemment, y compris le nom du fichier, la taille, le contenu, les autorisations, le propriétaire, le groupe, etc., comme nano/vim (changements de taille de fichier),

Nous pouvons statvisualiser ces trois temps du fichier via des commandes

Impact du temps d'accès

Pourquoi est-il nécessaire de comparer le temps de modification de deux nombres pour juger si make compile à plusieurs reprises ?

Sous Linux, l'accès à un fichier peut se faire par cat、lessdes instructions, et le fichier accédé par ces deux instructions ne modifiera pas son propre temps d'accès, pour les deux raisons suivantes :

1. Sous Linux, l'accès aux fichiers est une opération très fréquente, et modifier le temps d'accès aux fichiers nécessite à chaque fois des opérations d'E/S. Si le temps d'accès est modifié à chaque fois, cela augmentera la charge du système.
2. Le fait qu'un fichier puisse être lu est déterminé par l'autorisation du fichier. Étant donné que le fichier est lisible, cela signifie que le propriétaire et le groupe du fichier ne vous recommandent pas de le lire et qu'il n'est pas nécessaire de modifier l'heure d'accès à chaque fois. temps.

Par conséquent, le temps d'accès Linux change dans les deux cas suivants :

1. Il sera mis à jour lorsque les visites s'accumuleront un certain nombre de fois ou s'accumuleront pendant une période de temps
2. Lorsque l'heure de modification du fichier change, elle change en conséquence
   

• L'image ci-dessus utilise uniquement le fichier d'enregistrement vim et ne l'a pas modifié, mais l'heure de modification changera également de temps en temps

Pour résumer : Si vous voulez juger si un fichier a été modifié, vous pouvez juger si son heure de modification a changé.

Remarque : L'heure de modification change et le fichier ne change pas nécessairement

Effet du temps de modification

Lorsque l'heure de modification du fichier source change, cela signifie que le fichier source a été modifié. À ce moment, utilisez make pour compiler à nouveau. Nous utilisons d'abord vim pour mettre à jour l'heure de modification afin de juger


que nous utilisons la commande touch pour mettre à jour tout le temps du fichier source (fichier tactile : fichier Il n'y a pas de création de fichier, fichier existe pour mettre à jour le fichier tout le temps), pour juger si make est exécuté n'a rien à voir avec s'il faut modifier le contenu du fichier source .

À partir des connaissances ci-dessus, nous pouvons conclure que le fait que make soit compilé est lié à l'heure de modification du fichier source , alors nous pouvons savoir ,PHONYque si le fichier cible est compilé n'est pas jugé en fonction de l'heure de modification, afin d'obtenir l'effet d'être toujours compilé.