linux中CMake工具的入门使用

1. 什么是CMake

我们经常会在编写程序的时候经常要使用到Makefile去管理我们的程序，使其容易的进行管理和编译，但是makefile的语法是比较复杂不是那么通俗易懂，而且每个平台的语法都有些许差异，因此急需要个makefile的编写工具，cmake就是一个非常好的选项，以下是cmake的好处。

• CMake是一个可以跨平台的makefile的编译工具
• CMake的语法比较简单，通俗易懂。常用的也就那几个方面

2. CMake生成Makefile的步骤

1. 编写CMake文件CMakeLists.txt；
2. 执行命令cmake PATH生成Makefile文件
3. 使用make进行编译

3. CMake的安装

以下是我的开发环境说明：

• 我的环境是ubuntu2004
• 系统自带gcc编译器
• window上的安装没有进行说明，具体可以上官网看
• 有些系统自带CMake的可以略过

3.2 安装方法

1. 安装方法1

sudo apt-get install cmake #安装cmake
cmake -version #输入查看cmake版本

# cmake version 3.13.4
# CMake suite maintained and supported by Kitware (kitware.com/cmake).
# 可以看出使用apt默认的安装版本是3.13.4,若有要安装最新的版本，可以到cmake的官网上查找，具体查看方法二

1. 安装方法2

# 1. 卸载现有版本cmake，想下载官网最新的CMake版本，先卸载原来的
sudo apt-get autoremove cmake

# 2. 查看当前系统位数
getconf LONG_BIT

# 3. 自己系统对应的版本
1. cmake官网 ：https://cmake.org/download/
2. 找到最新版本camke，当前最新版本为3.18
3. 下载并安装
	3.1 wget https://github.com/Kitware/CMake/releases/download/v3.18.0-rc3/cmake-3.18.0-rc3.tar.gz
	3.2 sudo tar zxvf cmake-3.18.0-rc3.tar.gz
	3.3 cd cmake-3.18.0-rc3
	3.4 sudo ./configure 
	3.5 sudo make -j2
	3.6 sudo make install
4. 查看是否安装成功 cmake -version

cmake version 3.18.0-rc3

CMake suite maintained and supported by Kitware (kitware.com/cmake).

4. CMake的使用

通过每个小案例慢慢组合成一个大项目

4.1 CMake的小试牛刀

目标：编写一个程序，使用CMake生成可执行程序

# 程序的目录结构如下：
geekfong@ubuntu:~/cmake_project$ tree
.
└── hellocmake.c

c语言程序如下:

#include

int main(void)
{
    printf("hello cmake\n");
}

//平常我们编译程序的时候只需要 gcc -o hellocmake.c hellocmake既可，下面使用CMake去编写

CMake编译程序：

1. 在当前目录新建CMakeLists.txt文件(名字必须要这个);

2. 在CMakeLists.txt输入下面指令

   cmake_minimum_required(VERSION 3.1) #限制cmake的最低版本
   project(hellocmake) #定义项目名自定义命名
   add_executeable(hellocmake hellocmake.c) #第一个参数标识生成运行程序的名字，第二个参数是要编译的源文件
   

3. 编译CMake

   geekfong@ubuntu:~/cmake_project$ cmake .
   -- The C compiler identification is GNU 7.5.0
   -- The CXX compiler identification is GNU 7.5.0
   -- Check for working C compiler: /usr/bin/cc
   -- Check for working C compiler: /usr/bin/cc -- works
   -- Detecting C compiler ABI info
   -- Detecting C compiler ABI info - done
   -- Detecting C compile features
   -- Detecting C compile features - done
   -- Check for working CXX compiler: /usr/bin/c++
   -- Check for working CXX compiler: /usr/bin/c++ -- works
   -- Detecting CXX compiler ABI info
   -- Detecting CXX compiler ABI info - done
   -- Detecting CXX compile features
   -- Detecting CXX compile features - done
   -- Configuring done
   -- Generating done
   -- Build files have been written to: /home/geekfong/cmake_project
   
   在如果你编译的效果和我一样，说明你编译成功。然后我们再看一下目录结构
   .
   ├── CMakeCache.txt
   ├── CMakeFiles
   │   ├── 3.10.2
   │   ├── cmake.check_cache
   │   ├── CMakeDirectoryInformation.cmake
   │   ├── CMakeOutput.log
   │   ├── CMakeTmp
   │   ├── feature_tests.bin
   │   ├── feature_tests.c
   │   ├── feature_tests.cxx
   │   ├── hellocmake.dir
   │   ├── Makefile2
   │   ├── Makefile.cmake
   │   ├── progress.marks
   │   └── TargetDirectories.txt
   ├── cmake_install.cmake
   ├── CMakeLists.txt
   ├── hellocmake.c
   └── Makefile （这就是使用CMake生成的Makefile文件）
   
   其他的文件和文件夹都是CMake编译的缓存文件等，不需要理会，我们只需要关注MakeFile就行
   

