Meniu

C ++ Makefile Tutorial: Cum să creați și să utilizați Makefile în C ++

  • Principal
  • Alte
  • C ++ Makefile Tutorial: Cum să creați și să utilizați Makefile în C ++

c makefile tutorial

Încercați Instrumentul Nostru Pentru Eliminarea Problemelor

În acest tutorial Makefile C ++, vom discuta despre aspectele majore ale instrumentului Make și makefile, inclusiv avantajele și aplicațiile sale în C ++:

În orice proiect C ++, unul dintre obiectivele importante este simplificarea construcției proiectului, astfel încât să obținem toate dependențele și fișierele de proiect într-un singur loc și să le executăm dintr-o singură mișcare, astfel încât să obținem rezultatul dorit cu o singură comandă.

adăugarea de valori într-o matrice java

În același timp, ori de câte ori vreunul dintre fișierele proiectului este modificat, nu trebuie să trecem prin problemele de a construi din nou întregul proiect, adică ori de câte ori un fișier sau două sunt modificate în proiect, reconstruim doar aceste fișiere modificate și apoi continuăm odată cu executarea.

=> Citiți seria Easy C ++ Training.

Acestea sunt exact caracteristicile care sunt abordate de instrumentul „make” și „makefiles” în C ++. În acest tutorial, vom discuta despre toate aspectele majore ale makefile-urilor, precum și despre aplicațiile lor în C ++.

C ++ Makefile și Make Tool

Ce veți învăța:

Faceți instrumentul

Make este un instrument UNIX și este folosit ca instrument pentru a simplifica executarea clădirilor din diferite module ale unui proiect. Există diferite reguli care sunt specificate ca intrări țintă în makefile. Instrumentul make citește toate aceste reguli și se comportă în consecință.

De exemplu, dacă o regulă specifică orice dependență, atunci instrumentul make va include dependența respectivă în scopuri de compilare. Comanda make este utilizată în makefile pentru a construi module sau pentru a curăța fișierele.

Sintaxa generală a mărcii este:

%make target_label #target_label is a specific target in makefile

De exemplu , dacă vrem să executăm comenzi rm pentru a curăța fișierele, scriem:

% make clean # aici clean este un target_label specificat pentru comenzile rm

C ++ Makefile

Un makefile nu este altceva decât un fișier text care este folosit sau la care se face referire prin comanda „make” pentru a construi țintele. Un makefile conține, de asemenea, informații, cum ar fi dependențele la nivel de sursă pentru fiecare fișier, precum și dependențele de ordine de construcție.

Acum să vedem structura generală a makefile-ului.

Un makefile începe de obicei cu declarații variabile urmate de un set de intrări țintă pentru construirea unor ținte specifice. Aceste ținte pot fi .o sau alte fișiere executabile în C sau C ++ și fișiere .class în Java.

De asemenea, putem avea un set de intrări țintă pentru executarea unui set de comenzi specificate de eticheta țintă.

Deci, un makefile generic este așa cum se arată mai jos:

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

Un exemplu simplu de makefile este prezentat mai jos.

# 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

În makefile-ul de mai sus, am specificat două etichete țintă, prima este eticheta „toate” pentru a construi executabil din fișierele obiect myprogram și mylib. A doua etichetă țintă „curată” elimină toate fișierele cu numele „programul meu”.

Să vedem o altă variantă a makefile-ului.

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

Așa cum se arată în exemplul de mai sus, în acest makefile folosim variabila „CC” care conține valoarea compilatorului pe care o folosim (GCC în acest caz). O altă variabilă „CFLAGS” conține steagurile compilatorului pe care le vom folosi.

A treia variabilă „ȚINTĂ” conține numele programului pentru care trebuie să construim executabilul.

Avantajul măsurării acestei variații a makefile-ului este că trebuie doar să schimbăm valorile variabilelor pe care le-am folosit ori de câte ori există o schimbare în compilator, steaguri ale compilatorului sau numele programului executabil.

Exemplu de Make and Makefile

Luați în considerare un exemplu de program cu următoarele fișiere:

  • Main.cpp: Programul principal de driver
  • Punct.h: Fișier antet pentru clasa punctelor
  • Point.cpp: Fișier de implementare CPP pentru clasa de puncte
  • Square.h: Fișier antet pentru clasa pătrată
  • Square.cpp; Fișier de implementare CPP pentru clasa pătrată

Cu fișierele .cpp și .h menționate mai sus, trebuie să compilăm aceste fișiere separat pentru a genera fișiere .o și apoi să le conectăm la executabilul numit main.

Deci, în continuare, compilăm aceste fișiere separat.

  • g ++ -c main.cpp: generează main.o
  • g ++ -c point.cpp: generează un punct.o
  • g ++ -c square.cpp: generează pătrat.o

