[Xiao Mu apprend C++] C++ construit des projets d'ingénierie basés sur CMake (Windows, Linux)

1. Introduction

Adresse du site officiel :
https://cmake.org

CMake est un outil d'installation (compilation) multiplateforme, qui peut décrire l'installation (processus de compilation) de toutes les plateformes avec des phrases simples. Il peut produire divers makefiles ou fichiers de projet et peut tester les fonctionnalités C++ prises en charge par le compilateur, similaires à automake sous UNIX. C'est juste que le fichier de configuration de CMake s'appelle CMakeLists.txt.

2. Télécharger cmake

(1) Adresse de téléchargement du site Web officiel un
https://cmake.org/download/

(2) Adresse de téléchargement du site Web officiel 2
https://cmake.org/files/

(3) Adresse de téléchargement GitHub :
https://github.com/Kitware/CMake/releases

Sous le système ubuntu, seule la commande suivante est requise :

# ubuntu
sudo apt install cmake

CMake fournit une variété de versions, y compris, mais sans s'y limiter, la "version RC" (Release Candidate) et la "version stable" (Latest Release). Basculez vers le répertoire où le système stocke le code source, puis utilisez la commande curl pour télécharger le package compressé de distribution binaire de CMake via ce lien :

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. Installez cmake

Une fois le package compressé de la distribution binaire CMake téléchargé, exécutez les deux commandes suivantes pour décompresser le package compressé, déplacez le dossier obtenu dans le répertoire du programme local du système et renommez le dossier en cmake (c'est-à-dire /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

Affichez le chemin après l'installation :

ls /usr/local/cmake

Si vous installez CMake pour la première fois en suivant les étapes de cet article, pour faciliter l'exécution ultérieure des commandes liées à CMake, veuillez exécuter les deux commandes suivantes pour ajouter le répertoire du fichier exécutable CMake à la variable d'environnement système PATH :

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

Voir ~/.bashrc :

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

Vérifiez la version de cmake :

cmake --verison

4. Tester cmake

4.1 Fichier source unique

principal c:

#include <stdio.h>

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

Ensuite, écrivez CMakeLists.txt dans le même répertoire que main.c :

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

Exécuter une commande :

cmake .

Examinons à nouveau les fichiers du répertoire. Le Makefile a été généré avec succès et certains fichiers sont automatiquement générés lors de l'exécution de cmake :

Afficher le Makefile :

vi Makefile

Entrez la commande make pour compiler :

make
ls
./main
#make clean

4.2 Plusieurs fichiers source dans le même répertoire

Installez la commande tree pour afficher la relation hiérarchique des dossiers :

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

tree ./

Modifiez CMakeLists.txt :

cmake_minimum_required (VERSION 2.8)

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

Exécuter une commande :

cmake .
ls
make
./main

S'il existe plusieurs fichiers source dans le même répertoire. cmake fournit une commande pour stocker tous les fichiers source dans un répertoire spécifié dans une variable, cette commande est aux_source_directory(dir var). Le premier paramètre dir est le répertoire spécifié et le second paramètre var est la variable utilisée pour stocker la liste des fichiers source.

Modifiez CMakeLists.txt :

cmake_minimum_required (VERSION 2.8)

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

Utilisez aux_source_directory pour stocker la liste de stockage du fichier source dans le répertoire courant dans la variable SRC_LIST, puis appelez SRC_LIST dans add_executable (notez la manière d'appeler la variable).
aux_source_directory() a également des inconvénients. Il ajoutera tous les fichiers source dans le répertoire spécifié et peut ajouter certains fichiers dont nous n'avons pas besoin. À ce stade, nous pouvons utiliser la commande set pour créer de nouvelles variables pour stocker les fichiers source requis , comme suit:

cmake_minimum_required (VERSION 2.8)

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

4.3 Plusieurs fichiers source dans différents répertoires

Modifiez 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 Structure organisationnelle standard

Généralement, les fichiers source sont placés dans le répertoire src, les fichiers d'en-tête sont placés dans le fichier d'inclusion, les fichiers d'objet générés sont placés dans le répertoire de construction et le fichier de sortie final elf est placé dans le répertoire bin, de sorte que l'ensemble la structure est plus claire.

Modifiez CMakeLists.txt :

cmake_minimum_required (VERSION 2.8)
project (demo)

add_subdirectory (src)

Ici, les fichiers source sont stockés dans le répertoire src.Lorsque cmake est exécuté, il entrera dans le répertoire src pour trouver le CMakeLists.txt dans le répertoire src, créez donc un CMakeLists.txt dans le répertoire src : add CMakeLists.txt
:

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

Il y a un nouveau jeu de commandes ici, qui est utilisé pour définir les variables. EXECUTABLE_OUT_PATH et PROJECT_SOURCE_DIR sont des variables prédéfinies fournies avec CMake. Leurs significations sont les suivantes.

EXECUTABLE_OUTPUT_PATH : L'emplacement de stockage du fichier exécutable binaire cible
PROJECT_SOURCE_DIR : Le répertoire racine du projet

Créez un nouveau dossier de construction et entrez :

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

Vous pouvez également utiliser un seul CMakeLists.txt et modifier le contenu du CMakeLists.txt le plus externe comme suit :

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 Compilation de bibliothèque dynamique et bibliothèque statique

Parfois, il est nécessaire de compiler des bibliothèques dynamiques et des bibliothèques statiques, puis d'attendre que d'autres programmes les utilisent. Le dossier du projet de test est le suivant :

• L'exemple Windows est le suivant :
  
  Le contenu de CMakeLists.txt est le suivant :

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目录

Exécutez cmake dans le répertoire de construction et stockez les fichiers de bibliothèque générés (.dll, .lib) dans le dossier lib et placez l'exe dans le dossier bin. Exécutez la commande comme suit :

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

Ouvrez le dossier build comme suit :

Compilez myrand.sln via la ligne de commande, comme suit.

# 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"

Les résultats d'exécution sont les suivants :

le dossier des résultats d'exécution est le suivant :

4.6 Liaison de la bibliothèque

Ajoutez un main.cpp dans le répertoire src et appelez le fichier de bibliothèque généré dans la section ci-dessus.

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})

