[Xiao Mu aprende C++] C++ construye proyectos de ingeniería basados en CMake (Windows, Linux)

1. Introducción

Dirección del sitio web oficial:
https://cmake.org

CMake es una herramienta de instalación (compilación) multiplataforma, que puede describir la instalación (proceso de compilación) de todas las plataformas con oraciones simples. Puede generar varios archivos MAKE o archivos de proyecto, y puede probar las características de C++ compatibles con el compilador, similar a la creación automática en UNIX. Es solo que el archivo de configuración de CMake se llama CMakeLists.txt.

2. Descargar cmake

(1) Dirección de descarga del sitio web oficial uno
https://cmake.org/download/

(2) Dirección de descarga del sitio web oficial 2
https://cmake.org/files/

(3) Dirección de descarga de GitHub:
https://github.com/Kitware/CMake/releases

Bajo el sistema ubuntu, solo se requiere el siguiente comando:

# ubuntu
sudo apt install cmake

CMake proporciona una variedad de versiones, que incluyen, entre otras, "versión RC" (candidato a lanzamiento) y "versión estable" (último lanzamiento). Cambie al directorio donde el sistema almacena el código fuente y luego use el comando curl para descargar el paquete comprimido de distribución binaria de CMake a través de este enlace:

cd /usr/local/src

curl -LO https://github.com/Kitware/CMake/releases/download/v3.22.2/cmake-3.22.2-linux-x86_64.tar.gz

# or
yum install -y wget
wget -c https://github.com/Kitware/CMake/releases/download/v3.22.2/cmake-3.22.2-linux-x86_64.tar.gz
# wget -c https://cmake.org/files/v3.26/cmake-3.26.0-rc1-linux-x86_64.tar.gz

3. Instalar cmake

Después de descargar el paquete comprimido de distribución binaria de CMake, ejecute los siguientes dos comandos para descomprimir el paquete comprimido, mueva la carpeta obtenida al directorio del programa local del sistema y cambie el nombre de la carpeta a cmake (es decir, /usr/local/cmake):

tar -xvf cmake-3.26.0-rc1-linux-x86_64.tar.gz
# tar zxvf cmake-3.22.2-linux-x86_64.tar.gz
mv cmake-3.26.0-rc1-linux-x86_64 /usr/local/cmake

Ver la ruta después de la instalación:

ls /usr/local/cmake

Si está instalando CMake por primera vez de acuerdo con los pasos de este artículo, para la conveniencia de ejecutar los comandos relacionados con CMake más adelante, ejecute los siguientes dos comandos para agregar el directorio del archivo ejecutable de CMake a la variable de entorno del sistema PATH:

echo 'export PATH="/usr/local/cmake/bin:$PATH"' >> ~/.bashrc
source ~/.bashrc

Ver ~/.bashrc:

vi ~/.bashrc
#在最后添加export PATH=/usr/local/cmake/bin:$PATH

Compruebe la versión de cmake:

cmake --verison

4. Hacer una prueba

4.1 Archivo fuente único

C Principal:

#include <stdio.h>

int main(void)
{
    
    
	printf("Hello World\n");
	return 0;
}

Luego escribe CMakeLists.txt en el mismo directorio que main.c:

cmake_minimum_required (VERSION 2.8)
project (demo)
add_executable(main main.c)

Ejecutando una orden:

cmake .

Echemos un vistazo a los archivos en el directorio nuevamente. El Makefile se generó con éxito, y hay algunos archivos generados automáticamente cuando se ejecuta cmake:

Ver Makefile:

vi Makefile

Ingrese el comando make para compilar:

make
ls
./main
#make clean

4.2 Múltiples archivos fuente en el mismo directorio

Instale el comando de árbol para ver la relación jerárquica de las carpetas:

ubuntu：sudo apt-get install tree
centos：yum -y install tree

tree ./

Modificar CMakeLists.txt:

cmake_minimum_required (VERSION 2.8)

project (demo)
add_executable(main main.c anotherTest.c)

Ejecutando una orden:

cmake .
ls
make
./main

Si hay varios archivos de origen en el mismo directorio. cmake proporciona un comando para almacenar todos los archivos fuente en un directorio específico en una variable, este comando es aux_source_directory(dir var). El primer parámetro dir es el directorio especificado y el segundo parámetro var es la variable utilizada para almacenar la lista de archivos fuente.

Modificar CMakeLists.txt:

cmake_minimum_required (VERSION 2.8)

project (demo)
aux_source_directory(. SRC_LIST)
add_executable(main ${SRC_LIST})