Apoi, legăm fișierele obiect împreună pentru a genera principalul executabil.

g ++ -o main main.o point.o square.o

Apoi, trebuie să decidem care dintre fișiere va trebui să le recompilăm și să le regenerăm atunci când anumite părți ale programului sunt actualizate. Pentru aceasta, vom avea un diagramă de dependență care arată diferite dependențe pentru fiecare fișier de implementare.

Dat mai jos este diagrama dependenței pentru fișierele de mai sus.

diagramă de dependență

Deci, în graficul de dependență de mai sus, putem vedea executabilul „principal” la rădăcină. Executabilul „principal” constă din fișiere obiect și anume. main.o, point.o, square.o care este generat prin compilarea main.cpp, point.cpp și respectiv square.cpp.

Toate implementările CPP folosesc fișiere antet așa cum se arată în graficul de mai sus. După cum se arată mai sus, main.cpp face trimitere atât la point.h cât și la square.h, deoarece este programul driver și folosește clasele de puncte și pătrate.

Următorul fișier referințe point.cpp point.h. Al treilea fișier square.cpp face referire la square.h, precum și la point.h, deoarece va avea nevoie și de un punct pentru a desena pătratul.

Din graficul de dependență de mai sus, este clar că ori de câte ori se schimbă orice fișier .cpp sau .h la care se face referire prin fișierul .cpp, trebuie să regenerăm acel fișier .o De exemplu, când main.cpp se modifică, trebuie să regenerăm main.o și să legăm din nou fișierele obiect pentru a genera executabilul principal.

Toate explicațiile de mai sus pe care le-am dat vor funcționa fără probleme dacă există puține fișiere în proiect. Când proiectul este imens și fișierele sunt mari și prea multe, atunci devine dificil să regenerați fișierele în mod repetat.

Astfel, mergem pentru a crea fișiere și folosim pentru a crea un instrument pentru a construi proiectul și a genera executabilul.

Am văzut deja diferite părți ale unui fișier make. Rețineți că fișierul trebuie să fie denumit „MAKEFILE” sau „makefile” și trebuie plasat în folderul sursă.

Acum vom scrie makefile-ul pentru exemplul de mai sus.

Vom defini variabile pentru a păstra valorile compilatorului și a steagurilor de compilare așa cum se arată mai jos.

CC = g++ CFLAGS = -wall -g

Apoi creăm prima țintă din makefile noastre, adică executabilul principal. Deci, scriem o țintă cu dependențele sale.

principal: principal.o punct.o pătrat.o

Astfel, comanda pentru a genera această țintă este

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

Notă: Comanda de mai sus se traduce de fapt în g ++ -wall –g –o main main.o point.o square.o

Următoarea noastră țintă va fi generarea de fișiere obiect, main.o, point.o, square.o

Acum, pentru a genera main.o, ținta va fi scrisă ca:

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

Comanda pentru această țintă este:

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

Următorul fișier point.o poate fi generat folosind comanda de mai jos:

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

În comanda de mai sus, am omis point.cpp. Acest lucru se datorează faptului că make știe deja că fișierele .o sunt generate din fișierele .cpp, astfel încât este suficient doar .h (include fișier).

În mod similar, square.o poate fi generat cu următoarea comandă.

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

Întregul makefile pentru acest exemplu va arăta așa cum se arată mai jos:

# 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

Astfel, vedem că avem un makefile complet care compilează trei fișiere C ++ și apoi generează un fișier principal executabil din fișierele obiect.

Avantajele Makefiles

  • Când vine vorba de proiecte mari, atunci folosirea makefiles ne ajută să reprezentăm proiectul într-un mod sistematic și eficient.
  • Makefile fac codul sursă mai concis și mai ușor de citit și de depanat.
  • Makefiles compilează automat numai acele fișiere care sunt modificate. Astfel, nu trebuie să regenerăm întregul proiect atunci când unele dintre porțiunile proiectului sunt modificate.
  • Instrumentul Make ne permite să compilăm mai multe fișiere simultan, astfel încât toate fișierele să poată fi compilate într-un singur pas.

Concluzie

Makefiles sunt un avantaj pentru dezvoltarea de software. Folosind un makefile C ++, putem construi soluții într-un timp mai mic. De asemenea, atunci când o parte a proiectului este modificată, makefile recompilează și regenerează doar acea parte fără a fi nevoie să regenereze întregul proiect.

C ++ Makefile ne permite să reprezentăm proiectul în mod sistematic și eficient, făcându-l astfel mai ușor de citit și mai ușor de depanat.

În acest tutorial C ++ Makefile, am văzut makefile și facem instrumente în detaliu. De asemenea, am discutat despre cum să scriem un makefile de la zero.

=> Consultați aici ghidul perfect de formare C ++.

Lectură recomandată

^