CMake入门

课程地址

文档地址

---

HelloWorld

编写一个C++文件：

//hello.cpp
#include <iostream>

int main() {
    std::cout << "hello, world" <<std::endl;
    return 0;
}
1
2
3
4
5
6
7

手动编译：

c++ hello.cpp
1

书写CMakeLists.txt：

PROJECT(HELLO)
SET(SRC_LIST hello.cpp)

MESSAGE(STATUS "This is BINARY dir " ${HELLO_BINARY_DIR})
MESSAGE(STATUS "This is SOURCE dir " ${HELLO_SOURCE_DIR})

ADD_EXECUTABLE(hello ${SRC_LIST})
1
2
3
4
5
6
7

构建，编译，执行：

cmake .
make
./hello
1
2
3

语法

语法的基本原则

• 变量使用${}方式取值，但是在 IF 控制语句中是直接使用变量名
• 指令(参数1 参数2…) 参数使用括弧括起，参数之间使用空格或分号分开
• 指令是大小写无关的，参数和变量是大小写相关的。推荐全部使用大写指令
• SET(SRC_LIST main.cpp) 可以写成 SET(SRC_LIST “main.cpp”)，如果源文件名中含有空格，就必须要加双引号

PROJECT

可以用来指定工程的名字和支持的语言，默认支持所有语言，不同字段之间以空格分隔

PROJECT(HELLO)指定了工程的名字，并且支持所有语言——建议

PROJECT(HELLO CXX)指定了工程的名字，并且支持语言是C++

PROJECT(HELLO C CXX)指定了工程的名字，并且支持语言是C和C++

该指定隐式定义了两个CMAKE的变量：

<projectname>_BINARY_DIR，本例中是 HELLO_BINARY_DIR

<projectname>_SOURCE_DIR，本例中是 HELLO_SOURCE_DIR

MESSAGE关键字就可以直接使用这两个变量，当前都指向当前的工作目录

问题：如果改了工程名，这两个变量名也会改变

解决：又定义两个预定义变量：PROJECT_BINARY_DIR和PROJECT_SOURCE_DIR，这两个变量和HELLO_BINARY_DIR，HELLO_SOURCE_DIR是一致的。所以改了工程名也没有关系

SET

用来显示地指定变量

SET(SRC_LIST main.cpp)：SRC_LIST变量就包含了main.cpp

也可以SET(SRC_LIST main.cpp t1.cpp t2.cpp)

MESSAGE

向终端输出用户自定义的信息

主要包含三种信息：

• SEND_ERROR，产生错误，生成过程被跳过
• SATUS，输出前缀为—的信息
• FATAL_ERROR，立即终止所有 cmake 过程

ADD_EXECUTABLE

生成可执行文件

ADD_EXECUTABLE(hello ${SRC_LIST})：生成的可执行文件名是hello，源文件读取变量SRC_LIST中的内容

也可以直接写 ADD_EXECUTABLE(hello main.cpp)

上述例子可以简化的写成

PROJECT(HELLO)
ADD_EXECUTABLE(hello main.cpp)
1
2

注意：工程名的 HELLO 和生成的可执行文件 hello 是没有任何关系的

内部构建和外部构建

• 上述例子就是内部构建，他生产的临时文件特别多，不方便清理
• 外部构建，就会把生成的临时文件放在build目录下，不会对源文件有任何影响，推荐使用外部构建方式

1、建立一个build目录，可以在任何地方，建议在当前目录下

2、进入build，运行cmake ..，当然..表示上一级目录

3、在build目录下，运行make来构建工程

注意外部构建的两个变量

1、HELLO_SOURCE_DIR 还是工程路径

2、HELLO_BINARY_DIR是编译路径，也就是/project/dir/bulid

-- This is BINARY dir /home/daniel/cm/build
-- This is SOURCE dir /home/daniel/cm
1
2

工程化

• 为工程添加一个子目录 src，用来放置工程源代码
• 添加一个子目录 doc，用来放置这个工程的文档 hello.txt
• 在工程目录添加文本文件 COPYRIGHT, README
• 在工程目录添加一个 runhello.sh 脚本，用来调用 hello 二进制
• 将构建后的目标文件放入构建目录的 bin 子目录
• 将 doc 目录 的内容以及 COPYRIGHT/README 安装到/usr/share/doc/cmake/