Use aux_source_directory para almacenar la lista de almacenamiento de archivos fuente en el directorio actual en la variable SRC_LIST y luego llame a SRC_LIST en add_executable (observe la forma de llamar a la variable).
aux_source_directory() también tiene desventajas. Agregará todos los archivos fuente en el directorio especificado y puede agregar algunos archivos que no necesitamos. En este momento, podemos usar el comando set para crear nuevas variables para almacenar los archivos fuente requeridos. , como sigue:

cmake_minimum_required (VERSION 2.8)

project (demo)
set( SRC_LIST
	 ./main.c
	 ./anotherTest.c)
	 
add_executable(main ${SRC_LIST})

4.3 Múltiples archivos fuente en diferentes directorios

Modificar CMakeLists.txt:

cmake_minimum_required (VERSION 2.8)
project (demo)

include_directories (test1 test2)

aux_source_directory (test1 SRC_LIST)
aux_source_directory (test2 SRC_LIST1)

add_executable (main main.c ${SRC_LIST} ${SRC_LIST1})

4.4 Estructura organizativa estándar

En general, los archivos de origen se colocan en el directorio src, los archivos de encabezado se colocan en el archivo de inclusión, los archivos de objetos generados se colocan en el directorio de compilación y el archivo elf de salida final se coloca en el directorio bin, de modo que todo la estructura es más clara.

Modificar CMakeLists.txt:

cmake_minimum_required (VERSION 2.8)
project (demo)

add_subdirectory (src)

Aquí, los archivos de origen se almacenan en el directorio src. Cuando se ejecuta cmake, ingresará al directorio src para encontrar CMakeLists.txt en el directorio src, así que cree un CMakeLists.txt en el directorio src: agregue CMakeLists.txt
:

aux_source_directory (. SRC_LIST)
include_directories (../include)
add_executable (main ${SRC_LIST})
set (EXECUTABLE_OUTPUT_PATH ${PROJECT_SOURCE_DIR}/bin)

Hay un nuevo comando establecido aquí, que se usa para definir variables. EXECUTABLE_OUT_PATH y PROJECT_SOURCE_DIR son variables predefinidas que vienen con CMake. Sus significados son los siguientes.

EXECUTABLE_OUTPUT_PATH: la ubicación de almacenamiento del archivo ejecutable binario de destino
PROJECT_SOURCE_DIR: el directorio raíz del proyecto

Cree una nueva carpeta de compilación e ingrese:

mkdir build
cd build
cmake ..
make
ls
../bin/main

También puede usar solo un CMakeLists.txt y cambiar el contenido del CMakeLists.txt más externo de la siguiente manera:

cmake_minimum_required (VERSION 2.8)
project (demo)

set (EXECUTABLE_OUTPUT_PATH ${PROJECT_SOURCE_DIR}/bin)
aux_source_directory (src SRC_LIST)
include_directories (include)
add_executable (main ${SRC_LIST})

4.5 Compilación de biblioteca dinámica y biblioteca estática

A veces es necesario compilar bibliotecas dinámicas y bibliotecas estáticas, y luego esperar a que otros programas las usen. La carpeta del proyecto de prueba es la siguiente:

• El ejemplo de Windows es el siguiente:
  
  El contenido de CMakeLists.txt es el siguiente:

cmake_minimum_required (VERSION 2.8)

project (myrand)

# find *.cpp *.c
set (SRC_LIST ${PROJECT_SOURCE_DIR}/src/getRandomAPI.cpp)

# find *.h
include_directories (${PROJECT_SOURCE_DIR}/include)

########################################
# create lib and dll
add_library (myrand_shared SHARED ${SRC_LIST})
add_library (myrand_static STATIC ${SRC_LIST})

set_target_properties (myrand_shared PROPERTIES OUTPUT_NAME "myrand")
set_target_properties (myrand_static PROPERTIES OUTPUT_NAME "myrand_s")

set (LIBRARY_OUTPUT_PATH ${PROJECT_SOURCE_DIR}/lib)

########################################
# create exe
add_compile_options(-std=c++11 -Wall)
set (EXECUTABLE_OUTPUT_PATH ${PROJECT_SOURCE_DIR}/bin)
add_executable (myrand_test ${SRC_LIST})

命令解释如下：
（1）add_library: 生成动态库或静态库(第1个参数指定库的名字；第2个参数决定是动态还是静态，如果没有就默认静态；第3个参数指定生成库的源文件)
（2）set_target_properties: 设置最终生成的库的名称，还有其它功能，如设置库的版本号等等
（3）LIBRARY_OUTPUT_PATH: 库文件的默认输出路径，这里设置为工程目录下的lib目录

