Quali sono i vantaggi dell'utilizzo di `make` per piccoli progetti? [chiuso]

Ho visto che makeè utile per grandi progetti, in particolare con dipendenze confuse descritte in a Makefile, e anche per aiutare con il flusso di lavoro. Non ho sentito alcun vantaggio nell'utilizzo makeper piccoli progetti. Ci sono?

Al contrario di cosa?

Supponiamo di avere un programma che hai diviso in due file, che hai chiamato in modo fantasioso file1.ce  file2.c. È possibile compilare il programma eseguendo

cc file1.c file2.c -o yourprogram

Ma questo richiede di ricompilare entrambi i file ogni volta, anche se solo uno è cambiato. È possibile scomporre i passaggi della compilazione in

cc -c file1.c
cc -c file2.c
cc    file1.o file2.o -o yourprogram

e quindi, quando modifichi uno dei file, ricompila solo quel file (ed esegui il passaggio di collegamento indipendentemente da ciò che hai modificato). Ma cosa succede se si modifica un file e poi l'altro e si dimentica di aver modificato entrambi i file e di averne ricompilato accidentalmente solo uno?

Inoltre, anche solo per due file, hai circa 60 caratteri di comandi lì. Diventa rapidamente noioso da scrivere. OK, certo, potresti metterli in uno script, ma poi sei tornato a ricompilare ogni volta. Oppure potresti scrivere uno script davvero elaborato e complicato che controlla quali file sono stati modificati e fa solo le compilazioni necessarie. Vedi dove sto andando con questo?

Molte altre persone stanno entrando nei dettagli di makefile più complessi e molta della complessità che ne deriva. In genere uso i makefile per un motivo completamente diverso:

Non voglio ricordare niente.

Anche se il tuo progetto è davvero noioso e semplice e non usi i makefile "correttamente":

all:
    gcc main.c -o project

Non ho bisogno di pensarci o di trattarlo in modo diverso rispetto a un progetto più complesso:

all:
    gcc libA.c libB.c main.c -o project2

O se ho specificato flag (ad es. -O2) Non ho bisogno di ricordare quali fossero.

Inoltre, se inizi con un semplice makefile e devi unire / refactificare le cose in un secondo momento, non devi ricordarti di costruire ogni progetto in modo diverso.

Anche con piccoli progetti può essere utile tenere sotto controllo la logica delle dipendenze e le build automatizzate. L'ho usato anche per innescare installazioni e disinstallazioni, quindi era un interruttore principale che ripristinava lo stage.

Se colleghi la tua app da 2 fonti ( .cfile), non è necessario ricompilare ogni file, ma solo quello modificato se stai usando make.

Inoltre, ti darò un esempio dal mondo BSD. Hanno un framework di Makefile basati sul sistema. Ti forniscono percorsi per le directory di sistema e hanno obiettivi per installare il tuo software e le pagine del manuale.

Ad esempio, hai appena scritto beer.capp e manuale per questo chiamato beer.6. Si crea Makefile:

PROG=   beer
MAN=    beer.6

.include <bsd.prog.mk>

..e chiama make install. Compila e installa automaticamente la tua app /usr/bine compila e installa la tua pagina man nel luogo in cui è manpossibile trovarla. Hai appena installato la tua app con un semplice comando!

Molto conveniente e assolutamente trasparente per chiunque abbia familiarità con BSD. Molto meglio dello script manuale.

Esempio Makefileper il mio progetto molto piccolo:getPixelColor

Fa esattamente quello che dice il suo nome, prendendo due argomenti opzionali, le coordinate.

Mi piace soprattutto il modo in cui le cose diventano dipendenti lì.

COORDS ?= 0 0

CXX := g++-8
CXXFLAGS := -std=c++17 -Wall -Wextra -Werror -Wpedantic -pedantic-errors
LDLIBS := -lX11
RM := rm -f

BIN := getPixelColor
SRC := $(BIN).cpp

$(BIN): $(SRC)
    $(CXX) $(CXXFLAGS) $(SRC) -o $(BIN) $(LDLIBS)

.PHONY: clean
clean:
    $(RM) $(BIN)

.PHONY: run
run: $(BIN)
    ./$(BIN) $(COORDS)

Come puoi vedere, può fare tutto il necessario, senza digitare nulla in più:

uso

Puoi eseguirlo in questi modi:

1. Pulisci il vecchio binario:

   make clean

2. Compila un nuovo binario:

   make

3. Esegui l'eseguibile in 2 modi:

   • le coordinate predefinite [0,0]

     make run     # equals COORDS='0 0'

   • eventuali coordinate

     COORDS='5 6' make run

I makefile possono essere estremamente utili a volte. Più grande è il progetto, maggiore è il vantaggio. Ma anche con quello il mio più piccolo progetto C ++, come puoi vedere negli esempi, ti fa risparmiare un sacco di mal di testa.

makeè abbastanza affidabile. Se distribuisci il tuo progetto con un makefile, gli utenti avranno un semplice riferimento su come eseguire le attività nello stesso modo in cui lo fai. La makefilepuò essere per più di una semplice compilazione.

Prendi un progetto che non richiede compilazione, per esempio. Ricordo di aver lavorato su un progetto Python che aveva un comando make per cancellare tutti i .pycfile, un comando make per eseguire i test, uno per scaricare una copia dei dati statici dal server di sviluppo, ecc.