En textfil som kallas 'makefile' används för att lagra kommandon för att skapa programvaruprojekt. Den länkar, ställer in och kompilerar automatiskt projektets ursprungliga kod med hjälp av en målfil. En makefile används för att skapa ett objekt och målfiler från en källkodsfil. När en målfil körs kommer koden i källkodsfilen att köras och ditt projekt körs på nolltid. I den här guiden kommer vi att ge dig omfattande detaljer om hur du gör en makefil med hjälp av variabler och argument.
En grundläggande makefil består av tre delar:
- Variablerna är märkta enheter för att lagra projektrelaterade data.
- Reglerna anger hur man skapar en avsedd fil med hjälp av beroenden i makefilen.
- Dokumenten som makefilen är designad för att generera kallas mål.
Makefile-variabler
Som vi redan beskrivit kallas ett märkt objekt som kan användas för att lagra data som en makefile-variabel. En variabels värde kan vara ett enstaka tecken, ett numeriskt värde eller en samling värden. Titlarna på käll- och måldokumenten, såväl som instruktionerna som ska användas för att skapa målen, är alla data om byggproceduren som lagras i variabler.
Skapa Makefile-variablerna
För att definiera en enkel variabel i makefile bör vi börja den med en enkel titel följt av tecknet '=' och värdet som kommer att lagras i den:
name_of_variable = value_of_variable
Å andra sidan är det att föredra och rekommendera att prova “:=” istället för “=” för ett snabbt och bäst resultat av ett projekt.
namn_på_variabel := variabel_värde
Till exempel skapar vi en makefile för C-projektet och deklarerar en 'CC'-variabel. Denna variabel lagrar kompilatorn som är körbar för C, det vill säga 'gcc', som ett värde. På den fjärde raden skapar vi variabeln 'CFLAGS' som används för att ge varningar medan kompileringsprocessen pågår. Detta för att förbättra optimeringen av ett projekt som du driver och för att undvika problem.
Precis så används variabeln 'TARGET' i detta kodavsnitt för att ställa in den nya målfilen som genereras efter exekvering av en makefil. När du skapar en make-fil är det nödvändigt att ställa in käll- och objektfilerna efter att du har ställt in en målfil. Käll- och objektfilerna kan också definieras med hjälp av variablerna. Du kan namnge dessa variabler enligt ditt val.
Till exempel ställer SRCS-variabeln in en källfil medan OBJS-variabeln ställer in en ny objektfil med SRCS-variabeln.
CC = gccCFLAGS = -Vägg
MÅL = Nytt
SRCS = main.c
OBJS = $ ( SRCS:.c=.o )
Använd Makefile-variablerna
Efter att ha deklarerat eller definierat makefile-variablerna är det mycket nödvändigt att göra dem användbara i makefilen. För att använda en makefile-variabel måste du använda '$'-tecknet följt av '()' eller '{}' parenteser. Till exempel använder vi '$()' för att bygga den körbara målfilen. Efter att ha gjort detta steg kommer målfilen att kunna svara.
alla: $ ( MÅL )
Makefile-argument
Närhelst makefilen anropas, tillförs den ett värde som en parameter som kallas ett 'argument'. Argumenten används för att åsidosätta det ursprungliga värdet av en mutable eller för att lägga till fler detaljer till makefilen vid körning. För att skicka kommandoradsargumenten till en variabel i en makefil, bör du använda nyckelordet 'make' följt av ett variabelnamn och ett argumentvärde som skickas till det:
göra name_of_variable = value_of_variable
Dessa parametrar kan nås som vanliga variabler i makefilen, d.v.s. 'New' är argumentvärdet för 'TARGET'-variabeln.
MÅL = Nytt
Exempel: Gör variablerna och argumenten
För att demonstrera användningen av variabler och argument i makefile använder vi ett enkelt exempel i C++. Vi skapar en ny C++-fil i Notepad++ och lägger till en 'iostream'-header för att använda indata och utdata i ett exempelprogram.
Main()-funktionen börjar med deklarationen av en teckentypsvariabel 'v'. Standardutgångsströmmen som är 'cout' används för att visa och be användaren om input. Däremot får standardinmatningsströmmen 'cin' ett indatavärde från en användare vid körning och sparar det till variabeln 'v'. Standarden 'cout' används återigen för att visa värdet som läggs till av en användare vid körning. 'return 0'-satsen avslutar programexekveringen framgångsrikt.
#includeint main ( ) {
röding v;
std::cout << 'Ange ett värde:' ;
std::cin >> i;
std::cout << i << std::endl;
lämna tillbaka 0 ;
}
En makefil genereras på ett standardsätt. Den allra första variabeln, 'CXX', förklarar att kompilatorn ska användas för att köra C++-filen, dvs. 'g++'. Nästa variabel används för att ställa in flaggorna för en kompilator för att undvika problem.
Nu ställs målfilen med variabeln 'MÅL' till 'Ny'. Detta är en körbar fil. Efter detta definierar makefilen sin käll- och objektfil via SRCS- och OBJS-variablerna. För att använda de deklarerade variablerna använder vi '$'-tecknet följt av '()'-brickorna för att bygga målkörbaren, objektfilen och rensa objektet och målfilen.
CXX = g++CXXFLAGGAR = -std =c++ elva -Vägg
MÅL = Nytt
SRCS = main.cpp
OBJS = $ ( SRCS:.cpp=.o )
alla: $ ( MÅL )
$ ( MÅL ) : $ ( OBJS )
$ ( CXX ) $ ( CXXFLAGGAR ) -O $ ( MÅL ) $ ( OBJS )
% .O: % .cpp
$ ( CXX ) $ ( CXXFLAGGAR ) -c $ < -O $ @
rena:
rm -f $ ( MÅL ) $ ( OBJS )
Efter att ha sparat C++ och dess make-fil, starta CMD för ditt system, navigera in i arbetskatalogen och kör make-instruktionen enligt följande. Den genererar objektfilen 'main.o' och målfilen 'New.exe' för källkodsfilen. Vi har inte passerat något argument för att göra instruktionerna för nu.
göra
Att köra målfilen kommer att be användaren om input. Vi lägger till 'h'-tecknet vid den första exekveringen och 'haha' vid den andra exekveringen. Medan variabeln 'v' bara accepterar 'tecken'-värdena, lagras och visas 'h'-tecknet från 'haha'-strängen.
New.exe
Låt oss köra make-instruktionen med hjälp av kommandoradsargumenten som skickas till makefil-variablerna. Så vi ändrar variabelvärdet 'TARGET' och skickar 'Test' till det. Därefter genereras filen 'Test.exe' och fungerar precis som filen 'New.exe'.
göra MÅL =TestTest.exe
Slutsats
Inom denna omfattande guide har vi gått igenom innehållet i makefile en efter en. Vi utvecklade hur man deklarerar variablerna i en makefil, hur man gör dem användbara och hur man ändrar deras värde vid körning med hjälp av argument. Som stöd för vår förklaring diskuterade vi ett enkelt exempel i C++.