Ejecute cmake en el directorio de compilación y almacene los archivos de biblioteca generados (.dll, .lib) en la carpeta lib y coloque el exe en la carpeta bin. Ejecute el comando de la siguiente manera:

cd C:\Users\tomcat\Desktop\test_cmake
mkdir build
cd build
cmake ..

Abra la carpeta de compilación de la siguiente manera:

Compile myrand.sln a través de la línea de comando, de la siguiente manera.

# release x64(默认)
cd C:\Program Files (x86)\Microsoft Visual Studio\2017\Community\Common7\IDE
.\devenv.com C:\Users\tomcat\Desktop\test_cmake\build\myrand.sln /Build

# or debug x64
.\devenv.com F:\00Projects\test.sln /Build "Debug|64"

# or debug win32
.\devenv.com F:\00Projects\test.sln /Build "Debug|Win32"

Los resultados de la ejecución son los siguientes:

la carpeta de resultados de la ejecución es la siguiente:

4.6 Vincular la biblioteca

Agregue un main.cpp en el directorio src y llame al archivo de biblioteca generado en la sección anterior.

cmake_minimum_required (VERSION 2.8)
project (myrand_test)

set (EXECUTABLE_OUTPUT_PATH ${PROJECT_SOURCE_DIR}/bin)
set (SRC_LIST ${PROJECT_SOURCE_DIR}/src/main.cpp)

# find *.h
include_directories (${PROJECT_SOURCE_DIR}/include)

find_library(TEST_LIB NAMES myrand HINTS ${PROJECT_SOURCE_DIR}/lib/debug)

add_executable (test ${SRC_LIST})
target_link_libraries (test ${TEST_LIB})

Ejecutando una orden:

cmake ..

4.7 Añadir opciones de compilación

Agregue algunas opciones de compilación, como -Wall, -std=c++11, etc., y puede usar add_compile_options para operar.

cmake_minimum_required (VERSION 2.8)
project (test)

set (EXECUTABLE_OUTPUT_PATH ${PROJECT_SOURCE_DIR}/bin)
add_compile_options(-std=c++11 -Wall) 
add_executable(test main.cpp)

4.8 Agregar opciones de control

A veces solo compila un código fuente específico, puede usar el comando de opción cmake:

1、本来要生成多个bin或库文件，现在只想生成部分指定的bin或库文件
2、对于同一个bin文件，只想编译其中部分代码（使用宏来控制）

El contenido de CMakeLists.txt es el siguiente:

cmake_minimum_required(VERSION 3.0)
project(test)

set (EXECUTABLE_OUTPUT_PATH ${PROJECT_SOURCE_DIR}/bin)
set (SRC_LIST ${PROJECT_SOURCE_DIR}/src/main.cpp)
set (SRC_LIST2 ${PROJECT_SOURCE_DIR}/src/main2.cpp)

option(USE_TEST_1 "use test 1" OFF)
option(USE_TEST_2 "use test 2" OFF)
option(USE_TEST_3 "use test 3" OFF)

if (USE_TEST_1)
    add_definitions(-DTEST_1)
endif()

if (USE_TEST_2)
    add_definitions(-DTEST_2)
endif()

if (USE_TEST_3)
    add_definitions(-DTEST_3)
endif()

add_executable(main ${SRC_LIST})

if (USE_PROJECT2)
    add_executable(main2 ${SRC_LIST2})
else()
    message(STATUS "No project main2")    
endif()

principal.cpp：

#include <windows.h>
#include <iostream>

int main()
{
    
    
#ifdef TEST_1
	printf("getRandom_1\n");
#endif

#ifdef TEST_2
	printf("getRandom_2\n");
#endif

#ifdef TEST_3
	printf("getRandom_3\n");
#endif

	system("pause");
	return 0;
}

cmake .. -DTEST_3=ON -DTEST_2=OFF -DUSE_PROJECT2=OFF
cmake .. -DTEST_3=ON && make

5. Construye un proyecto mínimo

5.1 Crear un nuevo archivo de código

Edite el archivo de código: tutorial.cpp

• tutorial.cpp

// tutorial.cpp

#include <cmath>
#include <cstdlib>
#include <iostream>
#include <string>