每个目录下都要有一个CMakeLists.txt说明：

$ tree
.
├── build
├── CMakeLists.txt
└── src
    ├── CMakeLists.txt
    └── hello.cpp

2 directories, 3 files
1
2
3
4
5
6
7
8
9

外层CMake：

PROJECT(HELLO)
ADD_SUBDIRECTORY(src bin)
1
2

内层CMake：

ADD_EXECUTABLE(hello hello.cpp)
1

在build目录：

cmake ..
make
1
2

ADD_SUBDIRECTORY

ADD_SUBDIRECTORY(source_dir [binary_dir] [EXCLUDE_FROM_ALL])

• 这个指令用于向当前工程添加存放源文件的子目录，并可以指定中间二进制和目标二进制存放的位置

• EXCLUDE_FROM_ALL函数是将写的目录从编译中排除，如程序中的example

• ADD_SUBDIRECTORY(src bin)

  将 src 子目录加入工程并指定编译输出(包含编译中间结果)路径为bin 目录

  如果不进行 bin 目录的指定，那么编译结果(包括中间结果)都将存放在build/src 目录

更改二进制的保存路径

SET 指令重新定义 EXECUTABLE_OUTPUT_PATH 和 LIBRARY_OUTPUT_PATH 变量 来指定最终的目标二进制的位置

SET(EXECUTABLE_OUTPUT_PATH ${PROJECT_BINARY_DIR}/bin)
SET(LIBRARY_OUTPUT_PATH ${PROJECT_BINARY_DIR}/lib)
1
2

思考：加在哪个CMakeLists.txt当中

哪里要改变目标存放路径，就在哪里加入上述的定义，所以应该在src下的CMakeLists.txt下写

使用CMake进行安装

使用CMAKE一个新的指令：INSTALL

INSTALL的安装可以包括：二进制、动态库、静态库以及文件、目录、脚本等

使用CMAKE一个新的变量：CMAKE_INSTALL_PREFIX = /usr/local/

daniel@u22:~/cm$ tree
.
├── build
├── CMakeLists.txt
├── COPYRIGHT
├── doc
│   └── hello.txt
├── README
├── runhello.sh
└── src
    ├── CMakeLists.txt
    └── hello.cpp

3 directories, 7 files
1
2
3
4
5
6
7
8
9
10
11
12
13
14

安装文件COPYRIGHT和README

INSTALL(FILES COPYRIGHT README DESTINATION share/doc/cmake/)
1

FILES：文件

DESTINATION：

1、写绝对路径

2、可以写相对路径，相对路径实际路径是：${CMAKE_INSTALL_PREFIX}/<DESTINATION 定义的路径>

CMAKE_INSTALL_PREFIX 默认为 /usr/local/

在cmake的时候指定CMAKE_INSTALL_PREFIX变量的路径：

cmake -DCMAKE_INSTALL_PREFIX=/usr
1

安装脚本runhello.sh

PROGRAMS：非目标文件的可执行程序安装(比如脚本之类)

INSTALL(PROGRAMS runhello.sh DESTINATION bin)
1

说明：实际安装到的是 /usr/bin

安装 doc 中的 hello.txt

一、是通过在 doc 目录建立CMakeLists.txt ，通过install下的file

二、是直接在工程目录通过

INSTALL(DIRECTORY doc/ DESTINATION share/doc/cmake)
1

DIRECTORY 后面连接的是所在 Source 目录的相对路径

注意：abc 和 abc/有很大的区别

目录名不以/结尾：这个目录将被安装到目标路径下

目录名以/结尾：将这个目录中的内容安装到目标路径

安装过程

cmake ..
make
make install
1
2
3

静态库和动态库的构建

任务：

1. 建立一个静态库和动态库，提供 HelloFunc 函数供其他程序编程使用，HelloFunc 向终端输出 Hello World 字符串
2. 安装头文件与共享库

静态库和动态库的区别：

