C程序编译、链接与项目构建

摘要

本篇博客对C/C++程序的编译环境、库创建链接、Make和CMake工具的使用进行介绍，以便加深理解和记忆

C编译环境

• C编译环境

  • GNU（GNU’s Not Unix）：GNU是一个自由软件运动的项目，旨在开发一个类Unix操作系统。GNU项目创建了一系列工具和库，为开发者提供了自由的软件开发环境。其中包括GCC编译器、MinGW和其他开发工具。GNU以开源和自由软件的理念而闻名，为用户提供了更大的自由度和可定制性。

  • GCC（GNU Compiler Collection）：GCC是GNU项目的核心组件之一，也是一个开源的编译器集合。它支持多种编程语言，包括C、C++、Objective-C、Fortran等。GCC是一个跨平台的编译器，提供了许多优化选项和功能，以生成高质量的可执行文件。（最早名为GNU Compiler C，针对C）

  • MinGW（Minimalist GNU for Windows）：MinGW是一个开源的软件开发工具集，旨在为Windows提供GNU开发环境。它包含了一组用于Windows的头文件和库文件，以及GCC（GNU Compiler Collection）编译器。MinGW使得开发者能够在Windows上开发和编译使用GNU工具链的应用程序，它提供了一种轻量级的方式在Windows环境下进行开发。

  • MSVC（Microsoft Visual C++）:MSVC是微软公司开发的一款C++编译器和集成开发环境（IDE）。它是Windows平台上最常用的C++开发工具之一。MSVC提供了丰富的开发工具、调试功能和图形化界面，使得Windows开发变得更加便捷。

• 区别与联系：MinGW和GCC都属于GNU项目的一部分，它们提供了在Windows环境下进行GNU开发的工具和编译器。GCC是跨平台的编译器集合，MinGW专注于在Windows上提供GNU工具链的支持

静、动态库

介绍

• 什么是库

库是写好的，成熟的，可复用的代码。本质上来说，库是一种可执行代码的二进制形式，可以被OS载入内存执行。库有两种：静态库（.a、.lib）和动态库（.so、.dll）

• 静态库

  • 概念：链接阶段，会将汇编生成的目标文件.o/.obj与依赖的静态库（.lib）一起打包到可执行文件中。一个静态库可以简单地看成一组目标文件（.o/.obj）的集合（即很多目标文件经过压缩打包形成的一个文件）
  • 特点
    • 程序对静态库的链接是在编译时完成的
    • 可执行程序在运行时与静态库再无瓜葛，移植方便（因为静态库在编译阶段就已被目标程序链接到一起生成可执行文件）
    • 通过静态链接的可执行程序体积通常较大，因为链接到一起时会占用较多空间
  • 静态库包含的内容
    • .a/.lib二进制文件：它是静态库实际的内容
    • .h头文件，它是静态库中函数、变量、宏定义的声明，以供引用并使用

• 动态库

  • 为何需要动态库：动态库的出现是为了解决静态库的一些不足：

    • 空间浪费
    
    • 静态库更新带来的程序全量更新问题：如果静态库更新了，依赖于它的应用程序都需要重新编译、发布给用户（对于用户来说，可能是一个很小的改动，却导致整个程序重新下载，全量更新）
      动态库在程序编译时并不会被连接到目标代码中，而是在程序运行是才被载入。不同的应用程序如果调用相同的库，那么在内存里只需要有一份该共享库的实例，规避了空间浪费问题。动态库在程序运行是才被载入，也解决了静态库对程序的更新、部署和发布页会带来麻烦。用户只需要更新动态库即可，增量更新。
    

  • 特点

    • 动态库把库函数的链接载入推迟到程序运行的时期
    • 可以实现进程之间的资源共享（因此动态库也称为共享库）
    • 将程序更新变得简单
    • 可以真正做到链接载入完全由程序员在程序代码中控制（显示调用）

  • 动态库包含的内容

    • .dll/.so文件：动态库的实际内容
    • .lib：动态库的入口文件
    • .h：动态库的声明头文件，以供程序引入和使用

gcc与g++和程序编译、链接

• gcc与g++的联系与区别

  • gcc与g++都是GNU(组织)的一个编译器

  • gcc与g++都可以编译c代码与c++代码。但是：后缀为.c的，gcc把它当做C程序，而g++当做是C++程序；后缀为.cpp的，两者都会认为是C++程序

  • 编译可以用gcc/g++，而链接可以用g++或者gcc -lstdc++。因为gcc命令不能自动和C＋＋程序使用的库联接（当然可以选择手动链接，使用命令如下），所以通常使用g++来完成联接。但在编译阶段，g++会自动调用gcc，二者等价

• gcc编译过程

  
  • 预处理：处理#开头的语句，进行文本替换

  gcc -E hello.c -o hello.i
  1

  • 编译：检查代码规范性和语法错误，将程序编译为汇编代码（语法检查、代码优化）

  gcc -S hello.i -o hello.s
  1

  • 汇编：将汇编代码转换为二进制目标文件（机器可识别）

  gcc -c hello.s -o hello.o
  1

  • 链接：将目标文件链接成最终可执行程序（处理目标文件间的依赖关系）

  gcc hello.o -o hello
  1

