Meny

C ++ Makefile Tutorial: Hvordan lage og bruke Makefile i C ++

  • Hoved
  • Annen
  • C ++ Makefile Tutorial: Hvordan lage og bruke Makefile i C ++

c makefile tutorial

Prøv Instrumentet Vårt For Å Eliminere Problemer

I denne C ++ Makefile-opplæringen vil vi diskutere de viktigste aspektene av Make tool and makefile, inkludert fordelene og applikasjonene i C ++:

I et hvilket som helst C ++ - prosjekt er et av de viktige målene å forenkle byggingen av prosjektet slik at vi får alle avhengigheter og prosjektfiler på ett sted og utfører dem på en gang, slik at vi får ønsket utgang med en enkelt kommando.

venstre indre sammenføyning mot venstre ytre sammenføyning

På samme tid, når noen av prosjektfilene endres, trenger vi ikke å gå gjennom problemer med å bygge hele prosjektet igjen, dvs. når en fil eller to endres i prosjektet, bygger vi bare opp disse endrede filene og fortsetter med henrettelsen.

=> Les gjennom Easy C ++ Training Series.

Dette er nøyaktig funksjonene som adresseres av 'make' -verktøyet og 'makefiles' i C ++. I denne opplæringen vil vi diskutere alle de viktigste aspektene ved makefiles samt applikasjonene deres i C ++.

C ++ Makefile og Make Tool

Hva du vil lære:

Lag verktøy

Make er et UNIX-verktøy og brukes som et verktøy for å forenkle bygging kjørbar fra forskjellige moduler i et prosjekt. Det er forskjellige regler som er spesifisert som måloppføringer i makefilen. Make-verktøyet leser alle disse reglene og oppfører seg deretter.

For eksempel, Hvis en regel spesifiserer noen avhengighet, vil lageverktøyet inkludere den avhengigheten for kompileringsformål. Make-kommandoen brukes i makefilen til å bygge moduler eller til å rydde opp i filene.

Den generelle syntaksen for merke er:

%make target_label #target_label is a specific target in makefile

For eksempel , hvis vi vil utføre rm-kommandoer for å rydde opp i filer, skriver vi:

% make clean #here clean er en target_label spesifisert for rm-kommandoer

C ++ Makefile

En makefile er ikke annet enn en tekstfil som brukes eller refereres til av 'make' -kommandoen for å bygge målene. En makefile inneholder også informasjon som kildeniveavhengigheter for hver fil, så vel som avhengighet av byggordre.

La oss nå se den generelle strukturen til makefile.

En makefile starter vanligvis med variable erklæringer etterfulgt av et sett med måloppføringer for å bygge spesifikke mål. Disse målene kan være .o eller andre kjørbare filer i C- eller C ++- og .class-filer i Java.

Vi kan også ha et sett med måloppføringer for å utføre et sett med kommandoer spesifisert av måletiketten.

Så en generell makefile er som vist nedenfor:

# comment target: dependency1 dependency2 ... dependencyn command # (note: the in the command line is necessary for make to work)

Et enkelt eksempel på makefilen er vist nedenfor.

# a build command to build myprogram executable from myprogram.o and mylib.lib all:myprogram.o mylib.o gcc –o myprogram myprogram.o mylib.o clean: $(RM) myprogram

I den ovennevnte makefilen har vi spesifisert to måletiketter, først er etiketten 'all' for å bygge kjørbar fra myprogram- og mylib-objektfiler. Den andre målmerket 'clean' fjerner alle filene med navnet 'myprogram'.

La oss se en annen variant av makefilen.

# the compiler: gcc for C program, define as g++ for C++ CC = gcc # compiler flags: # -g - this flag adds debugging information to the executable file # -Wall - this flag is used to turn on most compiler warnings CFLAGS = -g -Wall # The build target TARGET = myprogram all: $(TARGET) $(TARGET): $(TARGET).c $(CC) $(CFLAGS) -o $(TARGET) $(TARGET).c clean: $(RM) $(TARGET)

Som vist i eksemplet ovenfor, i denne makefilen bruker vi variabelen ‘CC’ som inneholder kompilatorverdien vi bruker (GCC i dette tilfellet). En annen variabel ‘CFLAGS’ inneholder kompilatorflaggene vi skal bruke.

Den tredje variabelen “TARGET” inneholder navnet på programmet som vi trenger for å bygge den kjørbare filen.

Målefordelen med denne variasjonen av makefilen er at vi bare trenger å endre verdiene til variablene som vi har brukt når det er noen endring i kompilatoren, kompilatorflagget eller det kjørbare programnavnet.

Eksempel på Make And Makefile

Tenk på et programeksempel med følgende filer:

  • Main.cpp: Hovedførerprogram
  • Punkt.h: Topptekstfil for poengklasse
  • Point.cpp: CPP-implementeringsfil for poengklasse
  • Square.h: Topptekstfil for kvadratklasse
  • Square.cpp; CPP-implementeringsfil for kvadratklasse

Med ovennevnte .cpp- og .h-filer må vi kompilere disse filene separat for å generere .o-filer og deretter koble dem til kjørbar navn.

Så vi kompilerer disse filene hver for seg.

  • g ++ -c main.cpp: genererer main.o
  • g ++ -c point.cpp: genererer et poeng. o
  • g ++ -c kvadrat.cpp: genererer kvadrat.o

