cmake教程

​

一. CMake流程

​​

二. CMake使用

1. 注释

# 这是一个 CMakeLists.txt 文件
cmake_minimum_required(VERSION 3.0.0)

2. add_executable

定义工程会生成一个可执行程序

add_executable(可执行程序名 源文件名称)

# 样式1
add_executable(app add.c div.c main.c mult.c sub.c)

3. set

将文件名对应的字符串存储起来

# SET 指令的语法是：
# [] 中的参数为可选项, 如不需要可以不写
SET(VAR [VALUE] [CACHE TYPE DOCSTRING [FORCE]])

# 方式1: 各个源文件之间使用空格间隔
# set(SRC_LIST add.c  div.c   main.c  mult.c  sub.c)

# 方式2: 各个源文件之间使用分号 ; 间隔
set(SRC_LIST add.c;div.c;main.c;mult.c;sub.c)

4. 指定C++的标准

#增加-std=c++11
set(CMAKE_CXX_STANDARD 11)
#增加-std=c++14
set(CMAKE_CXX_STANDARD 14)
#增加-std=c++17
set(CMAKE_CXX_STANDARD 17)

5. 指定输出的路径

在CMake中指定可执行程序输出的路径，也对应一个宏，叫做EXECUTABLE_OUTPUT_PATH，它的值还是通过set命令进行设置:

set(HOME /home/robin/Linux/Sort)
set(EXECUTABLE_OUTPUT_PATH ${HOME}/bin)

• 第一行：定义一个变量用于存储一个绝对路径
• 第二行：将拼接好的路径值设置给EXECUTABLE_OUTPUT_PATH宏
  • 如果这个路径中的子目录不存在，会自动生成，无需自己手动创建

6. 搜索文件

方式一

在 CMake 中使用aux_source_directory 命令可以查找某个路径下的所有源文件，命令格式为：

aux_source_directory(< dir > < variable >)

• dir：要搜索的目录
• variable：将从dir目录下搜索到的源文件列表存储到该变量中

方式二

file(GLOB/GLOB_RECURSE 变量名 要搜索的文件路径和文件类型)

• GLOB: 将指定目录下搜索到的满足条件的所有文件名生成一个列表，并将其存储到变量中。
• GLOB_RECURSE：递归搜索指定目录，将搜索到的满足条件的文件名生成一个列表，并将其存储到变量中。