• 静态链接库

  • 创建静态链接库

# 将所有指定的源文件，都编译成相应的目标文件
g++ -c greeting.cpp  name.cpp
# greeting.cpp name.cpp greeting.o name.o greeting.h name.h
# 将生成的目标文件打包成静态链接库（可以将多个目标文件打成一个链接库）
# 静态链接库的不能随意起名，需遵循如下的命名规则：libxxx.a/libxxx.lib
ar rcs libmyfunction.a name.o greeting.o 
1
2
3
4
5
6

• 链接静态链接库

# 将主文件编译为目标文件
g++ -c main.cpp
# 链接
g++ -static main.o libmyfunction.a
# -L注定路径，-l指定库名称，中间一般不加空格
# g++ -static main.o -L /home/wohu/cpp/src -lmyfunction
1
2
3
4
5
6

• 动态链接库

  • 创建动态链接库

  # 1.直接使用源文件创建动态链接库
  # -shared 选项用于生成动态链接库
  # -fpic（还可写成 -fPIC）选项的功能是，令 GCC 编译器生成动态链接库（多个目标文件的压缩包）时，表示各目标文件中函数、类等功能模块的地址使用相对地址，而非绝对地址。这样，无论将来链接库被加载到内存的什么位置，都可以正常使用
  gcc -fpic -shared 源文件名... -o 动态链接库名
  
  # 2.先使用 gcc -c 指令将指定源文件编译为目标文件，再由目标文件生成动态链接库
  g++ -c -fPIC name.cpp greeting.cpp
  # 生成动态链接库
  g++ -shared greeting.o name.o -o libmyfunction.so
  1
  2
  3
  4
  5
  6
  7
  8
  9

  • 链接动态链接库

  g++ main.cpp  libmyfunction.so -o main
  1

Visual Studio创建和链接库

• 静态库

  • 创建静态库

  使用VS新建项目 → 选择Win32控制台程序 → 选择应用程序设置 → 勾选静态库 → 编写静态库 → Build项目

  • 链接静态库

    • 方法一：引用的静态库是同一解决方案下的子工程

      • 项目 → 属性 → 项目依赖项：在欲引用静态库的项目中点选静态库依赖项

      

      • 右键欲引用静态库的项目 → 属性 → 配置属性 → C/C++ → 常规 → 在附加包含目录中键入静态库{name}.h头文件所在文件夹的路径

      

    • 方法二：右键欲引用静态库的项目 → 属性 → 配置属性 → 链接器 → 命令行：在其他选项中键入完整的静态库.lib路径

    

    • 方法三

      • 右键欲引用静态库的项目 → 属性 → 配置属性 → 链接器 → 常规 → 附加库目录中键入静态库所在的目录
      • 右键欲引用静态库的项目 → 属性 → 配置属性 → 链接器 → 输入 → 附加依赖项中输入静态库的名称{name}.lib

      