• 静态库的扩展名一般为“.a”或“.lib”；动态库的扩展名一般为“.so”或“.dll”。
• 静态库在编译时会直接整合到目标程序中，编译成功的可执行文件可独立运行
• 动态库在编译时不会放到连接的目标程序中，即可执行文件无法单独运行

构建动态库

$ tree
.
├── build
├── CMakeLists.txt
└── lib
    ├── CMakeLists.txt
    ├── hello.cpp
    └── hello.h
1
2
3
4
5
6
7
8

hello.h中的内容：

#ifndef HELLO_H
#define Hello_H

void HelloFunc();

#endif
1
2
3
4
5
6

hello.cpp中的内容：

#include "hello.h"
#include <iostream>
void HelloFunc(){
    std::cout << "Hello World" << std::endl;
}
1
2
3
4
5

项目中的cmake内容：

PROJECT(HELLO)
ADD_SUBDIRECTORY(lib bin)
1
2

lib中CMakeLists.txt中的内容：

SET(LIBHELLO_SRC hello.cpp)
ADD_LIBRARY(hello SHARED ${LIBHELLO_SRC})
1
2

ADD_LIBRARY

ADD_LIBRARY(hello SHARED ${LIBHELLO_SRC})
1

• hello：就是正常的库名，生成的名字前面会加上lib，最终产生的文件是libhello.so
• SHARED：动态库；STATIC：静态库
• ${LIBHELLO_SRC} ：构建库的源文件

同时构建动态库和静态库

// 如果用这种方式，只会构建一个动态库，不会构建出静态库，虽然静态库的后缀是.a
ADD_LIBRARY(hello SHARED ${LIBHELLO_SRC})
ADD_LIBRARY(hello STATIC ${LIBHELLO_SRC})

// 修改静态库的名字，这样是可以的，但是我们往往希望他们的名字是相同的，只是后缀不同而已
ADD_LIBRARY(hello SHARED ${LIBHELLO_SRC})
ADD_LIBRARY(hello_static STATIC ${LIBHELLO_SRC})
1
2
3
4
5
6
7

SET_TARGET_PROPERTIES

这条指令可以用来设置输出的名称，对于动态库，还可以用来指定动态库版本和 API 版本

同时构建静态和动态库

SET(LIBHELLO_SRC hello.cpp)

ADD_LIBRARY(hello_static STATIC ${LIBHELLO_SRC})

# 对hello_static的重名为hello
SET_TARGET_PROPERTIES(hello_static PROPERTIES  OUTPUT_NAME "hello")
# cmake 在构建一个新的target 时，会尝试清理掉其他使用这个名字的库，因为，在构建 libhello.so 时， 就会清理掉 libhello.a
SET_TARGET_PROPERTIES(hello_static PROPERTIES CLEAN_DIRECT_OUTPUT 1)

ADD_LIBRARY(hello SHARED ${LIBHELLO_SRC})

SET_TARGET_PROPERTIES(hello PROPERTIES  OUTPUT_NAME "hello")
SET_TARGET_PROPERTIES(hello PROPERTIES CLEAN_DIRECT_OUTPUT 1)
1
2
3
4
5
6
7
8
9
10
11
12
13

构建：

cd build
cmake ..
make
1
2
3

动态库的版本号

一般动态库都有一个版本号的关联：

libhello.so.1.2
libhello.so ->libhello.so.1
libhello.so.1->libhello.so.1.2
1
2
3

SET_TARGET_PROPERTIES(hello PROPERTIES VERSION 1.2 SOVERSION 1)
1

VERSION 指代动态库版本，SOVERSION 指代 API 版本

安装共享库和头文件

本例中我们将 hello 的共享库安装到<prefix>/lib目录，

将 hello.h 安装到<prefix>/include/hello目录

SET(LIBHELLO_SRC hello.cpp)

ADD_LIBRARY(hello_static STATIC ${LIBHELLO_SRC})

# 对hello_static的重名为hello
SET_TARGET_PROPERTIES(hello_static PROPERTIES  OUTPUT_NAME "hello")
# cmake 在构建一个新的target 时，会尝试清理掉其他使用这个名字的库，因为，在构建 libhello.so 时， 就会清理掉 libhello.a
SET_TARGET_PROPERTIES(hello_static PROPERTIES CLEAN_DIRECT_OUTPUT 1)

