Menu

Tutorial C ++ Makefile: come creare e utilizzare Makefile in C ++

  • Principale
  • Altro
  • Tutorial C ++ Makefile: come creare e utilizzare Makefile in C ++

c makefile tutorial

Prova Il Nostro Strumento Per Eliminare I Problemi

In questo tutorial C ++ Makefile, discuteremo i principali aspetti dello strumento Make e del makefile, inclusi i suoi vantaggi e le applicazioni in C ++:

In qualsiasi progetto C ++, uno degli obiettivi importanti è semplificare la costruzione del progetto in modo da ottenere tutte le dipendenze e i file di progetto in un unico posto ed eseguirli in una volta in modo da ottenere l'output desiderato con un singolo comando.

come creare un firewall da zero

Allo stesso tempo, ogni volta che uno qualsiasi dei file di progetto viene modificato, non dobbiamo affrontare la fatica di ricostruire l'intero progetto di nuovo, ovvero ogni volta che un file o due vengono modificati nel progetto, ricostruiamo solo questi file modificati e quindi procediamo con l'esecuzione.

=> Leggere la serie di formazione Easy C ++.

Queste sono esattamente le funzionalità che vengono affrontate dallo strumento 'make' e dai 'makefile' in C ++. In questo tutorial, discuteremo tutti gli aspetti principali dei makefile e delle loro applicazioni in C ++.

C ++ Makefile e Make Tool

Cosa imparerai:

Crea strumento

Make è uno strumento UNIX e viene utilizzato come strumento per semplificare la creazione di eseguibili da diversi moduli di un progetto. Esistono varie regole specificate come voci di destinazione nel makefile. Lo strumento make legge tutte queste regole e si comporta di conseguenza.

Per esempio, se una regola specifica una dipendenza, lo strumento make includerà tale dipendenza per scopi di compilazione. Il comando make viene utilizzato nel makefile per creare moduli o per ripulire i file.

La sintassi generale di make è:

%make target_label #target_label is a specific target in makefile

Per esempio , se vogliamo eseguire comandi rm per ripulire i file, scriviamo:

% make clean #here clean è un target_label specificato per i comandi rm

Makefile C ++

Un makefile non è altro che un file di testo utilizzato o referenziato dal comando 'make' per costruire i target. Un makefile contiene anche informazioni come le dipendenze a livello di origine per ogni file, nonché le dipendenze dell'ordine di compilazione.

Vediamo ora la struttura generale del makefile.

Un makefile inizia in genere con dichiarazioni di variabili seguite da una serie di voci di destinazione per la creazione di obiettivi specifici. Queste destinazioni possono essere .o o altri file eseguibili in C o C ++ e file .class in Java.

Possiamo anche avere una serie di voci di destinazione per l'esecuzione di una serie di comandi specificati dall'etichetta di destinazione.

Quindi un makefile generico è come mostrato di seguito:

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

Di seguito è mostrato un semplice esempio 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

Nel makefile sopra, abbiamo specificato due etichette di destinazione, la prima è l'etichetta 'all' per creare eseguibili dai file oggetto myprogram e mylib. La seconda etichetta di destinazione 'clean' rimuove tutti i file con il nome 'myprogram'.

Vediamo un'altra variante 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)

Come mostrato nell'esempio precedente, in questo makefile utilizziamo la variabile 'CC' che contiene il valore del compilatore che stiamo utilizzando (GCC in questo caso). Un'altra variabile 'CFLAGS' contiene i flag del compilatore che useremo.

La terza variabile 'TARGET' contiene il nome del programma per il quale dobbiamo costruire l'eseguibile.

Il vantaggio di misura di questa variazione del makefile è che dobbiamo solo cambiare i valori delle variabili che abbiamo usato ogni volta che c'è qualche cambiamento nel compilatore, nei flag del compilatore o nel nome del programma eseguibile.

Esempio di make e makefile

Considera un esempio di programma con i seguenti file:

  • Main.cpp: Programma driver principale
  • Point.h: File di intestazione per la classe di punti
  • Point.cpp: File di implementazione CPP per la classe di punti
  • Square.h: File di intestazione per classe quadrata
  • Square.cpp; File di implementazione CPP per classe quadrata

Con i file .cpp e .h sopra indicati, è necessario compilare questi file separatamente per generare file .o e quindi collegarli all'eseguibile denominato main.

Quindi compiliamo questi file separatamente.

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

Successivamente, colleghiamo i file oggetto insieme per generare l'eseguibile main.

