Meny

C ++ Makefile Tutorial: Hur man skapar och använder Makefile i C ++

  • Huvud
  • Övrig
  • C ++ Makefile Tutorial: Hur man skapar och använder Makefile i C ++

c makefile tutorial

Prova Vårt Instrument För Att Eliminera Problem

I denna C ++ Makefile-handledning kommer vi att diskutera de viktigaste aspekterna av Make tool och makefile inklusive dess fördelar och applikationer i C ++:

I alla C ++ - projekt är ett av de viktiga målen att förenkla byggandet av projektet så att vi får alla beroenden och projektfilerna på ett ställe och kör dem på en gång så att vi får önskad utdata med ett enda kommando.

vilken av följande åtgärder inte kunde tillämpas på pekare

Samtidigt, när någon av projektfilerna ändras, behöver vi inte gå igenom besväret med att bygga upp hela projektet igen, dvs när en fil eller två ändras i projektet, bygger vi bara om de ändrade filerna och fortsätter sedan med utförandet.

=> Läs igenom Easy C ++ Training Series.

Detta är exakt de funktioner som behandlas av 'make' -verktyget och 'makefiles' i C ++. I den här guiden kommer vi att diskutera alla viktiga aspekter av makefiles samt deras applikationer i C ++.

C ++ Makefile och Make Tool

Vad du kommer att lära dig:

Skapa verktyg

Make är ett UNIX-verktyg och används som ett verktyg för att förenkla byggbar körning från olika moduler i ett projekt. Det finns olika regler som anges som målposter i makefilen. Make-verktyget läser alla dessa regler och beter sig därefter.

Till exempel, om en regel anger något beroende, kommer verktyget make att inkludera det beroendet för kompileringsändamål. Kommandot make används i makefilen för att bygga moduler eller för att rensa filerna.

Den allmänna syntaxen för fabrikat är:

%make target_label #target_label is a specific target in makefile

Till exempel , om vi vill utföra rm-kommandon för att städa upp filer, skriver vi:

% make clean #here clean är en target_label specificerad för rm-kommandon

C++ Makefile

En makefile är inget annat än en textfil som används eller hänvisas till med 'make' -kommandot för att bygga målen. En makefile innehåller också information som beroenden på källnivå för varje fil samt beroendeförhållandena.

Låt oss nu se den allmänna strukturen för makefile.

En makefile börjar vanligtvis med variabla deklarationer följt av en uppsättning målposter för att bygga specifika mål. Dessa mål kan vara .o eller andra körbara filer i C- eller C ++- och .class-filer i Java.

Vi kan också ha en uppsättning målposter för att utföra en uppsättning kommandon som anges av måletiketten.

Så en generell makefile är som visas nedan:

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

Ett enkelt exempel på makefilen visas nedan.

# 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 ovanstående makefile har vi angett två måletiketter, först är etiketten 'all' för att bygga körbar från myprogram- och mylib-objektfiler. Den andra måletiketten 'clean' tar bort alla filer med namnet 'myprogram'.

Låt oss se en annan 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 visas i exemplet ovan använder vi i denna makefile variabeln 'CC' som innehåller kompilatorvärdet som vi använder (GCC i det här fallet). En annan variabel 'CFLAGS' innehåller kompilatorflaggorna som vi kommer att använda.

Den tredje variabeln ”TARGET” innehåller namnet på det program som vi behöver bygga den körbara filen för.

Måttfördelen med denna variation av makefilen är att vi bara behöver ändra värdena på de variabler som vi har använt när det finns någon förändring i kompilatorn, kompilatorflaggorna eller det körbara programnamnet.

Exempel på Make And Makefile

Tänk på ett programexempel med följande filer:

  • Main.cpp: Huvudförarprogrammet
  • Point.h: Rubrikfil för poängklass
  • Point.cpp: CPP-implementeringsfil för poängklass
  • Square.h: Rubrikfil för fyrkantig klass
  • Square.cpp; CPP-implementeringsfil för fyrkantig klass

Med ovan angivna .cpp- och .h-filer måste vi kompilera dessa filer separat för att generera .o-filer och sedan länka dem till körbar namngiven main.

Så här sammanställer vi dessa filer separat.

  • g ++ -c main.cpp: genererar main.o
  • g ++ -c point.cpp: genererar en punkt. o
  • g ++ -c kvadrat.cpp: genererar kvadrat.o