ADD_LIBRARY(hello SHARED ${LIBHELLO_SRC})

SET_TARGET_PROPERTIES(hello PROPERTIES  OUTPUT_NAME "hello")
SET_TARGET_PROPERTIES(hello PROPERTIES CLEAN_DIRECT_OUTPUT 1)

# 文件放到该目录下
INSTALL(FILES hello.h DESTINATION include/hello)

# 二进制，静态库，动态库安装都用TARGETS
# ARCHIVE 特指静态库，LIBRARY 特指动态库，RUNTIME 特指可执行目标二进制。
INSTALL(TARGETS hello hello_static LIBRARY DESTINATION lib ARCHIVE DESTINATION lib)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

注意：安装的时候，指定一下路径，将默认的/usr/local修改为/usr

cmake -DCMAKE_INSTALL_PREFIX=/usr ..
1

安装：

$ sudo make && make install
[ 50%] Built target hello_static
[100%] Built target hello
Install the project...
-- Install configuration: ""
-- Installing: /usr/include/hello/hello.h
-- Installing: /usr/lib/libhello.so
-- Installing: /usr/lib/libhello.a
1
2
3
4
5
6
7
8

使用外部共享库和头文件

准备工作，新建一个目录来使用外部共享库和头文件

[root@MiWiFi-R4CM-srv cmake3]# tree
.
├── build
├── CMakeLists.txt
└── src
    ├── CMakeLists.txt
    └── main.cpp
1
2
3
4
5
6
7

main.cpp

#include <hello.h>

int main(){
	HelloFunc();
}
1
2
3
4
5

INCLUDE_DIRECTORIES

可以通过#include <hello/hello.h>来解决

或者使用指令INCLUDE_DIRECTORIES：这条指令可以用来向工程添加多个特定的头文件搜索路径，路径之间用空格分割

在CMakeLists.txt中加入头文件搜索路径：

INCLUDE_DIRECTORIES(/usr/include/hello)
1

LINK_DIRECTORIES

用于添加非标准的共享库搜索路径：

LINK_DIRECTORIES(/home/myproject/libs)
1

TARGET_LINK_LIBRARIES

用于添加需要链接的共享库，使用TARGET_LINK_LIBRARIES的时候，只需要给出动态链接库的名字就行了，前提是它在库的标准搜索路径里面

在CMakeLists.txt中插入链接共享库，要放在executable的后面：

ADD_EXECUTABLE(hello main.cpp)
TARGET_LINK_LIBRARIES(hello libhello.so)
1
2

查看main的链接情况

$ ldd hello
        linux-vdso.so.1 (0x00007ffd66db1000)
        libhello.so => /lib/libhello.so (0x00007fca3efc6000)
        libc.so.6 => /lib/x86_64-linux-gnu/libc.so.6 (0x00007fca3ec00000)
        libstdc++.so.6 => /lib/x86_64-linux-gnu/libstdc++.so.6 (0x00007fca3e800000)
        /lib64/ld-linux-x86-64.so.2 (0x00007fca3efe2000)
        libm.so.6 => /lib/x86_64-linux-gnu/libm.so.6 (0x00007fca3eedf000)
        libgcc_s.so.1 => /lib/x86_64-linux-gnu/libgcc_s.so.1 (0x00007fca3eebf000)
1
2
3
4
5
6
7
8

链接静态库：

TARGET_LINK_LIBRARIES(main libhello.a)
1

特殊的环境变量 CMAKE_INCLUDE_PATH 和 CMAKE_LIBRARY_PATH：

注意：这两个是环境变量而不是 cmake 变量，可以在linux的bash中进行设置

我们上面例子中使用了绝对路径INCLUDE_DIRECTORIES(/usr/include/hello)来指明include路径的位置

我们还可以使用另外一种方式，使用环境变量export CMAKE_INCLUDE_PATH=/usr/include/hello

构建debug版本

生产debug版本的方法：

cmake -DCMAKE_BUILD_TYPE=debug ..
1