Menú

C ++ Makefile Tutorial: Com crear i utilitzar Makefile a C ++

  • Principal
  • Altres
  • C ++ Makefile Tutorial: Com crear i utilitzar Makefile a C ++

c makefile tutorial

Proveu El Nostre Instrument Per Eliminar Problemes

En aquest tutorial de C ++ Makefile, analitzarem els aspectes principals de l'eina Make i makefile, inclosos els seus avantatges i aplicacions a C ++:

En qualsevol projecte C ++, un dels objectius importants és simplificar la construcció del projecte de manera que aconseguim totes les dependències i fitxers de projecte en un sol lloc i els executem d’una sola vegada per obtenir la sortida desitjada amb una sola ordre.

eina de pirateig de contrasenyes de correu electrònic en línia

Al mateix temps, sempre que es modifica algun dels fitxers del projecte, no hem de passar problemes per construir tot el projecte de nou, és a dir, sempre que es modifiqui un o dos fitxers al projecte, només reconstruïm aquests fitxers modificats i procedim amb l'execució.

=> Llegiu la sèrie de formació Easy C ++.

Aquestes són exactament les funcions que aborda l'eina 'make' i els 'makefiles' a C ++. En aquest tutorial, analitzarem tots els aspectes principals dels fitxers makefile, així com les seves aplicacions a C ++.

C ++ Makefile i Make Tool

Què aprendreu:

Eina de creació

Make és una eina UNIX i s’utilitza com a eina per simplificar la construcció d’executables a partir de diferents mòduls d’un projecte. Hi ha diverses regles que s’especifiquen com a entrades de destinació al fitxer makefile. L'eina make llegeix totes aquestes regles i es comporta en conseqüència.

Per exemple, si una regla especifica alguna dependència, l'eina make inclourà aquesta dependència a efectes de compilació. L'ordre make s'utilitza al makefile per crear mòduls o netejar els fitxers.

La sintaxi general de make és:

%make target_label #target_label is a specific target in makefile

Per exemple , si volem executar ordres rm per netejar fitxers, escrivim:

% make clean #aquí clean hi ha una target_label especificada per a les ordres rm

C ++ Makefile

Un fitxer makefile no és res més que un fitxer de text que s’utilitza o fa referència a l’ordre ‘make’ per construir els objectius. Un makefile també conté informació com les dependències de nivell de font per a cada fitxer, així com les dependències de l'ordre de construcció.

Ara vegem l’estructura general del makefile.

Un fitxer makefy normalment comença amb declaracions de variables seguides d'un conjunt d'entrades de destinació per crear objectius específics. Aquests objectius poden ser fitxers .o o altres fitxers executables en fitxers C o C ++ i .class a Java.

També podem tenir un conjunt d’entrades de destinació per executar un conjunt d’ordres especificades per l’etiqueta de destinació.

Per tant, un fitxer genèric de canvi és el que es mostra a continuació:

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

A continuació es mostra un exemple senzill del makefile.

# 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

Al fitxer makefire anterior, hem especificat dues etiquetes de destinació, la primera és l’etiqueta ‘all’ per construir executable a partir de fitxers objecte myprogram i mylib. La segona etiqueta de destinació 'neteja' elimina tots els fitxers amb el nom 'el meu programa'.

Vegem una altra variació del makefile.

# 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)

Com es mostra a l’exemple anterior, en aquest fitxer de make fem ús de la variable ‘CC’ que conté el valor del compilador que estem utilitzant (GCC en aquest cas). Una altra variable 'CFLAGS' conté els indicadors del compilador que utilitzarem.

La tercera variable 'TARGET' conté el nom del programa per al qual hem de construir l'executable.

L’avantatge de mesurar aquesta variació del fitxer makeh és que només hem de canviar els valors de les variables que hem utilitzat sempre que hi ha algun canvi en el compilador, els senyaladors del compilador o el nom del programa executable.

Exemple de Make i Makefile

Penseu en un exemple de programa amb els fitxers següents:

  • Main.cpp: Programa principal de controladors
  • Punt.h: Fitxer de capçalera de la classe de punts
  • Point.cpp: Fitxer d'implementació CPP per a la classe de punts
  • Square.h: Fitxer de capçalera per a classe quadrada
  • Square.cpp; Fitxer d’implementació CPP per a classe quadrada

Amb els fitxers .cpp i .h donats anteriorment, hem de compilar aquests fitxers per separat per generar fitxers .o i enllaçar-los a l’executable anomenat main.

A continuació, compilem aquests fitxers per separat.

  • g ++ -c main.cpp: genera main.o
  • g ++ -c point.cpp: genera un punt.o
  • g ++ -c square.cpp: genera quadrat.o

