¿Cuáles son las ventajas de usar `make` para proyectos pequeños? [cerrado]

He visto que makees útil para proyectos grandes, especialmente con dependencias confusas descritas en a Makefile, y también ayuda con el flujo de trabajo. No he escuchado ninguna ventaja de usar makepara proyectos pequeños. ¿Hay alguna?

¿A diferencia de qué?

Supongamos que tiene un programa que ha dividido en dos archivos, que ha llamado imaginativamente file1.cy  file2.c. Puede compilar el programa ejecutando

cc file1.c file2.c -o yourprogram

Pero esto requiere recompilar ambos archivos cada vez, incluso si solo uno ha cambiado. Puede descomponer los pasos de compilación en

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

y luego, cuando edite uno de los archivos, vuelva a compilar solo ese archivo (y realice el paso de vinculación sin importar lo que haya cambiado). Pero, ¿qué sucede si edita un archivo, y luego el otro, y olvida que editó ambos archivos y accidentalmente vuelve a compilar uno?

Además, incluso para solo dos archivos, tiene alrededor de 60 caracteres de comandos allí. Eso rápidamente se vuelve tedioso de escribir. OK, claro, puedes ponerlos en un script, pero luego vuelves a recompilar cada vez. O puede escribir un script realmente sofisticado y complicado que verifique qué archivo (s) se han modificado y solo haga las compilaciones necesarias. ¿Ves a dónde voy con esto?

Muchas otras personas están entrando en los detalles de los makefiles más complejos y mucha de la complejidad que conlleva. Normalmente uso makefiles por una razón completamente diferente:

No quiero recordar nada.

Incluso si tu proyecto es realmente aburrido y simple, y no usas makefiles "correctamente":

all:
    gcc main.c -o project

No necesito pensarlo o tratarlo de manera diferente a un proyecto que es más complejo:

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

O si especifiqué banderas (por ejemplo -O2), no necesito recordar cuáles eran.

Además, si comienza con un archivo MAKE simple y necesita fusionar / refactorizar más tarde, no necesita recordar construir cada proyecto de manera diferente.

Incluso con proyectos pequeños, puede ser útil mantener la lógica de dependencia bajo control y las compilaciones automatizadas. También lo usé para activar instalaciones y desinstalaciones, por lo que fue un interruptor principal que restableció el escenario.

Si vincula su aplicación desde 2 fuentes ( .carchivos), no necesita volver a compilar cada archivo, sino solo el modificado si está utilizando make.

Además, te daré un ejemplo del mundo BSD. Tienen marco de Makefiles basados ​​en el sistema. Le proporcionan rutas a los directorios del sistema y tienen objetivos para instalar su software y páginas de manual.

Por ejemplo, acabas de escribir la beer.caplicación y el manual llamado beer.6. Tu creas Makefile:

PROG=   beer
MAN=    beer.6

.include <bsd.prog.mk>

..y llamar make install. Compila e instala automáticamente su aplicación /usr/biny compila e instala su página de manual en el lugar donde manpuede encontrarla. ¡Acabas de instalar tu aplicación con un simple comando!

Muy conveniente y absolutamente transparente para cualquiera que esté familiarizado con BSD. Mucho mejor que el script manual.

Ejemplo Makefilepara mi proyecto muy pequeño:getPixelColor

Hace exactamente lo que dice su nombre, tomando dos argumentos opcionales, las coordenadas.

Me gusta especialmente la forma en que las cosas se vuelven dependientes allí.

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)

Como puede ver, puede hacer todo lo que necesita, sin escribir nada adicional:

Uso

Puede ejecutarlo de esta manera:

1. Limpiar el viejo binario:

   make clean

2. Compila un nuevo binario:

   make

3. Ejecute el ejecutable de 2 maneras:

   • las coordenadas predeterminadas [0,0]

     make run     # equals COORDS='0 0'

   • cualquier coordenada dada

     COORDS='5 6' make run

Los Makefiles pueden ser extremadamente útiles a veces. Cuanto más grande es el proyecto, mayor es el beneficio. Pero incluso con eso, mi proyecto C ++ más pequeño, como puede ver en los ejemplos, le ahorra muchos dolores de cabeza.

makeestá bastante confiablemente disponible. Si distribuye su proyecto con un makefile, los usuarios tendrán una referencia simple de cómo realizar tareas de la misma manera que usted. El makefilepuede ser para algo más que una compilación.

Tome un proyecto que no requiere compilación, por ejemplo. Recuerdo haber trabajado en un proyecto de Python que tenía un comando make para borrar todos los .pycarchivos, un comando make para ejecutar las pruebas, uno para descargar una copia de los datos estáticos del servidor de desarrollo, etc.