cMake学习之路

发表于 分类于 ， 阅读次数： Waline： 本文字数： 9.5k 阅读时长 ≈ 9 分钟

cMake适用于跨平台的编译

cMake学习之路

1. cMake安装

我使用的是mac

1
brew install cmake

2. cMake的编译

创建我们的文件所在目录，并来到创建的目录

1
2
madir cmakeLearn/cmake01
cd cmakeLearen/cmake01

2.1 创建一个hello world

我是在nvim下

1
nvim main.cpp
1
2
3
4
5
6
//main.cpp

#include <iostream>
int main(){
	std::cout << "hello world" << std::endl;
}

我们正常编译执行看下结果

1
2
clang++ main.cpp
./a.out

输出：

hello world

然后把a.out删除

1
rm -rf a.out

2.2 写CMakeLists.txt

现在我们用cMake来编译

新建CMakeLists.txt

1
nvim CMakeLists.txt
1
2
3
4
5
6
// projext name
PROJECT(HELLO)
SET(SRC_LIST main.cpp)
MESSAGE(STATUS "This is BINARY dir" ${HELLO_BINARY_DIR})
MESSAGE(STATUS "This is SOURCES dir" ${HELLO_SOURCE_DIR})
ADD_EXECUTABLE(hello ${SRC_LIST})

2.3 使用cmake生成makefile文件

1
cmake .

没有发生报错，就是成功编译了

我们执行

1
la -a

查看当前目录下有哪些文件

2.4 使用make编译

1
make

可以发现生成了hello这个文件，我们执行

1
./hello

输出结果：

hello world

3. cMake语法介绍

3.1 PROJECT关键字

可以用来指定工程的名字和支持的语言，默认支持所有语言

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

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

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

我们的hello world程序

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

<projectname>_BINARY_DIR，本例中是 HELLO_BINARY_DIR

<projectname>_SOURCE_DIR，本例中是 HELLO_SOURCE_DIR

MESSAGE关键字就可以直接使用者两个变量，当前都指向当前的工作目录，后面会讲外部编译

ps:

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

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

3.2 SET关键字

用来显示的指定变量的

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

如果有多个cpp文件

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

3.3 MESSAGE关键字

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

主要包含三种信息：

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

3.4 ADD_EXECUTABLE关键字

生成可执行文件

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

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

上述例子可以简化的写成

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

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

4. 语法的基本原则

  • 变量使用${}方式取值，但是在IF 控制语句中是直接使用变量名

  • 指令(参数 1 参数 2...) 参数使用括弧括起，参数之间使用空格或分号分开。 以上面的 ADD_EXECUTABLE指令为例，如果存在另外一个 func.cpp 源文件

    就要写成：ADD_EXECUTABLE(hello main.cpp func.cpp)或者ADD_EXECUTABLE(hello main.cpp;func.cpp)

  • 指令是大小写无关的，参数和变量是大小写相关的。但，推荐你全部使用大写指令

4.1 语法注意事项

  • SET(SRC_LIST main.cpp)可以写成 SET(SRC_LIST “main.cpp”)，如果源文件名中含有空格，就必须要加双引号
  • ADD_EXECUTABLE(hello main)后缀可以不行，他会自动去找.c和.cpp，最好不要这样写，可能会有这两个文件main.cpp和main

5. 内部构建和外部构建

我们的hello world使用的就是内部构建，生产的临时文件特别多，不方便清理

外部构建，就会把生成的临时文件放在build目录下，不会对源文件有任何影响强烈使用外部构建方式

我们删除到只剩下

### 5.1 外部构建

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

1
2
mkdir build
cd build

2、运行cmake ..

1
cmake ..

当然..表示上一级目录，你可以写CMakeLists.txt所在的绝对路径，生产的文件都在build目录下了

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

1
make

ps:

注意外部构建的两个变量

1、HELLO_SOURCE_DIR 还是工程路径

2、HELLO_BINARY_DIR 编译路径 也就是/root/cmake/bulid

6. 让Hello World看起来更像一个工程

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

6.1 将目标文件放入构建目录的 bin子目录

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

1
2
3
4
5
6
7
[root@localhost cmake01]# tree
.
├── build
├── CMakeLists.txt
└── src
    ├── CMakeLists.txt
    └── main.cpp

回到我们的cmake01，此时路径

1
lab/cmakeLearn/cmake01

建立src,并把main.cpp移动过来

1
2
mkdir src
mv main.cpp src/

并在src中创建一个CMakeLists.txt

1
touch CMakeLists.txt

回到我们的根目录下，也就是cmake01