g ++ -o principale principale.o punto.o quadrato.o

Successivamente, dobbiamo decidere quale dei file dovremo ricompilare e rigenerare quando vengono aggiornate alcune parti del programma. Per questo, avremo un file grafico delle dipendenze che mostra varie dipendenze per ciascuno dei file di implementazione.

Di seguito è riportato il grafico delle dipendenze per i file sopra.

grafico delle dipendenze

Quindi, nel grafico delle dipendenze sopra, possiamo vedere l'eseguibile 'main' alla radice. L'eseguibile 'principale' è costituito da file oggetto vale a dire. main.o, point.o, square.o generato compilando rispettivamente main.cpp, point.cpp e square.cpp.

Tutte le implementazioni cpp utilizzano file di intestazione come mostrato nella tabella sopra. Come mostrato sopra main.cpp fa riferimento sia a point.h che a square.h in quanto è il programma driver e utilizza classi point e square.

Il file successivo point.cpp fa riferimento a point.h. Il terzo file square.cpp fa riferimento sia a square.h che a point.h in quanto sarà necessario anche un punto per disegnare il quadrato.

Dal grafico delle dipendenze sopra, è chiaro che ogni volta che un file .cpp o .h a cui fa riferimento il file .cpp cambia, dobbiamo rigenerare quel file .o. Per esempio, quando main.cpp cambia, dobbiamo rigenerare main.o e collegare nuovamente i file oggetto per generare l'eseguibile principale.

Tutte le spiegazioni di cui sopra che abbiamo fornito funzioneranno senza problemi se ci sono pochi file nel progetto. Quando il progetto è enorme ei file sono grandi e troppi, diventa difficile rigenerarli ripetutamente.

Quindi, andiamo per make files e usiamo per creare uno strumento per costruire il progetto e generare l'eseguibile.

Abbiamo già visto varie parti di un file make. Tieni presente che il file deve essere denominato 'MAKEFILE' o 'makefile' e deve essere posizionato nella cartella di origine.

Ora scriveremo il makefile per l'esempio precedente.

Definiremo le variabili per contenere i valori dei flag del compilatore e del compilatore come mostrato di seguito.

CC = g++ CFLAGS = -wall -g

Quindi creiamo il primo target nel nostro makefile, ovvero l'eseguibile main. Quindi scriviamo un obiettivo con le sue dipendenze.

main: main.o point.o square.o

Quindi il comando per generare questo obiettivo è

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

Nota: Il comando precedente si traduce effettivamente in g ++ -wall –g –o main main.o point.o square.o

Il nostro prossimo obiettivo sarà generare file oggetto, main.o, point.o, square.o

Ora per generare main.o, l'obiettivo verrà scritto come:

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

Il comando per questo target è:

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

Il prossimo file point.o può essere generato utilizzando il comando seguente:

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

Nel comando precedente, abbiamo saltato point.cpp. Questo perché make sa già che i file .o vengono generati dai file .cpp, quindi solo .h (include file) è sufficiente.

Allo stesso modo, square.o può essere generato con il seguente comando.

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

L'intero makefile per questo esempio apparirà come mostrato di seguito:

# 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

Quindi, vediamo che abbiamo un makefile completo che compila tre file C ++ e quindi genera un eseguibile main dai file oggetto.

Vantaggi dei makefile

  • Quando si tratta di grandi progetti, l'uso dei makefile ci aiuta a rappresentare il progetto in modo sistematico ed efficiente.
  • I makefile rendono il codice sorgente più conciso e facile da leggere e da eseguire il debug.
  • I makefile compilano automaticamente solo i file modificati. Quindi non è necessario rigenerare l'intero progetto quando alcune parti del progetto vengono modificate.
  • Lo strumento Make ci consente di compilare più file contemporaneamente in modo che tutti i file possano essere compilati in un unico passaggio.

Conclusione

I makefile sono un vantaggio per lo sviluppo del software. Usando un makefile C ++, possiamo costruire soluzioni in minor tempo. Inoltre, quando una parte del progetto viene modificata, il makefile ricompila e rigenera solo quella parte senza dover rigenerare l'intero progetto.

C ++ Makefile ci permette di rappresentare il progetto in modo sistematico ed efficiente, rendendolo così più leggibile e facile da eseguire il debug.

In questo tutorial C ++ Makefile, abbiamo visto makefile e make tools in dettaglio. Abbiamo anche discusso di come scrivere un makefile da zero.

=> Dai un'occhiata alla guida di formazione C ++ perfetta qui.

Lettura consigliata

^