Därefter länkar vi objektfilerna för att generera den körbara main.

g ++ -o huvud main.o point.o kvadrat.o

Därefter måste vi bestämma vilka av filerna vi måste kompilera och återskapa när vissa delar av programmet uppdateras. För detta kommer vi att ha en beroende diagram som visar olika beroenden för var och en av implementeringsfilerna.

Nedan visas beroendetabellen för ovanstående filer.

beroende diagram

Så i ovanstående beroendediagram kan vi se den körbara 'main' vid roten. Den körbara ”main” består av objektfiler, dvs. main.o, point.o, square.o som genereras genom att kompilera main.cpp, point.cpp respektive square.cpp.

Alla cpp-implementeringar använder rubrikfiler som visas i ovanstående diagram. Som visas ovan refererar main.cpp till både point.h och square.h eftersom det är drivrutinsprogrammet och använder punkt- och kvadratklasser.

Nästa fil point.cpp referenser point.h. Den tredje filen kvadrat.cpp refererar till kvadrat.h såväl som punktet.h eftersom det också behöver en punkt för att rita rutan.

Från beroendetabellen ovan är det tydligt att när någon .cpp-fil eller .h-fil som refereras av .cpp-fil ändras måste vi återskapa den .o-filen. Till exempel, när main.cpp ändras måste vi regenerera main.o och länka objektfilerna igen för att skapa den huvudsakliga körbara filen.

Alla ovanstående förklaringar som vi har gett fungerar smidigt om det finns få filer i projektet. När projektet är stort och filer är stora och för många, blir det svårt att regenerera filerna upprepade gånger.

Således går vi för att skapa filer och vi använder för att skapa ett verktyg för att bygga projektet och generera den körbara filen.

Vi har redan sett olika delar av en make-fil. Observera att filen ska ha namnet “MAKEFILE” eller ”makefile” och bör placeras i källmappen.

Nu ska vi skriva ner makefilen för exemplet ovan.

Vi definierar variabler för att hålla värdena för kompilator- och kompilatorflaggor enligt nedan.

CC = g++ CFLAGS = -wall -g

Sedan skapar vi det första målet i vår makefile, dvs. den körbara huvudmenyn. Så vi skriver ett mål med dess beroenden.

main: main.o point.o square.o

Således är kommandot att generera detta mål

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

Notera: Ovanstående kommando översätts faktiskt till g ++ - vägg –g –o huvud main.o point.o kvadrat.o

Vårt nästa mål är att generera objektfiler, main.o, point.o, square.o

Nu för att generera main.o kommer målet att skrivas som:

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

Kommandot för detta mål är:

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

Nästa fil point.o kan genereras med kommandot nedan:

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

I kommandot ovan har vi hoppat över point.cpp. Detta beror på att make redan vet att .o-filer genereras från .cpp-filerna, så att endast .h (inkludera fil) räcker.

På samma sätt kan square.o genereras med följande kommando.

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

Hela makefilen för detta exempel ser ut som visas nedan:

# 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

Således ser vi att vi har en komplett makefil som kompilerar tre C ++ - filer och sedan genererar en körbar huvud från objektfilerna.

Fördelar med Makefiles

  • När det gäller stora projekt hjälper användningen av makefiles oss att representera projektet på ett systematiskt och effektivt sätt.
  • Makefiles gör källkoden mer kortfattad och lätt att läsa och felsöka.
  • Makefiles kompilerar automatiskt bara de filer som ändras. Således behöver vi inte regenerera hela projektet när några av delarna av projektet modifieras.
  • Make-verktyget gör att vi kan sammanställa flera filer samtidigt så att alla filer kan sammanställas i ett enda steg.

Slutsats

Makefiles är en välsignelse för mjukvaruutveckling. Med hjälp av en C ++ makefile kan vi bygga lösningar på kortare tid. Även när en del av projektet modifieras kompilerar och återskapar makefilen bara den delen utan att behöva regenerera hela projektet.

C ++ Makefile tillåter oss att representera projektet systematiskt och effektivt och därigenom göra det mer läsbart och enkelt att felsöka.

I denna C ++ Makefile-handledning har vi sett makefile och gjort verktyg i detalj. Vi har också diskuterat hur man skriver en makefile från grunden.

=> Kolla in den perfekta C ++ träningsguiden här.

Rekommenderad läsning

^