4. 编译Makefile

   geekfong@ubuntu:~/cmake_project$ make
   Scanning dependencies of target hellocmake
   [ 50%] Building C object CMakeFiles/hellocmake.dir/hellocmake.c.o
   [100%] Linking C executable hellocmake
   [100%] Built target hellocmake
   
   运行程序：
   geekfong@ubuntu:~/cmake_project$ ./hellocmake 
   hello cmake
   

4.2 CMake的进阶之路

上面我们目录结构比较简单，而且编译的文件比较少，而且都在同一文件夹下面，接下来我们要把我们的项目复杂程度提高。

4.2.1 CMake编译同一文件夹下多个源文件

目标：编写一个程序，有多个源文件。使用CMake生成可执行程序

# 程序的目录结构如下：
geekfong@ubuntu:~/cmake_project$ tree
.
├── CMakeLists.txt
├── hellocmake.c
├── hellocmake.h
└── main.c

c语言程序如下:

//hellocmake.c
#include

int printfCMake(void)
{
    printf("hello cmake\n");
    return 0;
}

//hellocmake.h
int printfCMake(void);

//main.c

#include 
#include "hellocmake.h"

int main(void)
{

    printfCMake();
    return 0; 
}

#CMakeLists.txt

cmake_minimum_required(VERSION 3.1) #限制cmake的最低版本
project(hellocmake) #定义项目名自定义命名
include_directories(./) #定义头文件的位置
add_executable(hellocmake main.c hellocmake.c) #第一个参数标识生成运行程序的名字，参数是要编译的源文件