file(GLOB MAIN_SRC ${CMAKE_CURRENT_SOURCE_DIR}/src/*.cpp)
file(GLOB MAIN_HEAD ${CMAKE_CURRENT_SOURCE_DIR}/include/*.h)

CMAKE_CURRENT_SOURCE_DIR 宏表示当前访问的 CMakeLists.txt 文件所在的路径。

7. 包含头文件

include_directories(${PROJECT_SOURCE_DIR}/include)

PROJECT_SOURCE_DIR宏对应的值就是我们在使用cmake命令时，后面紧跟的目录，一般是工程的根目录。

8. 制作动态库或静态库

8.1 制作静态库

add_library(库名称 STATIC 源文件1 [源文件2] ...) 

在Linux中，静态库名字分为三部分：lib+库名字+.a，此处只需要指定出库的名字就可以了，另外两部分在生成该文件的时候会自动填充。

file(GLOB SRC_LIST "${CMAKE_CURRENT_SOURCE_DIR}/src/*.cpp")
add_library(calc STATIC ${SRC_LIST})

这样最终就会生成对应的静态库文件libcalc.a

8.2 制作动态库

add_library(库名称 SHARED 源文件1 [源文件2] ...) 

在Linux中，动态库名字分为三部分：lib+库名字+.so，此处只需要指定出库的名字就可以了，另外两部分在生成该文件的时候会自动填充

file(GLOB SRC_LIST "${CMAKE_CURRENT_SOURCE_DIR}/src/*.cpp")
add_library(calc SHARED ${SRC_LIST})

这样最终就会生成对应的动态库文件libcalc.so

8.3 指定输出的路径

​由于在Linux下生成的静态库默认不具有可执行权限，所以在指定静态库生成的路径的时候就不能使用EXECUTABLE_OUTPUT_PATH宏了，而应该使用LIBRARY_OUTPUT_PATH，这个宏对应静态库文件和动态库文件都适用

file(GLOB SRC_LIST "${CMAKE_CURRENT_SOURCE_DIR}/src/*.cpp")
# 设置动态库/静态库生成路径
set(LIBRARY_OUTPUT_PATH ${PROJECT_SOURCE_DIR}/lib)
# 生成动态库
add_library(calc SHARED ${SRC_LIST})
# 生成静态库
add_library(calc STATIC ${SRC_LIST})

9. 链接库

在编写程序的过程中，可能会用到一些系统提供的动态库或者自己制作出的动态库或者静态库文件，cmake中也为我们提供了相关的加载动态库的命令

9.1 链接静态库

首先先指定静态库的路径

link_directories(<lib path>)

链接静态库

link_libraries(<static lib> [<static lib>...])

• 参数1：指定出要链接的静态库的名字
  • 可以是全名 libxxx.a
  • 也可以是掐头（lib）去尾（.a）之后的名字 xxx
• 参数2-N：要链接的其它静态库的名字

# 包含静态库路径
link_directories(${PROJECT_SOURCE_DIR}/lib)
# 链接静态库, calc为静态库的名字
link_libraries(calc) 

9.2 链接动态库

动态库的链接和静态库是完全不同的：

• 静态库会在生成可执行程序的链接阶段被打包到可执行程序中，所以可执行程序启动，静态库就被加载到内存中了。
• 动态库在生成可执行程序的链接阶段不会被打包到可执行程序中，当可执行程序被启动并且调用了动态库中的函数的时候，动态库才会被加载到内存

因此，在cmake中指定要链接的动态库的时候，应该将命令写到生成了可执行文件之后：

cmake_minimum_required(VERSION 3.0)
project(TEST)
file(GLOB SRC_LIST ${CMAKE_CURRENT_SOURCE_DIR}/*.cpp)
#指定要链接的动态库的路径
link_directories(${PROJECT_SOURCE_DIR}/lib)
# 添加并指定最终生成的可执行程序名
add_executable(app ${SRC_LIST})
# 指定可执行程序要链接的动态库名字
target_link_libraries(app pthread)

10. 预定义宏

三. 构建项目

先来看一下下面的这个的目录结构：

$ tree
.
├── build
├── calc
│   ├── add.cpp
│   ├── CMakeLists.txt
│   ├── div.cpp
│   ├── mult.cpp
│   └── sub.cpp
├── CMakeLists.txt
├── include
│   ├── calc.h
│   └── sort.h
├── sort
│   ├── CMakeLists.txt
│   ├── insert.cpp
│   └── select.cpp
├── test1
│   ├── calc.cpp
│   └── CMakeLists.txt
└── test2
    ├── CMakeLists.txt
    └── sort.cpp

6 directories, 15 files

• include 目录：头文件目录
• calc 目录：目录中的四个源文件对应的加、减、乘、除算法
  • 对应的头文件是include中的calc.h
• sort 目录 ：目录中的两个源文件对应的是插入排序和选择排序算法
  • 对应的头文件是include中的sort.h
• test1 目录：测试目录，对加、减、乘、除算法进行测试
• test2 目录：测试目录，对排序算法进行测试

1. 涉及的文件

1.1 calc

add.cpp:

#include "calc.h"

int add(int a, int b)
{
    return a+b;
}

div.cpp:

#include "calc.h"

double divide(int a, int b)
{
    return (double)a/b;
}

mult.cpp:

#include "calc.h"

int multiply(int a, int b)
{
    return a*b;
}

sub.cpp:

#include "calc.h"

int subtract(int a, int b)
{
    return a-b;
}

1.2 include

calc.h:

#ifndef _CALC_H
#define _CALC_H
#include <iostream>
using namespace std;
// 加法
int add(int a, int b);
// 减法
int subtract(int a, int b);
// 乘法
int multiply(int a, int b);
// 除法
double divide(int a, int b);
#endif

sort.h:

#ifndef _SORT_H
#define _SORT_H
// 加法
#include <iostream>
using namespace std;
void fun();
void fun1();
void fun2();
// 减法
// 乘法
#endif

1.3 sort

insert.cpp

void print(int a[], int n)
{
    for(int j= 0; j<n; j++)
        {
            cout<<a[j] <<"  ";
        }
    cout<<endl;
}

void insert(int a[], int n)
{
   for(int i = 1; i < n; i++) //第一个元素作为基准元素，从第二个元素开始把其插到正确的位置
   {
          if(a[i] < a[i-1]) //如果第i个元素比前面的元素小
          {
              int j = i-1;     //需要判断第i个元素与前面的多个元素的大小，换成j继续判断
              int x = a[i]; //将第i个元素复制为哨兵
              while(j >= 0 && x < a[j]) //找哨兵的正确位置，比哨兵大的元素依次后移
              {
                 a[j+1] = a[j];
                 j--;
              }
              a[j+1] = x;  //把哨兵插入到正确的位置
          }
   }
}

select.cpp:

void print1(int a[], int n)
{
    for(int j= 0; j<n; j++)
        {
        cout<<a[j] <<"  ";
    }
    cout<<endl;
}

void select(int a[], int len)
{

        int minindex, temp;
        for(int i = 0; i<len-1;i++)
        {
            minindex = i;
            for(int j = i+1; j<len; j++)
                {
                    if(a[j]<a[minindex])
                                minindex = j;

                }
                temp = a[i];
                a[i] = a[minindex];
                a[minindex] = temp;
        }
}

1.4 test1

calc.cpp:

#include <stdio.h>
#include "calc.h"

int main()
{
    int a = 20;
    int b = 12;
    printf("a = %d, b = %d\n", a, b);
    printf("a + b = %d\n", add(a, b));
    printf("a - b = %d\n", subtract(a, b));
    printf("a * b = %d\n", multiply(a, b));
    printf("a / b = %f\n", divide(a, b));
    return 0;
}

1.5 test2

sort.cpp:

#include "sort.h"
int  main()
{
    int a[10] = {8,1,9,7,2,4,5,6,10,3};
    insert(a,10);
    cout<<"插入排序结果：";
    print(a,10);
    select(a, 10);
    cout << "选择排序结果: ";
    print1(a, 10);
}

2. 准备工作

2.1 节点关系

众所周知，Linux的目录是树状结构，所以嵌套的 CMake 也是一个树状结构，最顶层的 CMakeLists.txt 是根节点，其次都是子节点。因此，我们需要了解一些关于 CMakeLists.txt 文件变量作用域的一些信息：

• 根节点CMakeLists.txt中的变量全局有效
• 父节点CMakeLists.txt中的变量可以在子节点中使用
• 子节点CMakeLists.txt中的变量只能在当前节点中使用

2.2 添加子目录

我们还需要知道在 CMake 中父子节点之间的关系是如何建立的，这里需要用到一个 CMake 命令：

add_subdirectory(source_dir [binary_dir] [EXCLUDE_FROM_ALL])

• source_dir：指定了CMakeLists.txt源文件和代码文件的位置，其实就是指定子目录
• binary_dir：指定了输出文件的路径，一般不需要指定，忽略即可。
• EXCLUDE_FROM_ALL：在子路径下的目标默认不会被包含到父路径的ALL目标里，并且也会被排除在IDE工程文件之外。用户必须显式构建在子路径下的目标。
  通过这种方式CMakeLists.txt文件之间的父子关系就被构建出来了。

3. 解决问题

在上面的目录中我们要做如下事情：

• 通过 test1 目录中的测试文件进行计算器相关的测试
• 通过 test2 目录中的测试文件进行排序相关的测试
  现在相当于是要进行模块化测试，对于calc和sort目录中的源文件来说，可以将它们先编译成库文件（可以是静态库也可以是动态库）然后在提供给测试文件使用即可。库文件的本质其实还是代码，只不过是从文本格式变成了二进制格式。

3.1 根目录

根目录中的 CMakeLists.txt文件内容如下：

cmake_minimum_required(VERSION 3.0)
project(test)
# 定义变量
# 静态库生成的路径
set(LIB_PATH ${CMAKE_CURRENT_SOURCE_DIR}/lib)
# 测试程序生成的路径
set(EXEC_PATH ${CMAKE_CURRENT_SOURCE_DIR}/bin)
# 头文件目录
set(HEAD_PATH ${CMAKE_CURRENT_SOURCE_DIR}/include)
# 静态库的名字
set(CALC_LIB calc)
set(SORT_LIB sort)
#可执行程序的名字
set(APP_NAME_1 test1)
set(APP_NAME_2 test2)
#添加子目录
add_subdirectory(calc)
add_subdirectory(sort)
add_subdirectory(test1)
add_subdirectory(test2)

在根节点对应的文件中主要做了两件事情：定义全局变量和添加子目录。

• 定义的全局变量主要是给子节点使用，目的是为了提高子节点中的CMakeLists.txt文件的可读性和可维护性，避免冗余并降低出差的概率。
• 一共添加了四个子目录，每个子目录中都有一个CMakeLists.txt文件，这样它们的父子关系就被确定下来了。

3.2 calc目录

calc 目录中的 CMakeLists.txt文件内容如下：

cmake_minimum_required(VERSION 3.0)
project(CALCLIB)
aux_source_directory(./ SRC)
include_directories(${HEAD_PATH})
set(LIBRARY_OUTPUT_PATH ${LIB_PATH})
add_library(${CALC_LIB} STATIC ${SRC})

• 第3行aux_source_directory：搜索当前目录（calc目录）下的所有源文件
• 第4行include_directories：包含头文件路径，HEAD_PATH是在根节点文件中定义的
• 第5行set：设置库的生成的路径，LIB_PATH是在根节点文件中定义的
• 第6行add_library：生成静态库，静态库名字CALC_LIB是在根节点文件中定义的

3.3 sort 目录

sort 目录中的 CMakeLists.txt文件内容如下：

cmake_minimum_required(VERSION 3.0)
project(SORTLIB)
aux_source_directory(./ SRC)
include_directories(${HEAD_PATH})
set(LIBRARY_OUTPUT_PATH ${LIB_PATH})
add_library(${SORT_LIB} SHARED ${SRC})

第6行add_library：生成动态库，动态库名字SORT_LIB是在根节点文件中定义的

在生成库文件的时候，这个库可以是静态库也可以是动态库，一般需要根据实际情况来确定。如果生成的库比较大，建议将其制作成动态库。

3.4 test1

test1 目录中的 CMakeLists.txt文件内容如下：

cmake_minimum_required(VERSION 3.0)
project(CALCTEST)
aux_source_directory(./ SRC)
include_directories(${HEAD_PATH})
link_directories(${LIB_PATH})
link_libraries(${CALC_LIB})
set(EXECUTABLE_OUTPUT_PATH ${EXEC_PATH})
add_executable(${APP_NAME_1} ${SRC})

• 第4行include_directories：指定头文件路径，HEAD_PATH变量是在根节点文件中定义的
• 第6行link_libraries：指定可执行程序要链接的静态库，CALC_LIB变量是在根节点文件中定义的
• 第7行set：指定可执行程序生成的路径，EXEC_PATH变量是在根节点文件中定义的
• 第8行add_executable：生成可执行程序，APP_NAME_1变量是在根节点文件中定义的

此处的可执行程序链接的是静态库，最终静态库会被打包到可执行程序中，可执行程序启动之后，静态库也就随之被加载到内存中了。

3.5 test2

test2 目录中的 CMakeLists.txt文件内容如下：

cmake_minimum_required(VERSION 3.0)
project(SORTTEST)
aux_source_directory(./ SRC)
include_directories(${HEAD_PATH})
set(EXECUTABLE_OUTPUT_PATH ${EXEC_PATH})
link_directories(${LIB_PATH})
add_executable(${APP_NAME_2} ${SRC})
target_link_libraries(${APP_NAME_2} ${SORT_LIB})

• 第四行include_directories：包含头文件路径，HEAD_PATH变量是在根节点文件中定义的
• 第五行set：指定可执行程序生成的路径，EXEC_PATH变量是在根节点文件中定义的
• 第六行link_directories：指定可执行程序要链接的动态库的路径，LIB_PATH变量是在根节点文件中定义的
• 第七行add_executable：生成可执行程序，APP_NAME_2变量是在根节点文件中定义的
  第八行target_link_libraries：指定可执行程序要链接的动态库的名字

在生成可执行程序的时候，动态库不会被打包到可执行程序内部。当可执行程序启动之后动态库也不会被加载到内存，只有可执行程序调用了动态库中的函数的时候，动态库才会被加载到内存中，且多个进程可以共用内存中的同一个动态库，所以动态库又叫共享库。

3.6 构建项目

一切准备就绪之后，开始构建项目，进入到根节点目录的build 目录中，执行cmake 命令，如下：

cmake ..
-- The C compiler identification is GNU 11.3.0
-- The CXX compiler identification is GNU 11.3.0
-- Detecting C compiler ABI info
-- Detecting C compiler ABI info - done
-- Check for working C compiler: /usr/bin/cc - skipped
-- Detecting C compile features
-- Detecting C compile features - done
-- Detecting CXX compiler ABI info
-- Detecting CXX compiler ABI info - done
-- Check for working CXX compiler: /usr/bin/c++ - skipped
-- Detecting CXX compile features
-- Detecting CXX compile features - done
-- Configuring done
-- Generating done
-- Build files have been written to: /root/backup/cmake/t2/build

然后在build 目录下执行make 命令:

 make 
[  8%] Building CXX object calc/CMakeFiles/calc.dir/add.cpp.o
[ 16%] Building CXX object calc/CMakeFiles/calc.dir/div.cpp.o
[ 25%] Building CXX object calc/CMakeFiles/calc.dir/mult.cpp.o
[ 33%] Building CXX object calc/CMakeFiles/calc.dir/sub.cpp.o
[ 41%] Linking CXX static library ../../lib/libcalc.a
[ 41%] Built target calc
[ 50%] Building CXX object sort/CMakeFiles/sort.dir/insert.cpp.o
[ 58%] Building CXX object sort/CMakeFiles/sort.dir/select.cpp.o
[ 66%] Linking CXX shared library ../../lib/libsort.so
[ 66%] Built target sort
[ 75%] Building CXX object test1/CMakeFiles/test1.dir/calc.cpp.o
[ 83%] Linking CXX executable ../../bin/test1
[ 83%] Built target test1
[ 91%] Building CXX object test2/CMakeFiles/test2.dir/sort.cpp.o
[100%] Linking CXX executable ../../bin/test2
[100%] Built target test2

通过上图可以得到如下信息：

在项目根目录的lib目录中生成了静态库libcalc.a
在项目根目录的lib目录中生成了动态库libsort.so
在项目根目录的bin目录中生成了可执行程序test1
在项目根目录的bin目录中生成了可执行程序test2
最后再来看一下上面提到的这些文件是否真的被生成到对应的目录中了:

$ tree bin/ lib/
bin/
├── test1
└── test2
lib/
├── libcalc.a
└── libsort.so

写在最后：
在项目中，如果将程序中的某个模块制作成了动态库或者静态库并且在CMakeLists.txt 中指定了库的输出目录，而后其它模块又需要加载这个生成的库文件，此时直接使用就可以了，如果没有指定库的输出路径或者需要直接加载外部提供的库文件，此时就需要使用 link_directories 将库文件路径指定出来。