De Linux-versie maken commando wordt gebruikt om groepen programma's en bestanden vanuit de broncode te bouwen en te onderhouden. In Linux is het een van de meest gebruikte opdrachten door de ontwikkelaars. Het helpt ontwikkelaars bij het installeren en compileren van veel hulpprogramma's vanaf de terminal. Verder verzorgt het het compilatieproces van de omvangrijke projecten. Het bespaart compilatietijd.
Het hoofdmotief van het make-commando is om een groot programma in delen te verdelen en te controleren of het opnieuw gecompileerd moet worden of niet. Ook geeft het de nodige opdrachten om ze opnieuw samen te stellen.
In deze sectie zullen we C++-programma's gebruiken, omdat de programmeertaal C++ een objectgeoriënteerde taal is, maar u kunt elke taal gebruiken die op uw computer is geïnstalleerd. Het is niet alleen beperkt tot programma's; we kunnen het ook gebruiken om andere taken te beschrijven.
Hoe werkt opdracht maken?
Het make-commando neemt doelen als argumenten. Deze argumenten worden gespecificeerd in 'Makefile.' Het makefile bevat de doelen en de bijbehorende acties die verband houden met deze doelen.
Wanneer we het make-commando uitvoeren, zoekt het naar het make-bestand en scant het om het doel te vinden en toegang te krijgen tot de afhankelijkheden ervan. Als er geen afhankelijkheden zijn opgegeven, wordt naar de afhankelijkheid gezocht en gebouwd. Het zal het hoofddoel bouwen nadat de afhankelijkheden zijn gebouwd.
Als we bijvoorbeeld slechts één bronbestand willen wijzigen en we de opdracht make uitvoeren; Dit zal dus alleen het objectbestand compileren dat is verbonden met dat bronbestand. Het bespaart veel tijd bij de uiteindelijke compilatie van het project.
Wat is Makefile?
Het make-commando roept de uitvoering van het makefile op. Het is een speciaal bestand dat de shell-opdrachten bevat die we maken om het project te onderhouden. Het makefile bevat doelen en opdrachten voor uitvoering. Het is niet toegestaan om meer dan één makefile aan te maken. Het wordt aanbevolen om er een aparte map voor te maken.
Het houdt recente bestanden bij, dus werk alleen de bestanden bij die nodig zijn. Als we een groot programma hebben met veel bronbestanden, moeten we alle afhankelijke bestanden opnieuw compileren. Het kan dus een extreem tijdrovend proces zijn.
Het makefile bevat een lijst met standaarden. Deze standaarden zijn nuttig voor het systeem om te begrijpen welke opdracht we willen uitvoeren. Deze normen bestaan uit twee delen en worden gescheiden door een nieuwe regel. De eerste regel is de afhankelijkheidslijn, en de daaropvolgende regels worden beschouwd als acties of commando's S. De opdrachten worden gescheiden door een tab op de nieuwe regel.
De afhankelijkheden specificeer de relatie van elk bestand met de bronbestanden. En de doel is een uitvoerbaar bestand en wordt gemaakt na de uitvoering van de make-opdracht.
Opties
Het make-commando biedt verschillende opties om het specifieker te maken. Enkele belangrijke opties zijn als volgt:
make -p -f/dev/null.
Laten we enkele voorbeelden van de opdracht make begrijpen. We zullen het basisgebruik van makefile zien, en verder zullen we enkele c++-programma's en een makefile maken. We zullen er enkele bewerkingen op uitvoeren om het make-commando beter te begrijpen.
java-typevariabele
Basisgebruik van make-opdracht
Laten we het basisgebruik van make command begrijpen, en het kan u helpen te begrijpen hoe het werkt.
Maak een map 'project' en wijzig de map ernaar. Overweeg de onderstaande opdrachten:
mkdir project cd project
Maak nu een 'Maakbestand' met de volgende inhoud voor het eerste programma:
say_hello: echo 'Hello World!'
Uit het bovenstaande bestand is de zeg_hello een doel dat zich gedraagt als een functie in elke programmeertaal, en echo zal worden beschouwd als een actie. Houd er rekening mee dat actie moet worden geschreven met behulp van a TAB. Het doel en de actie vormen samen een regel voor het makefile. Voer nu het make-commando als volgt uit:
Beschouw de onderstaande uitvoer:
Uit de bovenstaande uitvoer kunnen we zien dat de echobewerking zelf wordt weergegeven. Als we het echo-commando niet op de uitvoer willen weergeven, voer dan de echo uit, beginnend met '@' symbool. Om de echo te onderdrukken, werkt u de inhoud van makefile als volgt bij:
say_hello: @echo 'Hello World!'
Beschouw de onderstaande uitvoer:
Een doel kan een binair bestand zijn dat afhankelijk is van de acties.
Laten we nog een paar doelen toevoegen, zoals genereren en weergeven in het makefile. Werk het makefile als volgt bij:
say_hello: @echo 'Hello World!' generate: @echo 'Creating files' touch file-{1..5}.txt list: @echo 'Listing files' ls Als we het make-commando uitvoeren, wordt alleen het eerste doel uitgevoerd, omdat dit het standaarddoel van het make-bestand is. Beschouw de onderstaande uitvoer:
We kunnen het standaarddoel wijzigen door onderstaande inhoud op te nemen in ons makefile:
databaseontwerp in dbms
.DEFAULT_GOAL := generate
Voeg het als volgt toe aan de eerste regel van het bestand:
Het bovenstaande makefile beschouwt 'genereren' als het standaarddoel. Voer het make-commando uit en het geeft de volgende uitvoer:
De optie DEFAULT GOAL voert slechts één doel uit om meer dan één doel op te geven om alle opties te gebruiken. Om meer dan één doel op te geven, werkt u de eerste regel van het makefile als volgt bij:
all: say_hello generate
Het zal het opgegeven doel uitvoeren. Beschouw de onderstaande uitvoer:
Er is nog een andere optie waarmee we alle doelen kunnen uitvoeren. Als we alle doelen van het makefile willen uitvoeren, update het bestand dan als volgt:
.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 Het bovenstaande bestand zal alle gespecificeerde doelen uitvoeren. Voer de make-opdracht uit, overweeg de onderstaande uitvoer:
Geavanceerd gebruik van het make-commando
Laten we een C++-project maken met de bestanden main.cpp, function1.cpp, function2.cpp en een afhankelijkheidsbestand function.h.
De code van de bestanden is als volgt:
tekenreeks gesplitste java
hoofd.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; } functie1.cpp:
#include 'functions.h' int factorial(int n) { if(n!=1) { return (n * factorial(n-1)); } else return 1; } functie2.cpp:
#include #include 'functions.h' void print_hello() { std::cout << 'Hello World'; } functies.h:
void print_hello(); int factorial (int n);
Maak nu een uitvoerbaar bestand van het bovenstaande project door de onderstaande opdracht uit te voeren:
g++ main.cpp function1.cpp function2.cpp -o hello
Met de bovenstaande opdracht wordt een uitvoerbaar bestand gemaakt 'Hallo' van de bestanden main.cpp, function1.cpp en function2.cpp.
Beschouw de onderstaande uitvoer:
Als de bovenstaande uitvoer met succes wordt uitgevoerd, zal deze geen enkele uitvoer opleveren.
Laten we dezelfde taak uitvoeren met behulp van het makefile.
Maak een bestand als Maakbestand en plaats onderstaande code erin.
all: g++ main.cpp function1.cpp function2.cpp -o hello
Het trefwoord all wordt gebruikt voor doel en in de nieuwe regel wordt hetzelfde commando met een TAB geplaatst als hierboven om de bewerking te specificeren. Bewaar het bestand. Beschouw het onderstaande bestand:
Om te werken, voert u de opdracht als volgt uit:
c programma voor tweedimensionale array
make
Met de bovenstaande opdracht wordt een uitvoerbaar bestand 'hallo' gemaakt van de opgegeven bestanden. Beschouw de onderstaande uitvoer:
Laten we nog wat taken toevoegen aan Makefile. Voeg een taak toe 'compileren' als volgt:
all: compile: g++ main.cpp function1.cpp function2.cpp -o hello
Om de taak uit te voeren compileren, voer het onderstaande commando uit:
make compile
Met het bovenstaande commando wordt de compileeropdracht uitgevoerd. Beschouw de onderstaande uitvoer:
Laten we nog wat taken uitvoeren in ons makefile.
update de Makefile als volgt:
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
Uit het bovenstaande make-bestand hebben we drie objecten gemaakt als main.o, function1.o en function2.o. Verder hebben we de afhankelijkheden voor de doelen main.o, function1.o en function2.o opgegeven als respectievelijk main.cpp, function1.cpp en function2.cpp. Alle doelen zullen de gespecificeerde taken daarin uitvoeren. We hebben ook een schoon doel gespecificeerd om alle afhankelijkheden op te schonen en het uitvoerbare bestand te verwijderen.
Voer nu het make all commando uit om ons nieuwe makefile uit te voeren.
make all
Beschouw de onderstaande uitvoer:
Uit de bovenstaande uitvoer kunnen we zien dat de opdracht eerst respectievelijk main.o, function1.o en function2.o uitvoerde. Het zal het uitvoerbare bestand en het objectenbestand van de gegeven bestanden maken. Het zal het schone doel niet uitvoeren omdat we het niet in hallo hebben gespecificeerd. Beschouw de onderstaande bestanden:
Het make-commando heeft een eenvoudig werkproces. Het voerde de all-optie uit en ging naar hallo. Na de uitvoering van hallo leest het het doel in de opgegeven volgorde. Het doorzocht elk doelwit en zijn afhankelijkheid en voerde ze in de juiste volgorde uit.
Voer de opschoontaak uit om de objecten en het uitvoerbare bestand te verwijderen. Om de opschoontaak uit te voeren, voert u de opdracht als volgt uit:
make clean
Beschouw de onderstaande uitvoer:
Met de bovenstaande opdracht worden alle objecten en uitvoerbare bestanden verwijderd. Zie de onderstaande module van de map:
Uit de bovenstaande afbeelding kunnen we zien dat we onze directory hebben opgeschoond.
Variabelen in make-opdracht
We kunnen de variabelen definiëren in ons makefile. Om de variabelen te definiëren, gebruikt u de '=' exploitant. Als we bijvoorbeeld een variabele A willen maken en er een commando gcc aan willen toewijzen, wijs deze dan toe als:
cast string als int
A=g++
Gebruik het als volgt in onze makefile:
hello: hello.cpp ${A} hello.cpp -o hello Het wordt doorgegeven aan de terminal als:
g++ hello.cpp -o hello
We kunnen $(A) gebruiken in plaats van ${A}, omdat beide door het script op dezelfde manier worden behandeld.
Opmerkingen in makefile
Om een opmerking aan het makefile toe te voegen, gebruikt u de '#' symbool. Als u bijvoorbeeld een opmerking wilt toevoegen aan de compileersectie, voegt u deze toe als '# Hiermee wordt het programma gecompileerd .' Opmerkingen worden door de compiler genegeerd.