Linux gjøre kommandoen brukes til å bygge og vedlikeholde grupper av programmer og filer fra kildekoden. I Linux er det en av de mest brukte kommandoene av utviklerne. Den hjelper utviklere med å installere og kompilere mange verktøy fra terminalen. Videre håndterer den kompileringsprosessen til de store prosjektene. Det sparer kompileringstiden.

Hovedmotivet til make-kommandoen er å bestemme et stort program i deler og sjekke om det må rekompileres eller ikke. Den gir også de nødvendige ordrene for å rekompilere dem.

I denne delen vil vi bruke C++-programmer siden C++-programmeringsspråket er et objektorientert språk, men du kan bruke hvilket som helst språk som er installert på maskinen din. Det er ikke bare begrenset til programmer; vi kan bruke den til å beskrive andre oppgaver også.

Hvordan fungerer make-kommandoen?

Make-kommandoen tar mål som argumenter. Disse argumentene er spesifisert i 'Makefile'. Makefilen inneholder målene samt tilhørende handlinger relatert til disse målene.

Når vi utfører make-kommandoen, søker den etter makefilen og skanner den for å finne målet og få tilgang til dens avhengigheter. Hvis avhengigheter ikke er spesifisert, vil den søke etter avhengigheten og bygge den. Det vil bygge hovedmålet etter at avhengighetene er bygget.

For eksempel, hvis vi ønsker å endre bare én kildefil og vi utfører kommandoen make; så dette vil kun kompilere objektfilen som er koblet til den kildefilen. Det vil spare mye tid i den endelige sammenstillingen av prosjektet.

Hva er Makefile?

Make-kommandoen påkaller kjøringen av makefilen. Det er en spesiell fil som inneholder skallkommandoer som vi lager for å vedlikeholde prosjektet. Makefilen inneholder mål og kommandoer for utførelse. Det er ikke tillatt å lage mer enn én make-fil. Det anbefales å opprette en egen katalog for den.

Den holder styr på de siste filene, så bare oppdater de filene som er nødvendige. Hvis vi har et stort program med mange kildefiler, må vi rekompilere alle de avhengige filene. Så det kan være en ekstremt tidkrevende prosess.

Makefilen har en liste over standarder. Disse standardene er nyttige for systemet for å forstå hvilken kommando vi ønsker å utføre. Disse standardene er i to deler og atskilt med en ny linje. Den første linjen er avhengighetslinjen, og de påfølgende linjene anses som handlinger eller kommando s. Kommandoene er atskilt med en tabulator i den nye linjen.

De avhengigheter spesifiser forholdet mellom hver fil og kildefilene. Og mål er en kjørbar fil, og den opprettes etter utførelse av make-kommandoen.

Alternativer

Make-kommandoen letter ulike alternativer for å gjøre den mer spesifikk. Noen viktige alternativer er som følger:

-b, -m:Disse alternativene brukes til å ignorere kompatibiliteten for de forskjellige versjonene av make-kommandoen.-B, --alltid-lag:Disse alternativene brukes til å ubetinget lage alle mål.-C dir, --directory=dir:Disse alternativene brukes til å endre katalogen før du kjører makefilen.-d:Den brukes til å skrive ut feilsøkingsinformasjonen.--debug[=FLAGGER]:Den brukes til å skrive ut feilsøkingsinformasjonen sammen med normal behandling. Hvis vi hopper over flagget, vil det vise lignende resultater som alternativet '-d'.-e, --miljø-overstyrer:Den brukes til å gi variablene tatt fra miljøprioriteten til makefile.-f fil, --fil=fil, --makefile=FIL:Den brukes til å bruke en fil som en makefil.-i, --ignore-errors:Alternativet '-i' brukes til å ignorere alle feil i kommandoer.-I dir, --include-dir=dir:Den brukes til å spesifisere en katalog for å søke etter den angitte makefilen. Hvis vi spesifiserer de mange '-I' alternativene, vil den søke i de mange katalogene i rekkefølgen som er spesifisert.-j [jobber], --jobber[=jobber]:Den brukes til å spesifisere antall jobber som skal kjøres samtidig. Hvis vi gir mange '-j'-alternativer, vil den siste bli vurdert å kjøre. Hvis vi ikke spesifiserer antall jobber, vil det ikke begrense jobbene som kan kjøres samtidig.-k, --fortsett:Den brukes til å fortsette programmet så mye som mulig etter å ha fått en feil.-l [last], --last-gjennomsnitt[=last]:Den brukes til å spesifisere at ingen ny oppgave skal startes hvis andre oppgaver er i køen og belastningsgjennomsnittet er på minimum.-n, --just-print, --dry-run, --recon:Den brukes til å vise kommandoen som skal kjøres.-o fil, --old-fil=fil, --assume-old=fil:Den brukes for å sikre at fabrikatet ikke vil gjenskape filen selv om den er eldre enn dens avhengigheter.-O[type], --output-sync[=type]:Den brukes til å bekrefte at produksjonen av hver oppgave er satt sammen i stedet for en blandet utgang av andre oppgaver. Det er nyttig for behandling av flere jobber med alternativet '-j'.-p, --print-database:Den brukes til å skrive ut databasen som produseres etter å ha lest makefilene. Det er også nyttig å skrive ut versjonsinformasjonen når den brukes med alternativet '-v'. For å skrive ut databasen uten å prøve å lage noen filer på nytt, kjør kommandoen som følger:
lage -p -f/dev/null.-q, --spørsmål:Alternativet '-q' brukes for Spørsmålsmodus. Den vil ikke kjøre noen kommando eller skrive ut noe. Den vil bare returnere en utgangsstatus er null hvis det angitte målet allerede er synkronisert; ellers vil den vise en utgangsstatus som ikke er null.-r, --no-builtin-regler:Den brukes til å eliminere bruken av de innebygde implisitte reglene.-R, --no-builtin-variables:Det er nyttig hvis vi ikke ønsker å definere noen innebygd variabel.-s, --stille, --stille:Disse alternativene kalles Stillegående drift. Det begrenser å skrive ut kommandoene etter hvert som de utføres.-S, --ikke-fortsett, --stopp:Den brukes til å avbryte effekten av '-k, --keep-going' operasjon.-t, --touch:Den brukes til å berøre filer i stedet for å kjøre kommandoene deres.--spore:Den brukes til å spore disposisjonen til hvert mål.-v, --versjon:Den brukes til å skrive ut den installerte versjonen av make-verktøyet. Videre viser den en liste over forfattere, opphavsrett og noen merknader angående make-verktøyet.-w, --print-katalog:Den brukes til å spore en utskriftsmelding som inneholder en arbeidskatalog før og etter annen behandling. Det er nyttig å spore opp feil fra den kompliserte strukturen til rekursiv make-kommando.--no-print-katalog:Den brukes til å slå av '-w'-alternativet.-W-fil, --what-if=fil, --new-file=fil, --assume-new=fil:Disse alternativene later som om målfilen nettopp har blitt endret.--warn-undefined-variables:Dette alternativet brukes til å advare om at det refereres til en udefinert variabel.

La oss forstå noen eksempler på make-kommandoen. Vi vil se den grunnleggende bruken av makefile, og videre vil vi lage noen c++-programmer og en makefil. Vi vil utføre noen operasjoner på dem for bedre å forstå make-kommandoen.

linux snarveier

Grunnleggende bruk av make-kommandoen

La oss forstå den helt grunnleggende bruken av make-kommandoen, og det kan hjelpe deg å forstå hvordan det fungerer.

Opprett en katalog 'prosjekt' og bytt katalog til den. Tenk på kommandoene nedenfor:

 mkdir project cd project 

Lag nå en 'Makefil' ha følgende innhold for det første programmet:

 say_hello: echo 'Hello World!' 

Fra filen ovenfor er say_hello et mål som oppfører seg som en funksjon i et hvilket som helst programmeringsspråk, og ekko vil bli betraktet som en handling. Det må huskes at handling skal skrives ved å bruke en TAB. Målet og handlingen lager sammen en regel for makefilen. Nå, utfør make-kommandoen som følger:

Tenk på utgangen nedenfor:

Fra utgangen ovenfor kan vi se at selve ekkooperasjonen vises. Hvis vi ikke vil vise ekko-kommandoen på utgangen, utfør ekkoet som starter med '@' symbol. For å undertrykke ekkoet, oppdater innholdet i makefilen som følger:

 say_hello: @echo 'Hello World!' 

Tenk på utgangen nedenfor:

javafx på formørkelse

Et mål kan være en binær fil som avhenger av handlingene.

La oss legge til noen flere mål, for eksempel generere og liste i makefilen. Oppdater makefilen som følger:

 say_hello: @echo 'Hello World!' generate: @echo 'Creating files' touch file-{1..5}.txt list: @echo 'Listing files' ls 

Hvis vi utfører make-kommandoen, kjører den bare det første målet fordi det er standardmålet til makefilen. Tenk på utgangen nedenfor:

Vi kan endre standardmålet ved å inkludere innholdet nedenfor i makefilen vår:

 .DEFAULT_GOAL := generate 

Legg den til på den første linjen i filen som følger:

Makefilen ovenfor vil vurdere 'generere' som standardmålet. Utfør make-kommandoen, og den vil gi utdata som følger:

STANDARDMÅL-alternativet vil kjøre bare ett mål for å spesifisere mer enn ett mål for å bruke alle alternativene. For å spesifisere mer enn ett mål, oppdater den første linjen i makefilen som følger:

 all: say_hello generate 

Den vil utføre det angitte målet. Tenk på utgangen nedenfor:

Det er et annet alternativ som lar oss utføre alle målene. Hvis vi ønsker å kjøre alle målene til makefilen, oppdater filen som følger:

 .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 

Ovennevnte fil vil utføre alle spesifiserte mål. Utfør make-kommandoen, tenk på utgangen nedenfor:

Avansert bruk av make-kommandoen

La oss lage et C++-prosjekt med filene main.cpp, function1.cpp, function2.cpp og en avhengighetsfil function.h.

Koden til filene er som følger:

liste sorter java

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; } 

funksjon1.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'; } 

funksjoner.h:

 void print_hello(); int factorial (int n); 

Lag nå en kjørbar fil av prosjektet ovenfor ved å utføre kommandoen nedenfor:

 g++ main.cpp function1.cpp function2.cpp -o hello 

Kommandoen ovenfor vil opprette en kjørbar fil 'Hallo' av filene main.cpp, function1.cpp og function2.cpp.

Tenk på utgangen nedenfor:

Fra utgangen ovenfor, hvis den er vellykket utført, vil den ikke gi noen utgang.

La oss utføre den samme oppgaven ved å bruke makefilen.

Opprett en fil som Makefile og legg inn koden nedenfor i den.

 all: g++ main.cpp function1.cpp function2.cpp -o hello 

Nøkkelordet all brukes for mål og i nylinje settes den samme kommandoen med en TAB som ovenfor for å spesifisere operasjonen. Lagre filen. Tenk på filen nedenfor:

For å betjene, utfør kommandoen som følger:

oppdaterer java

 make 

Kommandoen ovenfor vil opprette en kjørbar fil 'hei' av de angitte filene. Tenk på utgangen nedenfor:

La oss legge til noen flere oppgaver til Makefile. Legg til en oppgave 'kompilere' følgende:

 all: compile: g++ main.cpp function1.cpp function2.cpp -o hello 

For å utføre oppgaven kompilere, kjør kommandoen nedenfor:

 make compile 

Kommandoen ovenfor vil utføre kompileringsoppgaven. Tenk på utgangen nedenfor:

La oss utføre noen flere oppgaver til makefilen vår.

oppdater Makefilen som følger:

 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 

Fra makefilen ovenfor har vi laget tre objekter som main.o, function1.o og function2.o. Videre har vi gitt avhengighetene for målene main.o, function1.o og function2.o som henholdsvis main.cpp, function1.cpp og function2.cpp. Alle målene vil utføre de angitte oppgavene i den. Vi har også spesifisert et rent mål for å rense alle avhengigheter og fjerne den kjørbare filen.

Kjør nå kommandoen make all for å kjøre vår nye makefil.

 make all 

Tenk på utgangen nedenfor:

Fra utgangen ovenfor kan vi se at kommandoen først utførte henholdsvis main.o, function1.o og function2.o. Det vil lage den kjørbare filen og objektfilen til de gitte filene. Den vil ikke utføre det rene målet fordi vi ikke har spesifisert det i hello. Tenk på filene nedenfor:

Make-kommandoen har en rett frem arbeidsprosess. Den utførte alt-alternativet og gikk til hei. Etter utførelsen av hello, leste den målet i den angitte sekvensen. Den søkte hvert mål og dets avhengighet og henrettet dem i sekvensen.

For å fjerne objektene og den kjørbare filen, utfør renseoppgaven. For å utføre renseoppgaven, kjør kommandoen som følger:

 make clean 

Tenk på utgangen nedenfor:

Kommandoen ovenfor vil fjerne alle objekter og kjørbare filer. Se snappet nedenfor av katalogen:

Fra bildet ovenfor kan vi se at vi har renset katalogen vår.

Variabler i make-kommandoen

Vi kan definere variablene i makefilen vår. For å definere variablene, bruk '=' operatør. For eksempel, hvis vi ønsker å lage en variabel A og tilordne en kommando gcc til den, tilordne den som:

filmnettsteder som ligner på 123movies

 A=g++ 

Bruk den som følger i makefilen vår:

 hello: hello.cpp ${A} hello.cpp -o hello 

Det sendes til terminalen som:

 g++ hello.cpp -o hello 

Vi kan bruke $(A) i stedet for ${A}, siden begge behandles likt av skriptet.

Kommentarer i makefile

For å legge til en kommentar i makefilen, bruk '#' symbol. For å legge til en kommentar i kompileringsdelen, legg den til som '# Dette vil kompilere programmet .' Kommentarer ignoreres av kompilatoren.