Deretter kobler vi objektfilene sammen for å generere den kjørbare hovedmenyen.

g ++ -o hoved hoved.o punkt.o kvadrat.o

Deretter må vi bestemme hvilke av filene vi må kompilere og regenerere når visse deler av programmet oppdateres. For dette vil vi ha en avhengighetsdiagram som viser forskjellige avhengigheter for hver av implementeringsfilene.

Nedenfor er avhengighetsdiagrammet for filene ovenfor.

avhengighetsdiagram

Så i avhengighetsdiagrammet ovenfor kan vi se den kjørbare 'main' ved roten. Den kjørbare 'main' består av objektfiler, nemlig. main.o, point.o, square.o som genereres ved å kompilere henholdsvis main.cpp, point.cpp og square.cpp.

Alle cpp-implementeringer bruker headerfiler som vist i diagrammet ovenfor. Som vist ovenfor refererer main.cpp til både point.h og square.h da det er driverprogram og bruker punkt- og firkantklasser.

Neste fil point.cpp referanser point.h. Den tredje filen square.cpp refererer til square.h så vel som point.h da den også trenger et punkt for å tegne firkanten.

Fra avhengighetskartet ovenfor er det klart at når en .cpp-fil eller .h-fil det refereres til av .cpp-filendringer, må vi regenerere den .o-filen. For eksempel, når main.cpp endres, må vi regenerere main.o og koble objektfilene igjen for å generere den viktigste kjørbare.

Alle de ovennevnte forklaringene vi har gitt, vil fungere greit hvis det er få filer i prosjektet. Når prosjektet er stort og filene er store og for mange, blir det vanskelig å regenerere filene gjentatte ganger.

Dermed går vi for å lage filer, og vi bruker til å lage et verktøy for å bygge prosjektet og generere den kjørbare filen.

Vi har allerede sett forskjellige deler av en make-fil. Merk at filen skal hete 'MAKEFILE' eller 'makefile' og skal plasseres i kildemappen.

Nå skal vi skrive ned makefilen for eksemplet ovenfor.

Vi vil definere variabler som holder verdiene til kompilator- og kompilatorflagg som vist nedenfor.

CC = g++ CFLAGS = -wall -g

Deretter lager vi det første målet i vår makefile, dvs. den kjørbare hoveddelen. Så vi skriver et mål med dets avhengigheter.

main: main.o point.o square.o

Dermed er kommandoen for å generere dette målet

$(CC) $(CFLAGS) –o main main.o point.o square.o

Merk: Ovennevnte kommando oversettes faktisk til g ++ -vegg –g –o hoved hoved.o punkt.o kvadrat.o

Vårt neste mål vil være å generere objektfiler, main.o, point.o, square.o

Nå for å generere main.o, vil målet skrives som:

Main.o: main.cpp point.h square.h

Kommandoen for dette målet er:

$(CC) $(CFLAGS) –c main.cpp

Neste fil point.o kan genereres ved hjelp av kommandoen nedenfor:

$(CC) $(CFLAGS) –c point.h

I kommandoen ovenfor har vi hoppet over point.cpp. Dette er fordi make allerede vet at .o-filer genereres fra .cpp-filene, og dermed bare .h (inkluderer fil) er nok.

På samme måte kan square.o genereres med følgende kommando.

$(CC) $(CFLAGS) –c square.h point.h

Hele makefilen for dette eksemplet vil se ut som vist nedenfor:

# Makefile for Writing Make Files Example # ***************************************************** # Variables to control Makefile operation CC = g++ CFLAGS = -Wall -g # **************************************************** # Targets needed to bring the executable up to date main: main.o Point.o Square.o $(CC) $(CFLAGS) -o main main.o Point.o Square.o # The main.o target can be written more simply main.o: main.cpp Point.h Square.h $(CC) $(CFLAGS) -c main.cpp Point.o: Point.h Square.o: Square.h Point.h

Dermed ser vi at vi har en komplett makefile som kompilerer tre C ++ filer og deretter genererer en kjørbar hoved fra objektfilene.

Fordeler med Makefiles

  • Når det gjelder store prosjekter, hjelper det oss å representere prosjektet på en systematisk og effektiv måte ved å bruke makefiles.
  • Makefiles gjør kildekoden mer kortfattet og enkel å lese og feilsøke.
  • Makefiles kompilerer automatisk bare de filene som endres. Derfor trenger vi ikke å regenerere hele prosjektet når noen av delene av prosjektet er modifisert.
  • Make tool lar oss kompilere flere filer samtidig, slik at alle filene kan kompileres i ett trinn.

Konklusjon

Makefiles er en velsignelse for programvareutvikling. Ved hjelp av en C ++ makefile kan vi bygge løsninger på kortere tid. Også når en del av prosjektet er modifisert, kompilerer makefilen bare og regenererer bare den delen uten å måtte regenerere hele prosjektet.

C ++ Makefile lar oss representere prosjektet systematisk og effektivt og dermed gjøre det mer lesbart og enkelt å feilsøke.

I denne C ++ Makefile-opplæringen har vi sett makefile og lage verktøy i detalj. Vi har også diskutert hvordan du skriver en makefile fra bunnen av.

=> Sjekk ut den perfekte C ++ treningsguiden her.

Anbefalt lesing

^