1
2
3
4
5
6
7
[root@localhost cmake01]# tree
.
├── build
├── CMakeLists.txt
└── src
    ├── CMakeLists.txt
    └── main.cpp

输入

1
cat CMakeLists.txt

可以看到里面有数据

1
2
3
4
5
PROJECT(HELLO)
SET(SRC_LIST main.cpp)
MESSAGE(STATUS "This is BINARY dir" ${HELLO_BINARY_DIR})
MESSAGE(STATUS "This is SOURCES dir" ${HELLO_SOURCE_DIR})
ADD_EXECUTABLE(hello ${SRC_LIST})

我们把里面的数据删除

1
echo "" > CMakeLists.txt

重新在CMakeLists.txt中输入

1
2
3
// CMakeLists.txt
PROJECT(HELLO)
ADD_SUBDIRECTORY(src bin)

ADD_SUBDIRECTORY指令

1
ADD_SUBDIRECTORY(source_dir [binary_dir] [EXCLUDE_FROM_ALL])

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

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

  • ADD_SUBDIRECTORY(src bin)

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

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

接下来我们写src下的CMakeLists.txt

1
2
cd src
nvim CMakeLists.txt
1
2
//	src/CMakeLists.txt
ADD_EXECUTABLE(hello main.cpp)

去到build文件下(空)

执行

1
cmake ..

可以看到产生了

. .. CMakeCache.txt CMakeFiles Makefile bin cmake_install.cmake

再执行

1
make

生成

. .. CMakeCache.txt CMakeFiles Makefile bin cmake_install.cmake

去到bin文件下

1
2
cd bin
ls -a

. .. CMakeFiles Makefile cmake_install.cmake hello

可以看到已经产生了我们的可执行文件hello

总结

结构为：

1
2
3
4
5
6
.
├── build
├── CMakeLists.txt
└── src
    ├── CMakeLists.txt
    └── main.cpp

在外层的CMakeLists.txt中通过ADD_SUBDIRECTORY指明当前工程添加存放源文件的子目录，并可以指定中间二进制和目标二进制存放的位置

在src中执行ADD_EXECUTABLE(hello main.cpp)

如果要更改二进制的保存路径

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

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

ps:

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

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

7. 安装

使用CMAKE一个新的指令：INSTALL

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

使用CMAKE一个新的变量：CMAKE_INSTALL_PREFIX

7.1 创建实例

我们创建cmake02

1
2
3
.
├── cmake01
├── cmake02

然后把cmake01的内容复制到cmake02