Exécuter une commande :

cmake ..

4.7 Ajouter des options de compilation

Ajoutez quelques options de compilation, telles que -Wall, -std=c++11, etc., et vous pouvez utiliser add_compile_options pour fonctionner.

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 Ajouter des options de contrôle

Parfois, ne compilez que du code source spécifié, vous pouvez utiliser la commande cmake option :

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

Le contenu de CMakeLists.txt est le suivant :

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()

main.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. Construire un projet minimal

5.1 Créer un nouveau fichier de code

Editez le fichier de code : tutorial.cpp

• tutoriel.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 Créer un nouveau CMakeLists.txt

Créez un nouveau fichier dans le même dossier : 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 : spécifie le numéro de version minimum de CMake,
project : spécifie le nom du projet,
add_executable : utilisé pour générer des fichiers exécutables, doit spécifier le nom du fichier exécutable généré et des fichiers source associés.

Commencez maintenant à créer, compiler et exécuter l'exemple de code ci-dessus.

5.3 Construire le projet

Dans le dossier de travail du projet en cours, créez un répertoire de construction build.Ensuite, entrez le répertoire de construction et exécutez CMake pour configurer le projet et générer le système de construction.

mkdir build
cd build
cmake ..

• État d'exécution de la commande :
  
• Les fichiers et dossiers générés sont les suivants :
  

5.4 Compiler le projet

Appelez ensuite ce système de construction pour réellement compiler/lier le projet :

cmake --build .

• Les fichiers et dossiers générés sont les suivants :
  

5.5 Exécution du projet

.\debug\Tutorial.exe 3.14

Le résultat de l'opération est le suivant :

5.6 Modifier les fichiers associés

Modifiez le fichier de code : 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} )

Nouveau fichier : TutorialConfig.h.in

• TutorialConfig.h.in

// 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@

Editez le fichier de code : tutorial.cpp

• tutoriel.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;
}

Exécutez la commande suivante :

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

Créer un fichier : TutorialConfig.h
TutorialConfig.h :

épilogue

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