A continuació, enllaçem els fitxers objecte entre si per generar el fitxer principal executable.

g ++ -o main.o main.o punt.o quadrat.o

A continuació, hem de decidir quins dels fitxers haurem de recompilar i regenerar quan s’actualitzin algunes parts del programa. Per a això, tindrem un gràfic de dependències que mostra diverses dependències per a cadascun dels fitxers d'implementació.

A continuació es mostra el gràfic de dependències dels fitxers anteriors.

gràfic de dependències

Així doncs, al gràfic de dependències anterior, podem veure l’executable ‘main’ a l’arrel. L'executable 'principal' consisteix en fitxers objecte, és a dir. main.o, point.o, square.o que es genera compilant main.cpp, point.cpp i square.cpp respectivament.

Totes les implementacions de CPP utilitzen fitxers de capçalera tal com es mostra al gràfic anterior. Com es mostra més amunt, main.cpp fa referència tant a point.h com a square.h, ja que és el programa controlador i utilitza classes de punts i quadrats.

Fitxer següent referències point.cpp point.h. El tercer fitxer square.cpp fa referència a square.h, així com al point.h, ja que també necessitarà un punt per dibuixar el quadrat.

Segons el gràfic de dependències anterior, queda clar que cada vegada que canvia algun fitxer .cpp o .h al qual fa referència el fitxer .cpp, hem de regenerar aquest fitxer .o. Per exemple, quan main.cpp canvia, hem de regenerar main.o i enllaçar de nou els fitxers objecte per generar l'executable principal.

Totes les explicacions anteriors que hem donat funcionaran sense problemes si hi ha pocs fitxers al projecte. Quan el projecte és enorme i els fitxers són grans i massa, aleshores es fa difícil regenerar els fitxers repetidament.

Per tant, anem a fer fitxers i fem servir una eina per construir el projecte i generar l’executable.

Ja hem vist diverses parts d’un fitxer make. Tingueu en compte que el fitxer s'ha de denominar 'MAKEFILE' o 'makefile' i s'ha de col·locar a la carpeta d'origen.

Ara anotarem el makefile de l'exemple anterior.

Definirem variables per contenir els valors de les marques del compilador i del compilador com es mostra a continuació.

CC = g++ CFLAGS = -wall -g

A continuació, creem el primer objectiu al nostre fitxer de make, és a dir, el principal executable. Per tant, escrivim un objectiu amb les seves dependències.

principal: principal.o punt.o quadrat.o

Per tant, l'ordre per generar aquest objectiu és

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

Nota: L’ordre anterior es tradueix realment en g ++ -wall –g –o main.o main.o point.o square.o

El nostre següent objectiu serà generar fitxers objecte, main.o, point.o, square.o

Ara per generar main.o, l'objectiu s'escriurà com:

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

L'ordre per a aquest objectiu és:

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

El següent fitxer point.o es pot generar mitjançant l'ordre següent:

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

A l'ordre anterior, hem saltat point.cpp. Això es deu al fet que make ja sap que els fitxers .o es generen a partir dels fitxers .cpp, de manera que només n'hi ha prou amb .h (inclou fitxer).

De la mateixa manera, es pot generar square.o amb l'ordre següent.

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

Tot el fitxer de maquillatge d’aquest exemple tindrà el següent aspecte:

# 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

Per tant, veiem que tenim un fitxer complet que compila tres fitxers C ++ i després genera un fitxer principal executable a partir dels fitxers objecte.

Avantatges de Makefiles

  • Quan es tracta de grans projectes, l’ús de makefiles ens ajuda a representar el projecte d’una manera sistemàtica i eficient.
  • Els fitxers Makefiles fan que el codi font sigui més concís i fàcil de llegir i depurar.
  • Makefiles compila automàticament només aquells fitxers que es canvien. Per tant, no hem de regenerar tot el projecte quan es modifiquen algunes de les parts del projecte.
  • L'eina Make ens permet compilar diversos fitxers alhora perquè es puguin compilar tots els fitxers en un sol pas.

Conclusió

Els fitxers Makefile són una ajuda per al desenvolupament de programari. Mitjançant un fitxer de make C ++, podem crear solucions en menys temps. També quan es modifica una part del projecte, el makefile recompila i regenera només aquella part sense haver de regenerar tot el projecte.

C ++ Makefile ens permet representar el projecte de manera sistemàtica i eficient, de manera que el fa més llegible i fàcil de depurar.

En aquest tutorial de C ++ Makefile, hem vist makefile i fer eines detalladament. També hem debatut sobre com escriure un fitxer de marca des de zero.

=> Consulteu aquí la guia d’entrenament perfecta de C ++.

Lectura recomanada

^