• 动态库

  • 创建动态库

    • 创建项目

    

    • 项目结构
    

    pch是预编译头文件，通常将一些不怎么变动的头文件预先编译，加快工程编译速度

    dllmain.cpp是dll程序的主文件，其中DllMain函数是dll的入口点，每次这个dll被加载都会执行DllMain，然后根据运行时状态执行不同的命令

    // dllmain.cpp : 定义 DLL 应用程序的入口点。
    #include "pch.h"
    
    BOOL APIENTRY DllMain( HMODULE hModule,
                           DWORD  ul_reason_for_call,
                           LPVOID lpReserved
                         )
    {
        switch (ul_reason_for_call)
        {
        case DLL_PROCESS_ATTACH:   //被程序加载时执行
        case DLL_THREAD_ATTACH:    //被线程加载时执行
        case DLL_THREAD_DETACH:    //被线程卸载时执行
        case DLL_PROCESS_DETACH:   //被程序卸载时执行
            break;
        }
        return TRUE;
    }
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18

    • 编写自定义的DLL函数

    ```c
    // dllmain.cpp : 定义 DLL 应用程序的入口点。
    #include "pch.h"
    
    BOOL APIENTRY DllMain( HMODULE hModule,
                         DWORD  ul_reason_for_call,
                         LPVOID lpReserved
                       )
    {
      switch (ul_reason_for_call)
      {
      case DLL_PROCESS_ATTACH:
      case DLL_THREAD_ATTACH:
      case DLL_THREAD_DETACH:
      case DLL_PROCESS_DETACH:
          break;
      }
      return TRUE;
    }
    
    //编写函数 pch.h里面记得要添加include<iostream>
    void test1()
    {
      std::cout << "test1 is worked\n";
    }
    
    void test2()
    {
      std::cout << "test2 is worked\n";
    }
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30

    • 将函数或对象暴露给外界：编写完函数或对象，外界还是无法执行的，这就像js里的模块化编程，需要将想要给外界使用的功能暴露（export）出来

      • 方法一：在函数名(对象)前加入暴露给外界的关键字

        • C

        __declspec(dllexport) void test1()
        {
            std::cout << "test1 is worked\n";
        }
        1
        2
        3
        4

        • C++：C++支持函数名重载，方法是将原有函数名粉碎，向函数名中添加关于参数的信息，就是说原来的函数名就是test1，但C++会粉碎成？test1@@YAXXZ这样的名字，这也就导致了我们暴露出去的函数名其实根本不是test1。为了解决这个问题：只需要在编写dll的时候在函数前告诉编译器，用C风格来暴露test函数，就不会被粉碎函数名了

        extern "C" __declspec(dllexport) void test1()
        {
            std::cout << "test1 is worked\n";
        }
        1
        2
        3
        4

        实际在C++中，我们更倾向于通过对象的方式将方法暴露给外界：

        class __declspec(dllexport) test
        {
            test() {};
        };
        1
        2
        3
        4

      • 方法二 ：使用模块定义文件(.def)：右键项目 → 添加项 → 新建项 → 选择模块定义文件创建

      

      自定义名称，并在文件中写入（.def文件中以";"作为注释符）：

      LIBRARY {dll_project_name}   ;LIBRAY后面跟dll的项目名称
      EXPORTS    ;EXPORTS代表后面的都是要export出去的函数
      test2  ;一行一个函数名
      1
      2
      3

    生成dll：在vs的顶部工具栏，依次点击生成 → 生成dll测试 → dll文件在项目文件夹的debug目录

  • 链接动态库

    • 方法一：同一解决方案

      • 右键项目 → 属性 → 通用属性 → 引用 → 添加新引用
      • 右键项目 → 属性 → 配置属性 → C/C++ → 常规 → 附加包含目录 键入动态库.h头文件的路径

    • 方法二：不要求同一解决方案

      • 右键项目 → 属性 → 配置属性 → 链接器 → 常规 → 附加依赖库目录 键入动态库所在目录

      • 右键项目 → 属性 → 配置属性 → 连接器 → 输入 → 附加目录 键入动态库对应的.lib文件（dll的入口）

动态库的显示调用

• Linux：#include <dlfcn.h>

  • void * dlopen( const char * pathname, int mode )：函数以指定模式打开指定的动态连接库文件，并返回一个句柄给调用进程

  • void* dlsym(void* handle,const char* symbol)：dlsym根据动态链接库操作句柄(pHandle)与符号(symbol)，返回符号对应的地址。使用这个函数不但可以获取函数地址，也可以获取变量地址

  • int dlclose (void *handle)：dlclose用于关闭指定句柄的动态链接库，只有当此动态链接库的使用计数为0时,才会真正被系统卸载

  • const char *dlerror(void)：当动态链接库操作函数执行失败时，dlerror可以返回出错信息，返回值为NULL时表示操作函数执行成功

  • Windows

//main.cpp : 测试动态链接库
#include <iostream>

// 函数指针：定义了一个类型名为fun的，指向空的函数指针
// https://blog.csdn.net/qq_35621436/article/details/106085752
typedef void(*func)(); 
int main(void)
{
    /**引入要加载的动态链接库
    HMODULE点进去看的话其实是HINSTANCE的一个别名，就是一个句柄
    如果获取到了，会返回这个动态库的句柄，否则返回NULL**/
    HMODULE dlltest = LoadLibraryW(L"{name}.dll");
    if (dlltest)
    {
        /**获取函数名所在的地址，即函数指针
        获取到的地址默认是void类型，因此要自己定义一个函数指针，进行强制类型转换**/
        func test = (func)GetProcAddress(dlltest, "test");
        if (test) {
            test();
        }
        else {
            MessageBoxW(NULL, L"找不到test方法", L"ERROR", NULL);
        }
    }
    else {
        MessageBoxW(NULL,L"找不到dll",L"ERROR",NULL);
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28

Make

Make - GNU Project - Free Software Foundation 跟我一起写Makefile — 跟我一起写Makefile 1.0 文档 (seisman.github.io)

介绍

Make 是一种流行的构建工具，常用于将源代码转换成可执行文件或者其他形式的输出文件(如库文件、文档等)。Make 可以自动化地执行编译、链接等一系列操作，提高开发效率。

• Make 使用 Makefile 文件描述项目的构建过程，其中包含了源文件、目标文件以及编译和链接的命令等信息。Makefile 按照一定的规则解析，将源码和构建过程相互关联起来，执行具体的构建操作，生成目标文件或可执行文件

• Make 工具的优势在于它可以识别哪些文件被修改了，只编译修改过的部分，以提高构建速度。此外，Make 工具还支持基于条件的编译，也就是预处理器(preprocessor)功能，可以生成不同的输出文件用于不同的平台或不同的运行环境

• Make 工具具有很好的跨平台性，可以在 Unix/Linux、Windows、Mac 等多种操作系统上使用，并且可以与多种编程语言搭配使用，如 C、C++、Java 等

安装

• Linux

• Windows

  • Make for Windows (sourceforge.net)：实际基于MinGW，推荐后者

  • MinGW - Minimalist GNU for Windows download | SourceForge.net

    • 下载安装，将Bin目录加入到系统环境变量中

    • 运行MinGW Installer，勾选所需的包，点击左上角的Installation，点击Apply Change

  

  • 将mingw32-make.exe更名为make.exe方便使用

使用

CMake

CMake官网 CMake官方中文文档 CMake-Practice-zh-CN: CMake 实践 (github.com) 《CMake Best Practices》的非专业个人翻译 (github.com)

介绍

CMake是一种管理源代码构建的工具，被广泛用于C/C++项目

使用的工具链：cmake + make。通过cmake语法编写CMakeLists.txt文件，描述项目的构建属性和配置，并进行自动化的项目构建（可执行二进制文件、静/动态库）

• 开源、高效率

• 跨平台：在Linux/Unix平台，生成makefile；在Mac平台生成xcode；在Windows平台可以生成MSVC工程文件

• 可扩展：可为cmake编写特定功能的模块，扩展cmake功能

安装

各大Linux发行版都集成了cmake，无需手动安装。如需安装可从官网上下载安装

使用

构建方式

• 内部构建

• 外部构建：推荐的方式，在源CMakeLists.txt所在的文件夹下新建build目录（或其他任意位置），在该位置下键入cmake ..或cmake 源工程路径，此时区分出了PROJECT_SOURCE_DIR和PROJCT_BINARY_DIR

内部构建

源码和构建中间、目标在同一目录下，将hello.c和CMakeLists.txt放入同一目录

# 注意：命令和括号之间没有空格
CMAKE_MINIMUM_REQUIRED(VERSION 3.29)

#[[
 指定项目信息：该声明隐式地定义了两个变量：项目名_BINARY_DIR和项目名_BINARY_DIR，
它们指向了当前CMakeLists.txt文件的路径，更好的替代方式是PROJECT_SOURCE_DIR和
PROJCT_BINARY_DIR，它们可以避免由项目名称更改造成的问题 
PROJECT (项目名
    VERSION 版本号
    DESCRIPTION "项目介绍"
    LANGUAGE C)
]]
PROJECT(hello)

#[[
 打印信息：MESSAGE([SEND_ERROR | STATUS | FATAL_ERROR] "message to display")
    SEND_ERROR，产生错误，生成过程被跳过
    SATUS，输出前缀为—的信息
    FATAL_ERROR，立即终止所有 cmake 过程
]]
# 注意除IF语句中，变量的使用方式为：${}
MESSAGE(STATUS "This is Projct BINARY dir" ${项目名_BINARY_DIR})
MESSAGE(STATUS "This is Projct SOURCE dir" ${项目名_SOURCE_DIR})

# 显示定义变量：SET(VAR [VALUE] [CACHE TYPE DOCSTRING [FORCE]])
# 变量值可以用双引号标识，以应对存在空格的情况：SET(SRC_LIST “fu nc.c”)
SET(SRC_LIST hello.c)

# 添加要构建可执行文件的源文件和输出文件，此时表示可执行文件为hello，源文件列表为SRC_LIST变量
# 多个参数可以使用空格或分号分隔：ADD_EXECUTABLE(hello main.c;func.c)
ADD_EXECUTABLE(hello ${SRC_LIST})
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31

cmake .
1

外部构建

注意：CMake需要在任何子目录中建立一个CMakeLists.txt，如下将源文件放入src文件夹中，src文件夹中也需要创建一个

- root
    # 源文件
    - src
        # 源码
        hello.c
        CMakeLists.txt
    # 文档
    - doc
        # 版权说明、自述文件
        COPYRIGHT.txt
        README.txt
    # bat脚本，用于调用二进制可执行文件
    run.bat
    # 构建后的目标文件夹
    - bin
    # 构建目录
    - build
    CMakeLists.txt
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

# /src/CMakeLists.txt
ADD_EXECUTABLE(hello hello.c)

# 指定最终的目标二进制的位置(指最终生成的 hello 或者最终的共享库，不包含编译生成的中间文件)
# 内部编译下，PROJECT_BINARY_DIR是当前目录，外部编译下，PROJECT_BINARY_DIR是构建目录
# 与下面的ADD_SUBDIRECTORY用途相同（在哪里 ADD_EXECUTABLE 或 ADD_LIBRARY，就在哪改变路径）
SET(EXECUTABLE_OUTPUT_PATH ${PROJECT_BINARY_DIR}/bin)
SET(LIBRARY_OUTPUT_PATH ${PROJECT_BINARY_DIR}/lib)
1
2
3
4
5
6
7
8

# /CMakeLists.txt
CMAKE_MINIMUM_REQUIRED(VERSION 3.12...3.29)

Project(hello)

# 向当前工程添加存放源文件的子目录，并可以指定中间二进制和目标二进制存放的位置
# ADD_SUBDIRECTORY(source_dir [binary_dir] [EXCLUDE_FROM_ALL])
# EXCLUDE_FROM_ALL 参数的含义是将这个目录从编译过程中排除，比如，工程的 example，可能就需要工程构建完成后，再进入 example 目录单独进行构建
# 将 src 子目录加入工程，并指定编译输出(包含编译中间结果)路径为bin 目录。如果不进行 bin 目录的指定，那么编译结果(包括中间结果)都将存放在build/src 目录(这个目录跟原有的 src 目录对应)
ADD_SUBDIRECTORY(src bin)


# 指定安装目录的变量:默认值/usr/local，注意Windows下转义字符
SET(CMAKE_INSTALL_PREFIX C:\\Users\\liyifan31\\Desktop\\des)

# 安装命令：注意FILES、PROGRAMS、DIRECTORY是标识符
#[[
 # 目标文件安装：TARGETS
 # TARGET参数即是ADD_EXECUTABLE、ADD_LIBRARY定义的目标文件
 INSTALL(TARGETS targets...
     # 静态库、动态库、可执行二进制文件    
     [[ARCHIVE|LIBRARY|RUNTIME]
         # 定义安装路径，若以/开头则是绝对路径，CMAKE_INSTALL_PREFIX失效    
         [DESTINATION <dir>]       
         [PERMISSIONS permissions...]
         [CONFIGURATIONS
     [Debug|Release|...]]
         [COMPONENT <component>]
         [OPTIONAL]
 ] [...])
 # 普通文件安装
 INSTALL(FILES files... DESTINATION <dir>
     # 定义文件权限，默认为：OWNER_WRITE,OWNER_READ,GROUP_READ,WORLD_READ，即644权限
     [PERMISSIONS permissions...]
     [CONFIGURATIONS [Debug|Release|...]]
     [COMPONENT <component>]
     [RENAME <name>] [OPTIONAL])
  # 非目标文件的可执行程序安装(比如脚本之类)，与FILES相比，默认为755权限
 INSTALL(PROGRAMS files... DESTINATION <dir>
     [PERMISSIONS permissions...]
     [CONFIGURATIONS [Debug|Release|...]]
     [COMPONENT <component>]
     [RENAME <name>] [OPTIONAL])
  # 文件夹
  INSTALL(DIRECTORY dirs... DESTINATION <dir>
     [FILE_PERMISSIONS permissions...]
     # 所在 Source 目录的相对路径。注意：abc 和 abc/有很大的区别
     # 如果目录名不以/结尾，那么这个目录将被安装为目标路径下的 abc，
     # 如果目录名以/结尾，代表将这个目录中的内容安装到目标路径，但不包括这个目录本身
     [DIRECTORY_PERMISSIONS permissions...]
     [USE_SOURCE_PERMISSIONS]
     [CONFIGURATIONS [Debug|Release|...]]
     [COMPONENT <component>]
     # 使用正则表达式进行过滤
     [[PATTERN <pattern> | REGEX <regex>]
     [EXCLUDE] [PERMISSIONS permissions...]] [...])
   # e.g.
   # 将 icons 目录安装到 <prefix>/share/myproj，将 scripts/中的内容安装到<prefix>/share/myproj
   INSTALL(DIRECTORY icons scripts/ DESTINATION share/myproj
       # 不包含目录名为 CVS 的目录
       PATTERN "CVS" EXCLUDE
       # 对于 scripts/*文件指定权限为 OWNER_EXECUTE OWNER_WRITE OWNER_READ GROUP_EXECUTE GROUP_READ
       PATTERN "scripts/*"
       PERMISSIONS OWNER_EXECUTE OWNER_WRITE OWNER_READ
       GROUP_EXECUTE GROUP_READ)
]]

INSTALL(DIRECTORY doc DESTINATION doc)
INSTALL(DIRECTORY data DESTINATION data)
INSTALL(TARGETS ${PROJECT_BINARY_DIR}\\bin\\Debug\\ DESTINATION bin)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70

cd build
cmake ..
1
2

cmake -DCMAKE_INSTALL_PREFIX=/usr
make
make install
1
2
3

构建使用静/动态库

目录结构

CMakeLists.txt
- lib
    CMakeLists.txt
    hello.c
    hello.h
- build
1
2
3
4
5
6

# /lib/CMakeLists.txt

SET(LIBHELLO_SRC hello.c)

#[[
    ADD_LIBRARY(libname 
        # SHARED，动态库 STATIC，静态库 MODULE，在使用 dyld 的系统有效，
        # 如果不支持 dyld，则被当作 SHARED 对待
        [SHARED|STATIC|MODULE]
        # 该库不会被默认构建，除非有其他的组件依赖或者手工构建
        [EXCLUDE_FROM_ALL]
        source1 source2 ... sourceN
)
]]
ADD_LIBRARY(hello SHARED ${LIBHELLO_SRC})
ADD_LIBRARY(hello_static STATIC ${LIBHELLO_SRC})

#[[
    # 设置输出属性
    SET_TARGET_PROPERTIES(target1 target2 ...
         PROPERTIES prop1 value1
         prop2 value2 ...)
]]
# 解决静态库和动态库重名/名称不一致的问题
# OUTPUT_NAME 设置输出名称。解决名称不一致问题
# CLEAN_DIRECT_OUTPUT 解决输出时，同名文件清除问题
# VERSION 库版本号
# SOVERSION api版本号
SET_TARGET_PROPERTIES(hello PROPERTIES CLEAN_DIRECT_OUTPUT 1 VERSION 1.2 SOVERSION 1)
SET_TARGET_PROPERTIES(hello_static PROPERTIES OUTPUT_NAME "hello" CLEAN_DIRECT_OUTPUT 1 VERSION 1.2 SOVERSION 1)

# 获取输出属性
GET_TARGET_PROPERTY(OUTPUT_VALUE hello_static OUTPUT_NAME)
MESSAGE(STATUS “This is the hello_static OUTPUT_NAME:” ${OUTPUT_VALUE})
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34

# /CMakeLists.txt
Project(hello_lib)

ADD_SUBDIRECTORY(lib lib)

INSTALL(TARGETS hello hello_static
    LIBRARY DESTINATION lib
    ARCHIVE DESTINATION lib
)
INSTALL(FILES hello.h DESTINATION /include)
1
2
3
4
5
6
7
8
9
10

• 使用静态库和动态库

新建项目，在根路径下创建src文件夹和CMakeLists.txt，在src文件夹下创建sort_test.c和CMakeLists.txt，sort.c中引用刚才的库头文件

# /src/CMakeLists.txt

#[[ 
    # 向工程添加多个特定的头文件搜索路径，路径之间用空格分割
    # 通过 AFTER 或者 BEFORE 参数，控制追加到当前的头文件搜索路径的后面还是前面
    INCLUDE_DIRECTORIES([AFTER|BEFORE] [SYSTEM] dir1 dir2 ...)
]]
INCLUDE_DIRECTORIES("${CMAKE_SOURCE_DIR}/extra/sort/include") 
# 通过 SET 这个 cmake 变量为 on，可以将添加的头文件搜索路径放在已有路径的前面
# SET(CMAKE_INCLUDE_DIRECTORIES_BEFORE ON)

# 为target添加共享库，路径之间用空格分割
LINK_DIRECTORIES("${CMAKE_SOURCE_DIR}/extra/sort/lib/WIN32")
#[[链接
TARGET_LINK_LIBRARIES(target library1
     <debug | optimized> library2 ...)
]]
# 动态
TARGET_LINK_LIBRARIES(sort_test sort.dll)
# 静态
TARGET_LINK_LIBRARIES(sort_test sort.lib)


#[[
   特殊的系统环境变量：注意不是CMake变量CMAKE_INCLUDE_PATH、CMAKE_LIBRARY_PATH
   # 修改这两个环境变量到系统共存的第三方库环境变量
]]
# 在环境变量中找sort.h的路径添加到myHeader变量中
FIND_PATH(myHeader sort.h)
# 指定路径
# FIND_PATH(myHeader NAMES sort.h PATHS /usr/include /usr/include/sort)
# 判空
IF(myHeader)
# 添加到include目录
INCLUDE_DIRECTORIES(${myHeader})
ENDIF(myHeader)

# 注意搜索路径应该添加到可执行文件前
ADD_EXECUTABLE(sort_test sort_test.c)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39

/CmakeLists.txt
Project(sort_lib)
ADD_SUBDIRECTORY(src bin)
1
2
3

常用[系统]变量

• 常用变量

• 系统变量

# 调用系统的环境变量
$ENV{NAME}
# 设置环境变量
SET(ENV{变量名} 值)
1
2
3
4

• 系统信息

• 开关选项

常用指令

# 1.向C，C++编译器添加-D定义
# 如果你的代码中定义了#ifdef ENABLE_DEBUG #endif，这个代码块就会生效。
# 如果要添加其他的编译器开关，可以通过 CMAKE_C_FLAGS 变量和 CMAKE_CXX_FLAGS 变量设置
ADD_DEFINITIONS(-DENABLE_DEBUG -DABC)


# 2.定义 target 依赖的其他 target，确保在编译本 target 之前，其他的 target 已经被构建
ADD_DEPENDENCIES(target-name depend-target1 depend-target2 ...)

# 3.ADD_TEST(testname Exename arg1 arg2 ...)
# testname 是自定义的 test 名称，Exename 可以是构建的目标文件也可以是外部脚本等等，后面连接传递给可执行文件的参数。
# 如果没有在同一个 CMakeLists.txt 中打开ENABLE_TESTING()指令，任何 ADD_TEST 都是无效的
ADD_TEST(mytest ${PROJECT_BINARY_DIR}/bin/main)
# 4.控制 Makefile 是否构建 test 目标，涉及工程所有目录，一般情况这个指令放在工程的主CMakeLists.txt 中
ENABLE_ESTING() 

# 5.发现一个目录下所有的源代码文件并将列表存储在一个变量中，这个指令临时被用来自动构建源文件列表
AUX_SOURCE_DIRECTORY(dir VARIABLE)

# 6.在指定的目录运行某个程序，通过 ARGS 添加参数，如果要获取输出和返回值
# 可通过 OUTPUT_VARIABLE 和 RETURN_VALUE 分别定义两个变量
# 该指令可以在 CMakeLists.txt 处理过程中支持任何命令，如根据系统情况去修改代码文件
# 在 CMakeLists.txt 处理过程中执行命令，并不会在生成的 Makefile 中执行
EXEC_PROGRAM(Executable [directory in which to run]
                 [ARGS <arguments to executable>]
                 [OUTPUT_VARIABLE <var>]
                 [RETURN_VALUE <var>])
# 在 src 目录执行 ls 命令，并把结果和返回值存下来
EXEC_PROGRAM(ls ARGS "*.c" OUTPUT_VARIABLE LS_OUTPUT RETURN_VALUELS_RVALUE)
IF(not LS_RVALUE)
MESSAGE(STATUS "ls result: " ${LS_OUTPUT})
ENDIF(not LS_RVALUE)

# 7.文件操作指令
FILE(WRITE filename "message to write"... )
FILE(APPEND filename "message to write"... )
FILE(READ filename variable)
FILE(GLOB  variable [RELATIVE path] [globbing expressions]...)
FILE(GLOB_RECURSE variable [RELATIVE path][globbing expressions]...)
FILE(REMOVE [directory]...)
FILE(REMOVE_RECURSE [directory]...)
FILE(MAKE_DIRECTORY [directory]...)
FILE(RELATIVE_PATH variable directory file)
FILE(TO_CMAKE_PATH path result)
FILE(TO_NATIVE_PATH path result)

# 8.载入 CMakeLists.txt 文件，也用于载入预定义的 cmake 模块
# OPTIONAL 参数的作用是文件不存在也不会产生错误
# 可以指定载入一个文件，如果定义的是一个模块，那么将在CMAKE_MODULE_PATH中
# 搜索这个模块并入。载入的内容将在处理到 INCLUDE 语句是直接执行。
INCLUDE(file1 [OPTIONAL])
INCLUDE(module [OPTIONAL])

# 9.Find
# VAR 变量代表找到的文件全路径，包含文件名
FIND_FILE(<VAR> name1 path1 path2 ...) 
# VAR 变量表示找到的库全路径，包含库文件名
FIND_LIBRARY(<VAR> name1 path1 path2 ...)
# e.g.
FIND_LIBRARY(libX X11 /usr/lib)
IF(NOT libX)
MESSAGE(FATAL_ERROR “libX not found”)
ENDIF(NOT libX)
# VAR 变量代表包含这个文件的路径
FIND_PATH(<VAR> name1 path1 path2 ...) 
# VAR 变量代表包含这个程序的全路径
FIND_PROGRAM(<VAR> name1 path1 path2 ...) 
# 调用预定义在 CMAKE_MODULE_PATH 下的 Find<name>.cmake 模块，
# 也可以自己 定义Find<name>模块，通过SET(CMAKE_MODULE_PATH dir)将其放入工程的某个目录中供工程使用
FIND_PACKAGE(<name> [major.minor] [QUIET] [NO_MODULE]
                 [[REQUIRED|COMPONENTS] [componets...]])

# 10.IF指令
IF(expression)
          # THEN section.
          COMMAND1(ARGS ...)
          COMMAND2(ARGS ...)
          ...
        ELSE(expression)
          # ELSE section.
          COMMAND1(ARGS ...)
          COMMAND2(ARGS ...)
          ...
ENDIF(expression)
# 凡是出现 IF 的地方一定要有对应的 ENDIF。出现 ELSEIF 的地方，ENDIF 是可选的
# IF(var)，如果变量不是空，0，N, NO, OFF, FALSE, NOTFOUND 或<var>_NOTFOUND 时，表达式为真。
# IF(NOT var )，与上述条件相反
# IF(var1 AND var2)，当两个变量都为真是为真。
# IF(var1 OR var2)，当两个变量其中一个为真时为真。
# IF(COMMAND cmd)，当给定的cmd确实是命令并可以调用是为真。
# IF(EXISTS dir)或者IF(EXISTS file)，当目录名或者文件名存在时为真。
# IF(file1 IS_NEWER_THAN file2)，当 file1 比 file2 新，或者 file1/file2 其 中有一个不存在时为真，文件名请使用完整路径。
# IF(IS_DIRECTORY dirname)，当dirname是目录时，为真
# 正则匹配
IF(variable MATCHES regex)
IF(string MATCHES regex)
# IF("hello" MATCHES "ell")
MESSAGE("true")
ENDIF("hello" MATCHES "ell"）

# 数字比较表达式
IF(variable LESS number) 
IF(string LESS number) 
IF(variable GREATER number) 
IF(string GREATER number) 
IF(variable EQUAL number) 
IF(string EQUAL number))

# 按照字母序的排列进行比较
IF(variable STRLESS string)
IF(string STRLESS string)
IF(variable STRGREATER string) 
IF(string STRGREATER string) 
IF(variable STREQUAL string)
IF(string STREQUAL string)

# 判断变量定义：IF(DEFINED variable)
IF(WIN32)
    MESSAGE(STATUS “This is windows.”) 
    # 作一些 Windows 相关的操作
ELSE(WIN32)
    MESSAGE(STATUS “This is not windows”) 
    # 作一些非 Windows 相关的操作
ENDIF(WIN32)

# 简化ELSE、ENDIF,使用开关语句
SET(CMAKE_ALLOW_LOOSE_LOOP_CONSTRUCTS ON)
# 简化为
IF(WIN32)
ELSE()
ENDIF()
# 配合ELSEIF使用
IF(WIN32)
#do something related to WIN32 
ELSEIF(UNIX)
#do something related to UNIX
ELSEIF(APPLE)
#do something related to APPLE
ENDIF(WIN32)

# 11.WHILE
WHILE(condition)
          COMMAND1(ARGS ...)
          COMMAND2(ARGS ...)
          ...
ENDWHILE(condition)

# 12.FOREACH
# 列表
AUX_SOURCE_DIRECTORY(. SRC_LIST) 
FOREACH(F ${SRC_LIST})
    MESSAGE(${F})
ENDFOREACH(F)
# 范围
FOREACH(VAR RANGE 10) 
MESSAGE(${VAR}) 
ENDFOREACH(VAR)
# 范围和步进
FOREACH(A RANGE 5 15 3) 
    MESSAGE(${A}) 
ENDFOREACH(A) 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161

CMake模块

• 以往找库链接的过程：引入+链接

# /src/CMakeLists.txt
INCLUDE_DIRECTORIES(/usr/include)
TARGET_LINK_LIBRARIES(curltest curl)
1
2
3

• 使用CMake模块

让工程找到 FindHELLO.cmake 模块(存放在工程中的 cmake 目录)

# /CMakeLists.txt
SET(CMAKE_MODULE_PATH ${PROJECT_SOURCE_DIR}/cmake)
1
2

FIND_PACKAGE可以直接调用预定义的模块

# /src/CMakeLists.txt
# 对于系统预定义的 Find<name>.cmake 模块,都会定义以下几个变量：
# 判断模块是否被找到，如果没有找到，按照工程的需要关闭某些特性、给出提醒或者中止编译
# <name>_FOUND
# 如果 <name>_FOUND 为真，则将 <name>_INCLUDE_DIR 加入 INCLUDE_DIRECTORIES
# 将 <name>_LIBRARY 加入 TARGET_LINK_LIBRARIES 中 
# FIND_PACKAGE(<name> [major.minor] [QUIET] [NO_MODULE]
#     [[REQUIRED|COMPONENTS] [componets...]])
FIND_PACKAGE(CURL)
IF(CURL_FOUND)
   INCLUDE_DIRECTORIES(${CURL_INCLUDE_DIR})
   TARGET_LINK_LIBRARIES(curltest ${CURL_LIBRARY})
ELSE(CURL_FOUND)
     MESSAGE(FATAL_ERROR ”CURL library not found”)
ENDIF(CURL_FOUND)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

• 自定义CMake模块

编库时，项目结构

- CMakeLists.txt
    - src
        CMakeLists.txt
        curl.c
    - cmake
        FindCURL.cmake
    - build
1
2
3
4
5
6
7

# /cmake/FindCURL.cmake
FIND_PATH(CURL_INCLUDE_DIR curl.h /usr/include/curl /usr/local/include/curl)
FIND_LIBRARY(CURL_LIBRARY NAMES curl PATH /usr/lib /usr/local/lib)
IF(CURL_INCLUDE_DIR AND CURL_LIBRARY)
   SET(CURL_FOUND TRUE)
ENDIF(CURL_INCLUDE_DIR AND CURL_LIBRARY)
IF(CURL_FOUND)
   # 根据FIND_PACKAGE中的QUIET参数判断
   IF(NOT CURL_FIND_QUIETLY)
       MESSAGE(STATUS "Found CURL: ${CURL_LIBRARY}")
   ENDIF(NOT CURL_FIND_QUIETLY)
ELSE(CURL_FOUND)
   # 根据FIND_PACKAGE中的REQUIRED参数判断
   IF(CURL_FIND_REQUIRED)
      MESSAGE(FATAL_ERROR "Could not find CURL library")
   ENDIF(CURL_FIND_REQUIRED)
ENDIF(CURL_FOUND)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

Make与CMake的联系与区别

• Make：用来处理编译顺序和依赖关系并构建最终项目的工具

• CMake：本身不执行Make过程，而是根据不同平台的特性，生成对应平台的Makefie，这样我们每个工程只要写一个CMake文件即可了，其余的交给不同平台的处理器来产生不同的Makefile文件即可。而且CMake的语法也更加简洁