Een tekstbestand genaamd “makefile” wordt gebruikt om de opdrachten voor het maken van softwareprojecten op te slaan. Het koppelt, stelt en compileert automatisch de originele code van het project met behulp van een doelbestand. Een makefile wordt gebruikt om een object- en doelbestanden te maken op basis van een broncodebestand. Bij de uitvoering van een doelbestand wordt de code in het broncodebestand uitgevoerd en wordt uw project in een mum van tijd uitgevoerd. In deze handleiding geven we u uitgebreide details over hoe u een makefile kunt maken met behulp van variabelen en argumenten.
Een basismakefile bestaat uit drie delen:
- De variabelen zijn gelabelde entiteiten om de projectgerelateerde gegevens op te slaan.
- De regels specificeren hoe een beoogd bestand moet worden gemaakt met behulp van de afhankelijkheden in het makefile.
- De documenten waarvoor het makefile is ontworpen om te genereren, worden doelen genoemd.
Makefile-variabelen
Zoals we al hebben beschreven, wordt een gelabeld object dat kan worden gebruikt om de gegevens op te slaan, een makefile-variabele genoemd. De waarde van een variabele kan een enkel teken, een numerieke waarde of een verzameling waarden zijn. De titels van de bron- en doeldocumenten, evenals de instructies die moeten worden gebruikt om de doelen te maken, zijn allemaal gegevens over de bouwprocedure die in variabelen zijn opgeslagen.
Maak de Makefile-variabelen
Om een eenvoudige variabele in makefile te definiëren, moeten we deze beginnen met een eenvoudige titel, gevolgd door het teken “=” en de waarde die daarin wordt opgeslagen:
naam_van_variabele = waarde_van_variabele
Aan de andere kant heeft het de voorkeur en wordt aanbevolen om “:=” te proberen in plaats van “=” voor een snelle en beste uitvoering van een project.
naam_van_variabele := waarde_van_variabele
We maken bijvoorbeeld een makefile voor het C-project en declareren een “CC” -variabele. Deze variabele slaat de compiler op die uitvoerbaar is voor C, d.w.z. “gcc”, als een waarde. Op de vierde regel creëren we de variabele “CFLAGS” die wordt gebruikt om waarschuwingen te geven terwijl het compilatieproces plaatsvindt. Dit is om de optimalisatie van een project dat u uitvoert te verbeteren en om eventuele problemen te voorkomen.
Op dezelfde manier wordt de variabele “TARGET” in dit codefragment gebruikt om het nieuwe doelbestand in te stellen dat wordt gegenereerd na de uitvoering van een makefile. Bij het maken van een make-bestand is het noodzakelijk om de bron- en objectbestanden in te stellen nadat u een doelbestand hebt ingesteld. De bron- en objectbestanden kunnen ook worden gedefinieerd met behulp van de variabelen. U kunt deze variabelen een naam geven volgens uw keuze.
De SRCS-variabele stelt bijvoorbeeld een bronbestand in, terwijl de OBJS-variabele een nieuw objectbestand instelt met behulp van de SRCS-variabele.
CC = gccCFLAGS = -Muur
DOEL = Nieuw
SRCS = hoofd.c
OBJS = $ ( SRCS:.c=.o )
Gebruik de Makefile-variabelen
Na het declareren of definiëren van de makefile-variabelen is het zeer noodzakelijk om ze bruikbaar te maken in de makefile. Om een makefile-variabele te gebruiken, moet u het “$”-teken gebruiken, gevolgd door de haakjes “()” of “{}”. We gebruiken bijvoorbeeld de “$()” om het uitvoerbare doelbestand te bouwen. Nadat u deze stap heeft uitgevoerd, kan het doelbestand reageren.
alles: $ ( DOEL )
Makefile-argumenten
Telkens wanneer het makefile wordt aangeroepen, wordt er een waarde aan toegevoegd als een parameter die bekend staat als een “argument”. De argumenten worden gebruikt om de oorspronkelijke waarde van een veranderlijk bestand te overschrijven of om tijdens runtime meer details aan het makefile toe te voegen. Om de opdrachtregelargumenten door te geven aan een variabele in een makefile, moet u het trefwoord “make” gebruiken, gevolgd door een variabelenaam en een argumentwaarde die eraan wordt doorgegeven:
maken naam_van_variabele = waarde_van_variabele
Deze parameters zijn toegankelijk als gewone variabelen in het makefile, d.w.z. “New” is de argumentwaarde van de “TARGET”-variabele.
DOEL = Nieuw
Voorbeeld: maak de variabelen en argumenten
Om het gebruik van variabelen en argumenten in makefile te demonstreren, gebruiken we een eenvoudig voorbeeld in C++. We maken een nieuw C++-bestand in Notepad++ en voegen een “iostream”-header toe om de invoer en uitvoer in een voorbeeldprogramma te gebruiken.
De functie main() begint met de declaratie van een tekentypevariabele “v”. De standaarduitvoerstroom die 'cout' is, wordt gebruikt om de gebruiker weer te geven en om invoer te vragen. Daarentegen krijgt de standaardinvoerstroom 'cin' tijdens runtime een invoerwaarde van een gebruiker en slaat deze op in de variabele 'v'. De standaard “cout” wordt opnieuw gebruikt om de waarde weer te geven die door een gebruiker tijdens runtime wordt toegevoegd. De instructie “return 0” beëindigt de programma-uitvoering met succes.
#includeint. hoofd ( ) {
teken v;
std::uit << 'Voer een waarde in: ' ;
std::cin >> in;
std::uit << in << std::endl;
opbrengst 0 ;
}
Een makefile wordt op een standaardmanier gegenereerd. De allereerste variabele, “CXX”, geeft aan welke compiler moet worden gebruikt om het C++-bestand uit te voeren, d.w.z. “g++”. De volgende variabele wordt gebruikt om de vlaggen voor een compiler in te stellen om eventuele problemen te voorkomen.
Nu wordt het doelbestand met behulp van de variabele “TARGET” ingesteld op “Nieuw”. Dit is een uitvoerbaar bestand. Hierna definieert de makefile zijn bron- en objectbestand via de SRCS- en OBJS-variabelen. Om gebruik te maken van de gedeclareerde variabelen, gebruiken we het “$”-teken gevolgd door de “()”-brackers om het uitvoerbare doelbestand, het objectbestand, te bouwen en het object- en doelbestand op te schonen.
CXX = g++CXXFLAGS = -soa =c++ elf -Muur
DOEL = Nieuw
SRCS = hoofd.cpp
OBJS = $ ( SRCS:.cpp=.o )
alles: $ ( DOEL )
$ ( DOEL ) : $ ( OBJS )
$ ( CXX ) $ ( CXXVLAGS ) -O $ ( DOEL ) $ ( OBJS )
% .O: % .cpp
$ ( CXX ) $ ( CXXVLAGS ) -C $ < -O $ @
schoon:
rm -F $ ( DOEL ) $ ( OBJS )
Nadat u de C++ en het make-bestand hebt opgeslagen, start u de CMD van uw systeem, navigeert u naar de werkmap en voert u de make-instructie als volgt uit. Het genereert het objectbestand “main.o” en het doelbestand “New.exe” voor het broncodebestand. We hebben voorlopig geen enkel argument aangenomen om de instructies te maken.
maken
Als u het doelbestand uitvoert, wordt de gebruiker om invoer gevraagd. We voegen het teken “h” toe bij de eerste uitvoering en “haha” bij de tweede uitvoering. Terwijl de “v”-variabele alleen de “character”-waarden accepteert, wordt het “h”-teken uit de “haha”-reeks opgeslagen en weergegeven.
Nieuw.exe
Laten we de make-instructie uitvoeren met behulp van de opdrachtregelargumenten die worden doorgegeven aan de makefile-variabelen. We wijzigen dus de variabelewaarde “TARGET” en geven er “Test” aan door. Daarna wordt het bestand “Test.exe” gegenereerd en werkt het precies hetzelfde als het bestand “New.exe”.
maken DOEL = TestenTest.exe
Conclusie
In deze uitgebreide handleiding hebben we de inhoud van makefile één voor één doorgenomen. We hebben uitgebreid besproken hoe u de variabelen in een makefile kunt declareren, hoe u ze bruikbaar kunt maken en hoe u hun waarde tijdens runtime kunt wijzigen met behulp van argumenten. Ter ondersteuning van onze uitleg hebben we een eenvoudig voorbeeld in C++ besproken.