#如果你在同一个文件夹有多个源文件，但是又不想像上面那样一个个输入如何操作，那该怎么操作
可以使用file函数，或者aux_source_directory()
-------------------------------------方法1-----------------------------------------
file(GLOB src_myc ./*.c) #把当前目录的所有C文件名字放在src_myc中
add_executable(hellocmake ${src_myc}) #第一个参数标识生成运行程序的名字，参数是要编译的源文件

-------------------------------------方法2-----------------------------------------
aux_source_directory(. SRC_LIST) #第一个参数是指定目录，第二个参数是存放该目录下所有源文件名字的变量
add_executable(hellocmake ${SRC_LIST}) #第一个参数标识生成运行程序的名字，参数是要编译的源文件

两个区别：aux_source_directory:只能获取当文件夹前源文件 file可以递归获取只需改变file的第一参数即可，改为GLOB_RECURSE。以后用到再说

4.2.2 CMake编译不同文件夹下多个源文件

目标：编写一个程序，有多个源文件在不同文件夹。使用CMake生成可执行程序

# 程序的目录结构如下：
geekfong@ubuntu:~/cmake_project$ tree
.
├── CMakeLists.txt
├── lib_print1
│   ├── hellocmake_1.c
│   └── hellocmake_1.h
├── lib_print2
│   ├── hellocmake_2.c
│   └── hellocmake_2.h
└── main.c

c语言程序如下:

//hellocmake_1.c

#include

int printfCMake_1(void)
{
    printf("hello cmake 1\n");
    return 0;
}

//hellocmake_1.h
int printfCMake_1(void);

//hellocmake_2.c

#include

int printfCMake_2(void)
{
    printf("hello cmake 2\n");
    return 0;
}

//hellocmake_2.h
int printfCMake_2(void);

#include 
#include "hellocmake_1.h"
#include "hellocmake_2.h"

int main(void)
{

    printfCMake_1();
    printfCMake_2();
    return 0; 
}

#CMakeLists.txt

cmake_minimum_required(VERSION 3.1) #限制cmake的最低版本
project(hellocmake) #定义项目名自定义命名

include_directories(./lib_print1)
aux_source_directory(./lib_print1 SRC_LIST1) #第一个参数是指定目录，第二个参数是存放该目录下所有源文件名字的变量

include_directories(./lib_print2)
aux_source_directory(./lib_print2 SRC_LIST2) #第一个参数是指定目录，第二个参数是存放该目录下所有源文件名字的变量

add_executable(hellocmake ${SRC_LIST1} ${SRC_LIST2} main.c) #第一个参数标识生成运行程序的名字，参数是要编译的源文件

4.2.3 CMake链接一些库

在实际的开发过程中，我们总不免的要使用一些别人已经写好的库，或者链接一些我们自己写好的库。

目标：编写一个程序，把源文件编译为库提供给主函数使用。

# 程序的目录结构如下：
geekfong@ubuntu:~/cmake_project$ tree
.
├── CMakeLists.txt
├── lib_print1
│   ├── hellocmake_1.c
│   └── hellocmake_1.h
├── lib_print2
│   ├── hellocmake_2.c
│   └── hellocmake_2.h
└── main.c

# C语言程序和上面的程序是一样的，只是我现在要把 lib_print1和lib_print2编译成库，然后提供给main函数使用

-在此之后我都会建立一个build文件，用于存放编译过程中的缓存文件
.
├── build
├── CMakeLists.txt
├── lib_print1
│   ├── hellocmake_1.c
│   └── hellocmake_1.h
├── lib_print2
│   ├── hellocmake_2.c
│   └── hellocmake_2.h
└── main.c

此处我们需要先把lib_print1和lib_print2编译为动态库和静态库

#CMakeLists.txt

cmake_minimum_required(VERSION 3.1) #限制cmake的最低版本
project(hellocmake) #定义项目名自定义命名

aux_source_directory (./lib_print1 SRC_LIST1)#把当前目录下的源文件存在SRC_LIST变量中

#add_library : 第一个参数指定库名字在本文件使用，第二个参数决定编译为动态库还是静态库，第三个为指定源文件
add_library (hellocmake1_shared SHARED ${SRC_LIST1})#编译为动态库
add_library (hellocmake1_static STATIC ${SRC_LIST1})#编译为静态库

aux_source_directory (./lib_print2 SRC_LIST2)#把当前目录下的源文件存在SRC_LIST变量中
add_library (hellocmake2_shared SHARED ${SRC_LIST2})#编译为动态库
add_library (hellocmake2_static STATIC ${SRC_LIST2})#编译为静态库

在build文件中就生成对应的库了

.
├── build
│   ├── CMakeCache.txt
│   ├── CMakeFiles
│   ├── cmake_install.cmake
│   ├── libhellocmake1_shared.so
│   ├── libhellocmake1_static.a
│   ├── libhellocmake2_shared.so
│   ├── libhellocmake2_static.a
│   └── Makefile
├── CMakeLists.txt
├── lib_print1
│   ├── hellocmake_1.c
│   └── hellocmake_1.h
├── lib_print2
│   ├── hellocmake_2.c
│   └── hellocmake_2.h
└── main.c

#add_library 命令用于生成库文件，在本例中我们传入了两个参数，第一个参数表示库文件的名字，需要注意的是，这个名字是不包含前缀和后缀的名字； 在 Linux 系统中，库文件的前缀是 lib，动态库文件的后缀是.so，而静态库文件的后缀是.a,意味着最终生成的库文件对应的名字会自动添加上前缀和后缀

重新编译，这次链接上main函数

#CMakeLists.txt

cmake_minimum_required(VERSION 3.1) #限制cmake的最低版本
project(hellocmake) #定义项目名自定义命名

aux_source_directory (./lib_print1 SRC_LIST1)#把当前目录下的源文件存在SRC_LIST变量中

#add_library : 第一个参数指定库名字在本文件使用，第二个参数决定编译为动态库还是静态库，第三个为指定源文件
add_library (hellocmake1_shared SHARED ${SRC_LIST1})#编译为动态库
add_library (hellocmake1_static STATIC ${SRC_LIST1})#编译为静态库

aux_source_directory (./lib_print2 SRC_LIST2)#把当前目录下的源文件存在SRC_LIST变量中
add_library (hellocmake2_shared SHARED ${SRC_LIST2})#编译为动态库
add_library (hellocmake2_static STATIC ${SRC_LIST2})#编译为静态库

add_executable(hello main.c)
target_link_libraries(hello hellocmake1_static hellocmake2_static)

#对于设置库文件的输出路径，在之后的章节会讲到

4.2.4 CMake的代码规范化整理

如果按照上面的方式进行写代码的话，我们相信很快你的目录结构会变的很乱，因此这里我们需要重新整理一下目录结构。目录结构如下

├── build
├── CMakeLists.txt
├── lib_src
│   ├── lib_print1
│   └── lib_print2
└── main.c

#lib_print1和lib_print2属于库源码的一部分

对目录结构进行结构化分层，顶层CMakeLists.txt，可以添加底层CMakeLists.txt，相当于顶层定义了一个CMakeLists.txt，告诉底层CMakeLists.txt，你帮我做件事，把lib_print1和lib_print2编译成库。目录结构变成如下

.
├── build
├── CMakeLists.txt
├── lib_src
│   ├── CMakeLists.txt
│   ├── lib_print1
│   └── lib_print2
└── main.c

#顶层CMakeLists.txt

cmake_minimum_required(VERSION 3.1) #限制cmake的最低版本
project(hellocmake) #定义项目名自定义命名

#添加底层CMakeLists.txt
add_subdirectory(lib_src)

#添加搜索的库的头文件
include_directories(./lib_src)

add_executable(hello main.c)
target_link_libraries(hello hellocmake1_static hellocmake2_static)

#低层CMakeLists.txt

#add_library : 第一个参数指定库名字在本文件使用，第二个参数决定编译为动态库还是静态库，第三个为指定源文件
aux_source_directory (./lib_print1 SRC_LIST1)#把当前目录下的源文件存在SRC_LIST变量中
add_library (hellocmake1_shared SHARED ${SRC_LIST1})#编译为动态库
add_library (hellocmake1_static STATIC ${SRC_LIST1})#编译为静态库

aux_source_directory (./lib_print2 SRC_LIST2)#把当前目录下的源文件存在SRC_LIST变量中
add_library (hellocmake2_shared SHARED ${SRC_LIST2})#编译为动态库
add_library (hellocmake2_static STATIC ${SRC_LIST2})#编译为静态库

4.3 CMake的毕业之路

通常4.1和4.2的两部分实践，你基本可以自己通过CMake构建一个项目了，但是想要CMake构建项目变得更加优雅，我们需要知道一些CMake的常用变量

4.3.1 CMake的常用变量

下面是我日常开发中最常用到的变量

#CMake的调试指令
message()：就是print的意思

#下面是CMake常用的变量
PROJECT_SOURCE_DIR：工程顶层目录，也就是顶层 CMakeLists.txt 源码所在目录
PROJECT_BINARY_DIR：生成CMake缓存文件的目录
CMAKE_CURRENT_SOURCE_DIR：当前源码所在路径
CMAKE_PROJECT_NAME：工程名字
EXECUTABLE_OUTPUT_PATH：设置可执行文件的输出路径
LIBRARY_OUTPUT_PATH：设置库文件的输出路径
CMAKE_C_COMPILER：设置c语言交叉编译工具链
CMAKE_CXX_COMPILER：设置c++语言交叉编译工具链，嵌入式开发基本都会送到

#CMakeLists.txt

cmake_minimum_required(VERSION 3.1) #限制cmake的最低版本
project(hellocmake) #定义项目名自定义命名

set(EXECUTABLE_OUTPUT_PATH  "${PROJECT_SOURCE_DIR}/bin")
set(LIBRARY_OUTPUT_PATH "${PROJECT_SOURCE_DIR}/lib")

message(${PROJECT_SOURCE_DIR})
message(${PROJECT_BINARY_DIR})
message(${CMAKE_CURRENT_SOURCE_DIR})
message(${CMAKE_PROJECT_NAME})
message(${EXECUTABLE_OUTPUT_PATH})
message(${LIBRARY_OUTPUT_PATH})

add_subdirectory(lib_src)

include_directories(./lib_src)

add_executable(hello main.c)
target_link_libraries(hello hellocmake1_static hellocmake2_static)

#上面变量在CMake中的输出展示
-- The C compiler identification is GNU 7.5.0
-- The CXX compiler identification is GNU 7.5.0
-- Check for working C compiler: /usr/bin/cc
-- Check for working C compiler: /usr/bin/cc -- works
-- Detecting C compiler ABI info
-- Detecting C compiler ABI info - done
-- Detecting C compile features
-- Detecting C compile features - done
-- Check for working CXX compiler: /usr/bin/c++
-- Check for working CXX compiler: /usr/bin/c++ -- works
-- Detecting CXX compiler ABI info
-- Detecting CXX compiler ABI info - done
-- Detecting CXX compile features
-- Detecting CXX compile features - done
/home/geekfong/cmake_project
/home/geekfong/cmake_project/build
/home/geekfong/cmake_project
hellocmake
/home/geekfong/cmake_project/bin
/home/geekfong/cmake_project/lib
-- Configuring done
-- Generating done
-- Build files have been written to: /home/geekfong/cmake_project/build

从上面可以看出来输出的路径都是对的

4.3.2 设置编译器编译参数

在我们日常的使用过程中，我们可能会经常使用一下编译参数，比如我们常用的到编译器gcc来说，

设置gcc编译器的优化等级，是否使用调试模式等

#CMakeLists.txt
set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -lpthread -std=gnu99 -g -o0") #
set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS}  -W -Wall -Wextra -g2 -ggdb -o0 -lpthread")

#在此处也能链接一些系统的默认库

5. 总结

在此处，我们已经入门了CMake的最主要用法，也是我日常开发中最精彩用到的点。我是一名嵌入式软件开发工程师，在下一章中，我将会公布我日常开发中使用的CMake模板，基本可以套用在所有地方
参考我的：使用cmake构建一个大型项目框架