LINUX

Una guía para principiantes para comprender los Makefiles en Linux

Como principiantes, la mayoría de los programadores de C / C ++ compilan sus programas en la línea de comandos de Linux ejecutando los comandos del compilador gcc o g ++. Pero, a medida que sus proyectos comienzan a crecer, la compilación mediante un solo comando no sigue siendo fácil y eficaz.

Como solución a todos los problemas relacionados con la compilación, debe comprender el concepto de archivos MAKE. Este tema se tratará en una serie de artículos y, en esta primera parte, discutiremos los conceptos básicos de los archivos MAKE en Linux.

Problemas con el método de comando único

Suponga que su proyecto consta de los siguientes tres archivos guardados en un directorio:

test.c
anotherTest.c
test.h

Como principiante, ejecutará el siguiente comando una y otra vez para compilar su proyecto:

gcc -Wall test.c anotherTest.c -o test -I.

Esto está bien siempre que su proyecto contenga solo unos pocos archivos. Ahora suponga que su proyecto crece y ahora contiene 10 archivos fuente y de encabezado más. ¿Qué harás entonces?

Muchos dirían que extenderán el comando existente agregando los nombres de esos nuevos archivos. Pero, ¿qué pasa si de alguna manera pierde este comando o cambia a otro sistema? ¿Volverás a escribir el comando largo?

Además, suponga que su proyecto se convierte en un gran proyecto que contiene cientos de archivos y tarda de 5 a 10 minutos en compilarse. Ahora, suponga que agrega un simple printf línea de depuración en uno de los archivos .c pero use un solo comando para volver a compilar. ¿No sería ineficiente que un programa tarde 10 minutos en compilarse, incluso si se cambia / agrega una sola línea en uno de los archivos de origen?

Bueno, la solución es usar Makefiles.

Makefiles

Un archivo MAKE es un archivo especial (llamado sólo «Makefile») que consta de destinos, dependencias y comandos, estructurado de una manera que facilita al programador la compilación del programa.

En términos simples, aquí hay una sintaxis muy básica de un archivo MAKE:

target: dependencies
[tab] command

Entonces, si queremos crear un archivo MAKE muy básico para nuestro proyecto de ejemplo (listado en la última sección), sería algo como:

all: test

test: test.o anotherTest.o
    gcc -Wall test.c anotherTest.c -o test -I.

test.o: test.c
    gcc -Wall -c test.c -I.

anotherTest.o: anothertest.c
    gcc -Wall -c anotherTest.c -I.

Esto puede parecer un poco complicado para un principiante, pero si lo observa de cerca, no contiene más que grupos de objetivos, dependencias y comandos.

  • El objetivo ‘todos’ no es más que un objetivo de archivo MAKE predeterminado.
  • La ‘prueba’ de destino depende de test.o y anotherTest.o, y se puede producir a través del comando que se menciona a continuación.
  • De manera similar, los objetivos ‘test.o’ y ‘anotherTest.o’ dependen de sus archivos .c correspondientes, y se pueden producir a través de los comandos respectivos que se mencionan a continuación.

Ahora, uno se preguntaría, ¿cómo usar estos objetivos? Bueno, estos se utilizan a través del comando ‘make’. Este comando acepta un objetivo como argumento y busca un archivo llamado ‘Makefile’ para entender cómo construir ese objetivo. Por ejemplo, si especifica el siguiente comando:

make test

Entonces este comando escanearía el Makefile, construiría (si es necesario) las dependencias de prueba y luego ejecute el comando para construir prueba sí mismo.

Del mismo modo, si desea eliminar todos los objetos o archivos ejecutables no necesarios antes de cada ciclo de compilación, puede agregar un objetivo limpio a su Makefile.

Aquí hay un ejemplo :

all: test

test: test.o anotherTest.o
    gcc -Wall test.c anotherTest.c -o test -I.

test.o: test.c
    gcc -Wall -c test.c -I.

anotherTest.o: anothertest.c
    gcc -Wall -c anotherTest.c -I.

clean:
    rm -rf *o test

Entonces puedes simplemente emitir el siguiente comando:

make clean

para limpiar todos los archivos de objetos extra y el prueba archivo ejecutable, antes de iniciar un ciclo de compilación.

La belleza de este comando es que sabe qué archivos han cambiado desde la última vez que se ejecutó y construye solo las dependencias necesarias. Entonces, la combinación de hacer command y Makefile no solo facilita al programador la compilación del proyecto, sino que también minimiza el tiempo total de compilación.

Publicaciones relacionadas

Deja una respuesta

Tu dirección de correo electrónico no será publicada.

Botón volver arriba
Cerrar