Windows system >> Conocimiento de Windows > >> Tutorial del sistema Linux >> Tutorial de linux

Aprendizaje simple de make y makefile

Comprometido en dos años Windows
Desarrollo de clientes, lo que ha desarrollado múltiples subprocesos y procesos, ha tocado mucho, y finalmente siente las deficiencias, todos los días cansados de la lógica empresarial y Windows
API Más tarde, descubrí que esto no es lo que quiero. En el futuro de Windows
, cuánto tiempo puede durar este camino, vale la pena reflexionar; encontré mi favorito "mdash;" y "mdash; Linux". Finalmente bajé y decidí dedicarme a Linux. Lo toqué muchas veces, pero me detuve por un simple comando. Afortunadamente, no lo hice. Instalé el sistema Ubuntu directamente. Todas las oficinas se transfirieron al sistema Ubuntu, incluyéndome a mí. Escribe este artículo. Mire la gramática de Markdown durante el día e intente Markdown para escribir un artículo. Este camino de Linux, continúa.
Basic
Hay tantas cosas en Linux que no se puede comer a un gordo de un solo bocado, la experiencia de aprendizaje y la experiencia de trabajo me dicen que aprender esto es algo delicado, poco a poco; la base es sólida, no quiero volar El día en que no puedo volar. Comenzando con los comandos más básicos, aprenderé unas cuantas veces al día, en lugar de leerlo de una vez y aprender a usarlo, luego iré a la práctica del lenguaje C de Linux. Ya domino el lenguaje C, solo en la plataforma Linux. Desconocidos, los conceptos básicos se basan en el desarrollo del lenguaje C familiarizado con la plataforma Linux, y luego está el artículo "mdash; —" make and makefile learning ".
Compilación y vinculación del programa
Para resumir make y makefile, debe comprender el siguiente proceso:

Precompilación: también llamado preprocesamiento, trabajo de reemplazo de texto, como #define La definición del contenido, en el código a reemplazar;

Compilar: el código preprocesado para análisis léxico, análisis, código intermedio … …; Si está bajo Windows, el código intermedio es .obj Archivo; en el sistema Linux, el código intermedio es el archivo .o;

Ensamblador: El código de ensamblaje compilado obtendrá 0 y 1 lenguaje de máquina a través del ensamblador;

Enlace: enlace varios La biblioteca de enlaces estáticos y la biblioteca de enlaces dinámicos obtienen el archivo ejecutable.

make y makefile puede hacer un proyecto, tantos archivos de origen, un montón de archivos cpp y h, ¿cómo compilar? Compile un proyecto grande, si Rebuild puede tomar horas o incluso una docena de horas, entonces es posible que tengamos que preguntar.

¿Cómo puedo compilar todo el proyecto con un clic como VS?

¿Cómo modificar qué archivo, compilar el archivo modificado en lugar de recompilar todo el proyecto?

Ok, make y makefiles pueden hacer esto. El makefile define un conjunto de reglas para especificar qué archivos deben compilarse primero, qué archivos deben compilarse, qué archivos deben compilarse o incluso operaciones funcionales más complejas, porque el makefile es como un script de shell, que también se puede ejecutar. Sistema operativo
comando. El beneficio de makefile es — — " compilación automática una vez escrito, solo se necesita un comando make, y todo el proyecto se compila de forma totalmente automática, lo que mejora enormemente la eficiencia del desarrollo de software. Make es una herramienta de comando, una herramienta de comando para explicar las instrucciones en el archivo make. En general, la mayoría de los IDE tienen este comando, como: Delphi make, Visual C ++ nmake, Linux GNU make. Se puede ver que el makefile se ha convertido en un método de compilación en ingeniería. Cuando se ejecuta el comando make, se necesita un makefile para decirle al comando make qué hacer para compilar y vincular el programa. Ahora, debes entender. Make es un comando para analizar el makefile; makefile es un archivo que le dice al comando make cómo compilar todo el proyecto y generar archivos ejecutables. Es así de simple, continuemos.
Tenemos que resolver el problema
¿Por qué la cosa se hace? ¿Recuerdas cuando empezaste el lenguaje C, escribiste el programa Hello World?
#include < stdio.h > int main () {printf (" Hello World \\ n " quot;); return 0;} Cuando ingresa el comando gcc HelloWorld.c en el terminal, se genera una a. Fuera del archivo, luego puede usar mágicamente ./a.out para ejecutar el archivo e imprimir Hello World. Esto es algo que entusiasma a los principiantes. Por supuesto, he pasado esta edad de emoción. Aha, el problema viene, ahora es un solo archivo HelloWorld.c, si hay varios archivos de código y hay relaciones de referencia entre varios archivos de código, en este momento, ¿cómo compilar y generar un archivo ejecutable? Sí, el problema está llegando. Por ejemplo, hay algunos archivos de origen:
add.hadd.csub.hsub.cmul.hmul.cdivi.hdivi.cmain.c Estos archivos de código se definen de la siguiente manera:
//add.h # ifndef _ADD_H_ # define _ADD_H_int add (int a, int b); # endif //add.c # include " add.h " int add (int a, int b) {return a + b;} //sub.h # ifndef _SUB_H_ # Defina _SUB_H_int sub (int a, int b); # endif //sub.c # include " sub.h " int sub (int a, int b {return a - b;} //mul.h # ifndef _MUL_H_ # Defina _MUL_H_int mul (int a, int b); # endif //mul.c # include " mul.h " int mul (int a, int b) {return a * b;} //divi.h # ifndef _DIVI_H_ #define _DIVI_H_int divi (int a, int b); # endif //divi.c # include " divi.h " int divi (int a, int b) {if (b == 0) {return 0;} return a /b;} //main.c # include < stdio.h > #include " add.h " #include " sub.h " #include " mul.h " #include " divi.h " Int main () {int a = 10; int b = 2; printf ("% d +% d =% d \\ n ", a, b, add (a, b)); printf ("% d - % d = % d \\ n ", a, b, sub (a, b)); printf ("% d *% d =% d \\ n ", a, b, mul (a, b)); printf (" % d /% d =% d \\ n ", a, b, divi (a, b)); return 0;} También vio que en main.c desea hacer referencia a estos archivos, luego cómo compilar ahora genera un Archivo ejecutable? La pregunta está por venir, ¿cómo solucionarlo?
La forma más estúpida de resolver el problema
La solución más estúpida es compilar todos los archivos para generar el archivo .o de destino correspondiente. De la siguiente manera:
$ gcc -c sub.c -o sub.o $ gcc -c add.c -o add.o $ gcc -c sub.c -o sub.o $ gcc -c mul.c -o Mul.o $ gcc -c divi.c -o divi.o $ gcc -c main.c -o main.o Luego use el siguiente comando para vincular el archivo de objeto único generado para generar un archivo ejecutable.
$ gcc -o main add.o sub.o mul.o divi.o main.o