Todo el contenido de este artículo es de la publicación del blog elaborado en resumen, gracias [El amor es paciente 1989 ] hermano mayor.
Asegúrese de leer la publicación original del blog y luego lea esta, de lo contrario, será complicado.
-------------------------------------------------- -------------------------------------------------- -------------------------------------------------- -------------
Generalmente, la composición de un proyecto requiere un archivo .h, un archivo .c correspondiente al .h, más un archivo main.c que contiene la función principal.
Si no desea que otros vean el código específico dentro de ciertas funciones, puede simplemente mantener los archivos .h correspondientes a estas funciones, descartar los archivos .c y usar enlaces estáticos o dinámicos en su lugar.
cmake se puede utilizar para generar documentos Makeile correspondientes a .h / .c / main.c, y también para generar documentos Makefile correspondientes a enlaces .h / (dinámicos / estáticos) La clave es cómo escribir el archivo CMakeLists.txt.
A continuación se muestra cómo escribir el archivo CMakeLists.txt de manera progresiva.
1. El uso más simple de CMakeLists.txt
En una prueba de carpeta vacía, cree el archivo testFunc.c para almacenar la función de la siguiente manera:
#include <stdio.h>
#include "testFunc.h"
void func(int data)
{
printf("data is %d\n", data);
}Cree el archivo .h correspondiente a testFunc.c de la siguiente manera:
#ifndef _test_FUNC_H
#define _test_FUNC_H
void func(int data);
#endifEn la carpeta de prueba, cree main.cy edítelo de la siguiente manera:
#include <stdio.h>
int main(void)
{
func(100);
return 0;
}Luego, aún en la carpeta de prueba, escriba CMakeLists.txt de la siguiente manera:
cmake_minimum_required(VERSION 2.8)
project(demo)
add_executable(main main.c)Entre ellos, las dos declaraciones cmake_minimum y project son obligatorias , una especifica los requisitos mínimos para la versión cmake y la otra especifica el nombre del proyecto.
add_executable (main main.c) significa que el archivo .c que se utilizará en este proyecto es main.c, y el archivo ejecutable final generado por este proyecto se denomina main.
Luego ejecute cmake .. y haga en la carpeta de prueba para generar archivos ejecutables.
En este caso, donde todos los .cy todos los .h están en el mismo directorio, no es necesario escribir declaraciones como include_directories (que se usa para indicar dónde se almacena el archivo .h) al escribir CMakeLists.txt, sino todos los .c archivos Simplemente introdúzcalo en add_executable.
(El contenido de cada archivo no se escribirá claramente más adelante, está incluido en el blog original . Este artículo solo escribe el archivo MakeLists)
2. Cuando hay varias funciones, es conveniente utilizar la instrucción aux_source_directiory para almacenar todos los archivos .c en una variable personalizada. como sigue:
En la carpeta de prueba, hay testFunc.c, testFunc.h, testFunc1.c, testFunc1.hy main.c.
Sigue siendo cierto que todos los archivos pertenecen a la misma carpeta.
Para mayor comodidad, puede introducir la instrucción aux_source_directory y escribir el archivo MakeLists.txt de la siguiente manera:
cmake_minimum_required(VERSION 2.8)
project(demo)
aux_source_directory(. SRC_LIST)
add_executable(main ${SRC_LIST})Aquí es solo para enfatizar el rol de aux_source_directory, que es encapsular todos los archivos .c en un directorio en una variable personalizada.
3. Para facilitar la búsqueda, colocamos los archivos .cy .h de diferentes funciones en diferentes carpetas, y el main.cy CMakeLists.txt se ubican en el directorio raíz del proyecto (este artículo es de prueba), el archivo El árbol es el siguiente:
¿Cómo escribir CMakeLists.txt en este momento? como sigue:
cmake_minimum_required(VERSION 2.8)
project(demo)
include_directories(test_func test_func1)#这条语句的参数是文件夹名称，可以有多个参数，这条语句会自动把每个参数文件夹中包含的.h文件纳入到程序中来
aux_source_directory(test_func SRC_LIST)#这条语句只能有一个文件夹、一个自定义的变量作为参数，不可有多个。这条语句会自动把每个参数文件夹中包含的.c文件纳入到程序中来
aux_source_directory(test_func1 SRC_LIST1)#同上
add_executable(main main.c ${SRC_LIST} ${SRC_LIST1})La característica principal de este ejemplo es que el archivo .h está contenido en múltiples rutas diferentes en lugar de solo una ruta como antes. En este caso, utilice la función include_directories para incluir todas las rutas que incluyan .h.
Además, no tenga demasiado miedo de la instrucción aux_source_directory, es solo por la conveniencia de incluir todos los archivos .c de la carpeta en una variable, para facilitar el uso de add_executable.
En cuarto lugar, para facilitar la búsqueda y el uso, generalmente, el directorio raíz del proyecto (este artículo es de prueba) contiene 4 subdirectorios, a saber, bin, build, include, src y src almacena todos los archivos .c (incluido main. c) Archivos. C de todas las funciones), include almacena todos los archivos .h, build almacena los archivos generados por cmake y bin almacena los archivos ejecutables finales generados.
La estructura del árbol de archivos es la siguiente:
En este caso, hay un archivo CMakeLists.txt en prueba y un archivo CMakeLists.txt en src.
El archivo CMakeLists.txt en prueba es para mostrar dónde están los archivos de origen, es decir, dónde está src; y el archivo CMakeLists.txt en src es para mostrar dónde están los archivos como .h.
Entre ellos, el archivo CMakeLists.txt en prueba es el siguiente:
cmake_minimum_required(VERSION 2.8)
project(demo)
add_subdirectory(src)add_subdirectoroy es para decirle al programa en qué carpeta se encuentra el archivo de origen (es decir, el archivo .c).
Para CMakeLists.txt en src, tenga en cuenta que no es necesario escribir cmake_minimum_required y project. El archivo CMakeLists.txt en src es el siguiente:
aux_source_directory(. SRC_LIST)
include_directories(../include)
add_executable(main SRC_LIST)
set(EXECUTABLE_OUTPUT_PATH ${PROJECT_SOURCE_DIR}/bin)Comparando el archivo CMakeLists.txt en el paso "tres", no es difícil encontrar que el archivo CMakeLists.txt en este src también contiene
(1) Especifique la carpeta de inclusión donde se encuentra el archivo .h
(2) Incluya todos los archivos .c en una o algunas variables
(3) add_executable
Tres pasos.
Pero además, el conjunto de instrucciones (EXECUTABLE_OUTPUT_PATH $ {PROJECT_SOURCE_DIR} / bin) se agrega aquí, que es para especificar que el archivo ejecutable generado se coloca en la carpeta bin.
Finalmente, vaya al directorio de compilación y ejecute cmake .., y luego ejecute make, puede encontrar el archivo ejecutable generado en el contenedor.
Cinco, crea bibliotecas estáticas y dinámicas
Reconstruya el árbol de archivos en la siguiente estructura:
Hay un archivo CMakeLists.txt en prueba y tres carpetas de compilación, lib y lib_testFunc. Entre ellas, la carpeta de compilación se usa para almacenar los archivos generados por cmake, y la lib se usa para almacenar la biblioteca estática final y dinámica. archivos de la biblioteca En lib_testFunc Almacene todos los archivos .cy los archivos .h necesarios.
El contenido del archivo CMakeLists.txt en la prueba es el siguiente, que es el mismo que en el paso "cuatro":
cmake_minimum_required(VERSION 2.8)
project(demo)
add_subdirectory(lib_testFunc)El contenido del archivo CMakeLists.txt en lib_testFunc es el siguiente:
aux_source_directory(. SRC_LIST)
add_library(testFunc_shared SHARED ${SRC_LIST})
add_library(testFunc_static STATIC ${SRC_LIST})
set_target_properties(testFunc_shared PROPERTIES OUTPUT_NAME "test_Func")
set_target_properties(testFunc_static PROPERTIES OUTPUT_NAME "test_Func")
set(LIBRARY_OUTPUT_PATH ${PROJECT_SOURCE_DIR}/lib)Este archivo en realidad contiene tres partes:
(1) Utilice la instrucción aux_source_directory para incluir todos los archivos .c en una variable personalizada SRC_LIST
(2) Use add_library con SRC_LIST para generar bibliotecas dinámicas (compartidas) y bibliotecas estáticas (estáticas)
Y use set_target_properties para cambiar el nombre del archivo de biblioteca generado a "test_Func" (porque una es una biblioteca dinámica y la otra es una biblioteca estática, los sufijos de los dos archivos de la biblioteca son diferentes, por lo que aquí puede llamarlos a ambos test_Func, que aún puede ser distinguido)
(3) Use la instrucción set para especificar la carpeta donde se almacena el inventario final generado, similar a la anterior, usamos la instrucción set para especificar la carpeta donde se almacena el archivo ejecutable final generado.
En sexto lugar, vincule main.c con el archivo de la biblioteca.
Reestructura el árbol de archivos de la siguiente manera:
No hay carpeta de inclusión aquí, porque ponemos .h en lib_testFunc
El contenido del archivo CMakeLists.txt en la carpeta de prueba es el siguiente:
cmake_minimum_required(VERSION 2.8)
project(demo)
add_subdirectory(lib_testFunc)
add_subdirectory(src)Además de agregar la ruta donde se encuentra el archivo fuente de la función testFunc.c, también necesita agregar la ruta donde se encuentra el archivo fuente de main.c, todos los cuales se agregan con add_subdirectory.
El contenido del archivo CMakeLists.txt en la carpeta src es el siguiente:
aux_source_directory(. SRC_LIST)
include_directories(../lib_testFunc)
link_directories(${PROJECT_SOURCE_DIR}/lib)
add_executable(main ${SRC_LIST})
target_link_libraries(main testFunc)
set(EXECUTABLE_OUTPUT_PATH ${PROJECT_SOURCE_DIR}/bin)Atención, para este archivo CMakeLists.txt en src, ¿cuál es la diferencia entre cuando el archivo de biblioteca no se usó antes y cuando el archivo de biblioteca se usa ahora?
Después de usar el archivo de la biblioteca, no necesitamos agregar el archivo .c de la función, solo use include_directories para agregar el archivo .h de la función; además, lo nuevo es que necesitamos usar link_direcctories para especificar la ruta de la biblioteca de búsqueda , y en la declaración add_executable Después de eso, vincule el nombre del archivo ejecutable main con el nombre de la biblioteca testFunc, usando la declaración target_link_libraries.
Finalmente, use set para generar archivos ejecutables.