int main(int argc, char* argv[])
{
    
    
    if (argc < 2) {
    
    
        std::cout << "Usage: " << argv[0] << " number" << std::endl;
        return 1;
    }

    // convert input to double
    const double inputValue = atof(argv[1]);

    // calculate square root
    const double outputValue = sqrt(inputValue);
    std::cout << "(爱看书的小沐)The square root of " << inputValue
              << " is " << outputValue
              << std::endl;
    return 0;
}

5.2 Crear un nuevo CMakeLists.txt

Cree un nuevo archivo en la misma carpeta: CMakeLists.txt.

• CMakeLists.txt

cmake_minimum_required(VERSION 3.15)

# set the project name
project(Tutorial)

# add the executable
add_executable(Tutorial tutorial.cpp)

cmake_minimum_required: especifica el número mínimo de versión de CMake,
proyecto: especifica el nombre del proyecto,
add_executable: se usa para generar archivos ejecutables, es necesario especificar el nombre del archivo ejecutable generado y los archivos de origen relacionados.

Ahora comience a construir, compilar y ejecutar el ejemplo de código anterior.

5.3 Construyendo el proyecto

En la carpeta de trabajo del proyecto actual, cree una compilación del directorio de compilación A continuación, ingrese el directorio de compilación y ejecute CMake para configurar el proyecto y generar el sistema de compilación.

mkdir build
cd build
cmake ..

• Estado de ejecución del comando:
  
• Los archivos y carpetas generados son los siguientes:
  

5.4 Compilar el proyecto

Luego invoque ese sistema de compilación para compilar/vincular el proyecto:

cmake --build .

• Los archivos y carpetas generados son los siguientes:
  

5.5 Ejecución del proyecto

.\debug\Tutorial.exe 3.14

El resultado de la operación es el siguiente:

5.6 Modificar archivos relacionados

Edite el archivo de código: CMakeLists.txt

• CMakeLists.txt

cmake_minimum_required(VERSION 3.15)

## set the project name
# project(Tutorial)
project(Tutorial VERSION 1.2.3)

string(TIMESTAMP COMPILE_TIME %Y%m%d-%H%M%S)
configure_file(TutorialConfig.h.in TutorialConfig.h)

# set(SRC_LIST a.cpp b.cpp c.cpp)
SET(SRC_LIST tutorial.cpp)
		   
## add the executable
# add_executable(Tutorial tutorial.cpp)
# add_executable(${PROJECT_NAME} tutorial.cpp)
# add_executable(${PROJECT_NAME} a.cpp b.cpp c.cpp)
add_executable(${
    
    PROJECT_NAME} ${
    
    SRC_LIST})

target_include_directories(${
    
    PROJECT_NAME} PUBLIC
                           ${
    
    PROJECT_BINARY_DIR} )

Nuevo archivo: TutorialConfig.h.in

• TutorialConfig.h.en

// the configured options and settings for Tutorial
#define Tutorial_VERSION_MAJOR @PROJECT_VERSION_MAJOR@
#define Tutorial_VERSION_MINOR @PROJECT_VERSION_MINOR@
#define Tutorial_VERSION_PATCH @PROJECT_VERSION_PATCH@

#define TIMESTAMP @COMPILE_TIME@

Edite el archivo de código: tutorial.cpp

• tutorial.cpp

// tutorial.cpp

#include <cmath>
#include <cstdlib>
#include <iostream>
#include <string>
#include "TutorialConfig.h"

int main(int argc, char* argv[])
{
    
    
    if (argc < 2) {
    
    
    	std::cout << argv[0] << " Version " << Tutorial_VERSION_MAJOR << "."
                << Tutorial_VERSION_MINOR << std::endl;
        std::cout << "Usage: " << argv[0] << " number" << std::endl;
        return 1;
    }

    // convert input to double
    const double inputValue = atof(argv[1]);

    // calculate square root
    const double outputValue = sqrt(inputValue);
    std::cout << "(爱看书的小沐)The square root of " << inputValue
              << " is " << outputValue
              << std::endl;
    return 0;
}

Ejecute el siguiente comando:

cmake --build .
.\debug\Tutorial.exe

Crear archivo: TutorialConfig.h
TutorialConfig.h:

epílogo

如果您觉得该方法或代码有一点点用处，可以给作者点个赞，或打赏杯咖啡；╮(￣▽￣)╭
如果您感觉方法或代码不咋地//(ㄒoㄒ)// ，就在评论处留言，作者继续改进；o_O???
如果您需要相关功能的代码定制化开发，可以留言私信作者；(✿◡‿◡)
感谢各位大佬童鞋们的支持！(´▽´)ﾉ (´▽´)! ! !