1
cp cmake01/* cmake02

此时cmake02到的结构为

1
2
3
4
5
6
7
8
9
lab/cmakeLearn/cmake02
➜ tree
.
├── CMakeLists.txt
├── build
└── src
    ├── CMakeLists.txt
    └── main.cpp

安装以下目录树构建完整。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
// 目录树结构
//lab/cmakeLearn/cmake02
➜ tree
.
├── CMakeLists.txt
├── COPYRIGHT
├── README
├── build
├── doc
│   └── hello.txt
├── runhello.sh
└── src
    ├── CMakeLists.txt
    └── main.cpp

7.2 安装文件COPYRIGHT和README

7.2.1 安装文件COPYRIGHT

打开最外层的CMakeLists.txt

1
nvim CMakeLists.txt
1
2
3
4
// CMakeLists.txt
PROJECT(HELLO)
ADD_SUBDIRECTORY(src bin)
INSTALL(FILES COPYRIGHT README DESTINATION share/doc/cmake/)

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

FILES：文件

DESTINATION：

1、写绝对路径

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

CMAKE_INSTALL_PREFIX 默认是在 /usr/local/

cmake -DCMAKE_INSTALL_PREFIX=/usr 在cmake的时候指定CMAKE_INSTALL_PREFIX变量的路径

7.2.2 安装脚本runhello.sh

继续在我们的CMakeLists.txt中添加

1
INSTALL(PROGRAMS runhello.sh DESTINATION bin)

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

INSTALL(PROGRAMS runhello.sh DESTINATION bin)

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

7.2.3 安装 doc中的 hello.txt

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

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

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

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

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

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

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

7.2.4 安装

1
2
cd build
cmake ..

可以看到已经生成了Makefile文件，代表没有出错

执行

1
make

已经在bin中成功生成hello可执行文件

执行

make install

可以看到我们的COPYRIGHT和README已经成功安装。

8. 静态库和动态库的构建

任务：

１，建立一个静态库和动态库，提供 HelloFunc函数供其他程序编程使用，HelloFunc 向终端输出Hello World 字符串。

２，安装头文件与共享库。

静态库和动态库的区别

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

8.1 创建实例

我们创建cmake03

1
2
3
4
.
├── cmake01
├── cmake02
├── cmake03

cmake03结构为

1
2
3
4
5
6
7
8
//目录树结构
.
├── build
├── CMakeLists.txt
└── lib
    ├── CMakeLists.txt
    ├── hello.cpp
    └── hello.h

hello.h

1
2
3
4
5
6
7
// hello.h
#ifndef HELLO_H
#define HELLO_H

void HelloFunc();

#endif

hello.cpp

1
2
3
4
5
6
7
// hello.cpp
#include <iostream>
#include "hello.h"

void HelloFunc(){
	std::cout << "hello world" << std::endl;
}

写项目外层的CMakeLists.txt

1
2
PROJECT(HELLO)
ADD_SUBDIRECTORY(lib bin)

第二句为我们在lib中生成一个共享库bin

lib中CMakeLists.txt中的内容

1
2
3
// lib/CMakeLists.txt
SET(LIBHELLO_SRC hello.cpp)
ADD_LIBRARY(hello SHARED ${LIBHELLO_SRC})

LIBHELLO_SRC 为我们定义的一个变量

在这个变量上放入了 hello.cpp

ADD_LIBRARY

ADD_LIBRARY(hello SHARED ${LIBHELLO_SRC})

  • hello：就是正常的库名，生成的名字前面会加上lib，最终产生的文件是libhello.so 或者libhello.dylib(mac中的共享库)
  • SHARED，动态库 STATIC，静态库
  • ${LIBHELLO_SRC}：源文件

我们来到build，执行

1
2
cmake ..
make

可以看到bin中生成了动态共享库libhello.dylib

drwxr-xr-x 5 SJCHEN staff 160B 5 15 22:41 CMakeFiles -rw-r--r-- 1 SJCHEN staff 5.8K 5 15 22:41 Makefile -rw-r--r-- 1 SJCHEN staff 1.1K 5 15 22:41 cmake_install.cmake -rwxr-xr-x 1 SJCHEN staff 55K 5 15 22:41 libhello.dylib

8.2 同时构建静态和动态库

我们来到lib中的CMakeLists.txt

1
2
3
4
5
6
7
8
9
10
11
SET(LIBHELLO_SRC hello.cpp)

ADD_LIBRARY(hello_static STATIC ${LIBHELLO_SRC})

SET_TARGET_PROPERTIES(hello_static PROPERTIES  OUTPUT_NAME "hello")
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)

SET_TARGET_PROPERTIES

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

来到build

先把build中的数据删空

1
rm -rf *

执行

1
2
cmake ..
make

输出结果；

[ 25%] Building CXX object bin/CMakeFiles/hello_static.dir/hello.o

[ 50%] Linking CXX static library libhello.a

[ 50%] Built target hello_static

[ 75%] Building CXX object bin/CMakeFiles/hello.dir/hello.o

[100%] Linking CXX shared library libhello.dylib

可以看到我们同时输出了静态库libhello.a和动态共享库libhello.dylib

8.3 安装共享库和头文件

来到lib中的CMakeLists.txt

插入

1
2
INSTALL(FILES hello.h DESTINATION include/hello)
INSTALL(TARGETS hello hello_static LIBRARY DESTINATION lib ARCHIVE DESTINATION lib)

//二进制，静态库，动态库安装都用TARGETS //ARCHIVE 特指静态库，LIBRARY 特指动态库，RUNTIME 特指可执行目标二进制。

此时CMakeLists.txt

1
2
3
4
5
6
7
8
9
10
11
12
13
14
SET(LIBHELLO_SRC hello.cpp)

ADD_LIBRARY(hello_static STATIC ${LIBHELLO_SRC})

SET_TARGET_PROPERTIES(hello_static PROPERTIES  OUTPUT_NAME "hello")
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)
INSTALL(TARGETS hello hello_static LIBRARY DESTINATION lib ARCHIVE DESTINATION lib)

ps:

注意：

安装的时候，指定一下路径，放到系统下

cmake -DCMAKE_INSTALL_PREFIX=/usr ..

来到build，清空

执行

1
2
cmake -DCMAKE_INSTALL_PREFIX=/usr ..
make

安装

1
make install

8.4 使用外部共享库和头文件

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

我们创建cmake04

1
2
3
4
5
6
7
//目录树结构
.
├── build
├── CMakeLists.txt
└── src
    ├── CMakeLists.txt
    └── main.cpp