Linux göra kommandot används för att bygga och underhålla grupper av program och filer från källkoden. I Linux är det ett av de mest använda kommandona av utvecklarna. Det hjälper utvecklare att installera och kompilera många verktyg från terminalen. Vidare hanterar den sammanställningsprocessen för de stora projekten. Det sparar kompileringstiden.
Huvudmotivet för make-kommandot är att bestämma ett stort program i delar och kontrollera om det behöver kompileras om eller inte. Dessutom utfärdar den nödvändiga order för att kompilera dem igen.
I det här avsnittet kommer vi att använda C++-program eftersom programmeringsspråket C++ är ett objektorienterat språk, men du kan använda vilket språk som helst som är installerat på din maskin. Det är inte bara begränsat till program; vi kan använda den för att beskriva andra uppgifter också.
Hur fungerar make-kommandot?
Kommandot make tar mål som argument. Dessa argument är specificerade i 'Makefile'. Makefilen innehåller målen samt associerade åtgärder relaterade till dessa mål.
När vi kör kommandot make söker den efter makefilen och skannar den för att hitta målet och komma åt dess beroenden. Om beroenden inte anges kommer den att söka efter beroendet och bygga upp det. Det kommer att bygga huvudmålet efter att beroenden har byggts.
Till exempel, om vi bara vill ändra en källfil och vi kör kommandot make; så detta kompilerar endast objektfilen som är kopplad till den källfilen. Det kommer att spara mycket tid i den slutliga sammanställningen av projektet.
Vad är Makefile?
Make-kommandot anropar exekveringen av makefilen. Det är en speciell fil som innehåller skalkommandon som vi skapar för att underhålla projektet. Makefilen innehåller mål och kommandon för exekvering. Det är inte tillåtet att skapa mer än en makefile. Det rekommenderas att skapa en separat katalog för den.
Den håller reda på de senaste filerna, så uppdatera bara de filer som krävs. Om vi har ett stort program med många källfiler måste vi kompilera om alla beroende filer. Så det kan vara en extremt tidskrävande process.
Makefilen har en lista med standarder. Dessa standarder är användbara för att systemet ska förstå vilket kommando vi vill utföra. Dessa standarder är i två delar och åtskilda av en ny linje. Den första raden är beroendelinjen, och de efterföljande raderna betraktas som handlingar eller kommando s. Kommandona separeras med en flik på den nya raden.
De beroenden specificera relationen mellan varje fil och källfilerna. Och den mål är en körbar fil, och den skapas efter körningen av kommandot make.
alternativ
Kommandot make underlättar olika alternativ för att göra det mer specifikt. Några viktiga alternativ är följande:
gör -p -f/dev/null.
Låt oss förstå några exempel på kommandot make. Vi kommer att se den grundläggande användningen av makefile, och vidare kommer vi att skapa några c++-program och en makefil. Vi kommer att utföra några operationer på dem för att bättre förstå make-kommandot.
rad vs kolumn
Grundläggande användning av make-kommandot
Låt oss förstå den mycket grundläggande användningen av kommandot make, och det kan hjälpa dig att förstå hur det fungerar.
Skapa ett katalog 'projekt' och byt katalog till det. Tänk på följande kommandon:
mkdir project cd project
Skapa nu en 'Makefile' med följande innehåll för det första programmet:
say_hello: echo 'Hello World!'
Från filen ovan är say_hello ett mål som beter sig som en funktion i vilket programmeringsspråk som helst, och eko kommer att betraktas som en åtgärd. Man måste komma ihåg att handling bör skrivas med hjälp av en FLIK. Målet och åtgärden skapar tillsammans en regel för makefilen. Utför nu kommandot make enligt följande:
Tänk på följande utdata:
Från ovanstående utdata kan vi se att ekooperationen i sig visas. Om vi inte vill visa ekokommandot på utgången, kör ekot som börjar med '@' symbol. För att undertrycka ekot, uppdatera innehållet i makefilen enligt följande:
say_hello: @echo 'Hello World!'
Tänk på följande utdata:
java räknare
Ett mål kan vara en binär fil som beror på åtgärderna.
Låt oss lägga till några fler mål, som generera och lista i makefilen. Uppdatera makefilen enligt följande:
say_hello: @echo 'Hello World!' generate: @echo 'Creating files' touch file-{1..5}.txt list: @echo 'Listing files' ls Om vi kör kommandot make, kör det bara det första målet eftersom det är standardmålet för makefilen. Tänk på följande utdata:
Vi kan ändra standardmålet genom att inkludera nedanstående innehåll i vår makefil:
.DEFAULT_GOAL := generate
Lägg till den på den första raden i filen enligt följande:
Ovanstående makefil kommer att betrakta 'generera' som standardmålet. Utför make-kommandot, och det kommer att ge utdata enligt följande:
Alternativet STANDARDMÅL kör endast ett mål för att ange mer än ett mål för att använda alla alternativ. För att ange mer än ett mål, uppdatera den första raden i makefilen enligt följande:
all: say_hello generate
Det kommer att utföra det angivna målet. Tänk på följande utdata:
Det finns ett annat alternativ som gör att vi kan utföra alla mål. Om vi vill köra alla mål för makefilen, uppdatera filen enligt följande:
.PHONY: all say_hello generate list say_hello: @echo 'Hello World!' generate: @echo 'Creating files' touch file-{1..5}.txt list: @echo 'Listing files' ls Ovanstående fil kommer att utföra alla angivna mål. Utför make-kommandot, överväg följande utdata:
Avancerad användning av make-kommandot
Låt oss skapa ett C++-projekt med filerna main.cpp, function1.cpp, function2.cpp och en beroendefil function.h.
Koden för filerna är följande:
zip-kommando i linux
main.cpp:
#include #include 'functions.h' int main() { print_hello(); std::cout<< std::endl; std::cout<< 'The factorial of 5 is' << factorial(5) << std:: endl; return 0; } function1.cpp:
#include 'functions.h' int factorial(int n) { if(n!=1) { return (n * factorial(n-1)); } else return 1; } function2.cpp:
#include #include 'functions.h' void print_hello() { std::cout << 'Hello World'; } functions.h:
void print_hello(); int factorial (int n);
Skapa nu en körbar fil av ovanstående projekt genom att utföra kommandot nedan:
g++ main.cpp function1.cpp function2.cpp -o hello
Ovanstående kommando kommer att skapa en körbar fil 'Hallå' av filerna main.cpp, function1.cpp och function2.cpp.
Tänk på följande utdata:
Från ovanstående utdata, om den exekveras framgångsrikt, kommer den inte att ge någon utdata.
Låt oss utföra samma uppgift genom att använda makefilen.
Skapa en fil som Makefile och lägg koden nedan i den.
all: g++ main.cpp function1.cpp function2.cpp -o hello
Nyckelordet all används för target och i newline läggs samma kommando med en TAB som ovan för att specificera operationen. Spara filen. Tänk på filen nedan:
För att använda, utför kommandot enligt följande:
mysql ändra kolumntyp
make
Ovanstående kommando kommer att skapa en körbar fil 'hej' av de angivna filerna. Tänk på följande utdata:
Låt oss lägga till några fler uppgifter till Makefile. Lägg till en uppgift 'sammanställa' som följer:
all: compile: g++ main.cpp function1.cpp function2.cpp -o hello
För att utföra uppgiften sammanställa, kör följande kommando:
make compile
Ovanstående kommando kommer att utföra kompileringsuppgiften. Tänk på följande utdata:
Låt oss utföra några fler uppgifter till vår makefile.
uppdatera Makefilen enligt följande:
all: hello hello: main.o function1.o function2.o g++ main.o function1.o function2.o -o hello main.o: main.cpp g++ -c main.cpp function1.o: function1.cpp g++ -c function1.cpp function2.o: function2.cpp g++ -c function2.cpp clean: rm -rf *o hello
Från makefilen ovan har vi skapat tre objekt som main.o, function1.o och function2.o. Vidare har vi tillhandahållit beroenden för målen main.o, function1.o och function2.o som main.cpp, function1.cpp respektive function2.cpp. Alla mål kommer att utföra de specificerade uppgifterna inom den. Vi har också specificerat ett rent mål för att rensa alla beroenden och ta bort den körbara filen.
Kör nu kommandot make all för att köra vår nya makefil.
make all
Tänk på följande utdata:
Från ovanstående utdata kan vi se att kommandot först körde main.o, function1.o respektive function2.o. Det kommer att skapa den körbara filen och objektfilen för de givna filerna. Det kommer inte att köra det rena målet eftersom vi inte har specificerat det i hej. Tänk på nedanstående filer:
Make-kommandot har en enkel arbetsprocess. Den körde alternativet allt och gick till hej. Efter utförandet av hej läste den målet i den angivna sekvensen. Den sökte igenom varje mål och dess beroende och exekverade dem i sekvensen.
För att ta bort objekten och den körbara filen, utför rensningsuppgiften. För att utföra rensningsuppgiften, kör kommandot enligt följande:
make clean
Tänk på följande utdata:
Ovanstående kommando tar bort alla objekt och körbara filer. Se bilden nedan av katalogen:
Från bilden ovan kan vi se att vi har rensat vår katalog.
Variabler i make-kommandot
Vi kan definiera variablerna i vår makefile. För att definiera variablerna, använd '=' operatör. Till exempel, om vi vill skapa en variabel A och tilldela ett kommando gcc till den, tilldela den som:
osi referensmodell i nätverk
A=g++
Använd den enligt följande i vår makefile:
hello: hello.cpp ${A} hello.cpp -o hello Den skickas till terminalen som:
g++ hello.cpp -o hello
Vi kan använda $(A) istället för ${A}, eftersom båda behandlas på samma sätt av skriptet.
Kommentarer i makefile
För att lägga till en kommentar i makefilen, använd '#' symbol. Till exempel, för att lägga till en kommentar i kompileringssektionen, lägg till den som '# Detta kommer att kompilera programmet .' Kommentarer ignoreras av kompilatorn.