CMake实用知识点之一

1 Q&A

  • Q : 在C++代码工程中，有**.h.in后缀的文件，有什么用？里面有这样的代码：#cmakedefine CROSS_COMPILE又是有什么作用？

  • A :

    在C++代码工程中，带有 .h.in 后缀的文件通常是 CMake 配置文件模板，用于生成配置头文件。这些文件通常包含一些占位符或宏定义，这些占位符或宏定义会在配置过程中被替换为实际的值。

    • .h.in 文件的用途

      • 模板文件：.h.in 文件是模板文件，其中包含占位符或预定义的宏。这些占位符将在 CMake 配置过程中被替换为实际的值，从而生成实际的头文件（通常是 .h 文件）。
      • 配置时间定义：这些文件允许在 CMake 配置时根据当前的配置选项、系统属性等生成特定的宏定义。这使得生成的头文件能够反映配置过程中的条件和选项。

    • cmakedefine 的作用

      • 宏替换：#cmakedefine 是 CMake 特定的指令，用于在配置过程中生成特定的宏定义。CMake 会根据 CMakeLists.txt 中的 configure_file 命令将这些指令替换为实际的宏定义或注释掉。

    • 示例解释

      假设有一个 config.h.in 文件：

      /* config.h.in - template for config.h */

#cmakedefine CROSS_COMPILE
#cmakedefine HAVE_LIBJPEG
#cmakedefine VERSION "@PROJECT_VERSION@"

      在 CMakeLists.txt 中，你可能有以下配置：

      # 设置一些选项或检查一些条件
set(CROSS_COMPILE 1)
set(HAVE_LIBJPEG 1)
set(PROJECT_VERSION "1.0.0")

# 生成 config.h 文件
configure_file(
  "${CMAKE_CURRENT_SOURCE_DIR}/config.h.in"
  "${CMAKE_CURRENT_BINARY_DIR}/config.h"
  @ONLY
)

      在 configure_file 命令执行后，CMake 会将 config.h.in 中的 #cmakedefine 指令替换为相应的宏定义，并替换占位符为实际的值，生成的 config.h 文件可能是这样的

      /* config.h - generated from config.h.in by CMake */

#define CROSS_COMPILE 1
#define HAVE_LIBJPEG 1
#define VERSION "1.0.0"

    • 更详细的解释

      • #cmakedefine：在配置过程中，如果 CROSS_COMPILE 被定义了（即在 CMakeLists.txt 中调用了 set(CROSS_COMPILE 1)），那么 #cmakedefine CROSS_COMPILE 将被替换为 #define CROSS_COMPILE 1。如果 CROSS_COMPILE 没有被定义，则 #cmakedefine CROSS_COMPILE 行会被注释掉。

      • @PROJECT_VERSION@：在 configure_file 中，@PROJECT_VERSION@ 会被替换为实际的项目版本字符串 1.0.0。

    • 配置示例

      假设有以下 CMakeLists.txt 文件：

      cmake_minimum_required(VERSION 3.10)

project(MyProject VERSION 1.0.0)

# 设置一些选项
option(CROSS_COMPILE "Enable cross compiling" ON)
option(HAVE_LIBJPEG "Enable JPEG support" ON)

# 生成 config.h 文件
configure_file(
  "${CMAKE_CURRENT_SOURCE_DIR}/config.h.in"
  "${CMAKE_CURRENT_BINARY_DIR}/config.h"
  @ONLY
)

      配置并生成项目后，CMake 会将这些指令替换为实际的宏定义，从而生成最终的 config.h 文件。

    • 总结

      带有 .h.in 后缀的文件是 CMake 用来生成配置头文件的模板文件。它们允许根据项目配置和系统属性生成特定的宏定义。#cmakedefine 指令用于在配置过程中生成这些宏定义，并根据条件将其替换为实际的值或注释掉。通过这种方式，CMake 可以灵活地管理配置时间的条件和选项，从而生成合适的头文件

  • Q：CMAKE_FIND_ROOT_PATH有什么用？

  • A:

    在交叉编译中，只有设置了该宏，才可以让gdb自动到该目录下去寻找相关的g++或g--,之后只需要CAMKE_BUILD_TYPE和CMAKE_CXX_FLAGS_RELEASE就可实现同一份代码不同的平台下的编译;

    CMAKE_FIND_ROOT_PATH 是一个 CMake 变量，用于设置根路径（root paths），这些路径将被用于搜索依赖项、库、头文件和可执行文件。它通常用于交叉编译环境中，帮助指定搜索路径的优先级和位置。

    • 主要用途

      • 交叉编译：在交叉编译环境中，目标平台的库和头文件通常位于不同的目录中。使用 CMAKE_FIND_ROOT_PATH 可以帮助 CMake 在这些特定路径中查找依赖项，而不是在主机系统的默认路径中查找。
      • 控制查找顺序：通过配置 CMAKE_FIND_ROOT_PATH_MODE_* 变量（如 CMAKE_FIND_ROOT_PATH_MODE_LIBRARY，CMAKE_FIND_ROOT_PATH_MODE_INCLUDE，CMAKE_FIND_ROOT_PATH_MODE_PROGRAM），可以控制在查找库、头文件和可执行文件时是否使用 CMAKE_FIND_ROOT_PATH 变量。

    • 使用方法

      设置 CMAKE_FIND_ROOT_PATH

      可以在命令行或 CMakeLists.txt 文件中设置 CMAKE_FIND_ROOT_PATH：

      cmake -DCMAKE_FIND_ROOT_PATH=/path/to/sysroot ..

      或者在 CMakeLists.txt 文件中：

      set(CMAKE_FIND_ROOT_PATH /path/to/sysroot)

    • 控制查找模式

      可以通过设置 CMAKE_FIND_ROOT_PATH_MODE_* 变量来控制查找行为。这些变量的值可以是 ONLY，NEVER，或 BOTH。

      • ONLY：仅在 CMAKE_FIND_ROOT_PATH 中查找。
      • NEVER：不在 CMAKE_FIND_ROOT_PATH 中查找，只在默认路径中查找。
      • BOTH：在 CMAKE_FIND_ROOT_PATH 和默认路径中查找。

    • 示例

      # 仅在 CMAKE_FIND_ROOT_PATH 中查找库
set(CMAKE_FIND_ROOT_PATH_MODE_LIBRARY ONLY)

# 在 CMAKE_FIND_ROOT_PATH 和默认路径中查找头文件
set(CMAKE_FIND_ROOT_PATH_MODE_INCLUDE BOTH)

# 不在 CMAKE_FIND_ROOT_PATH 中查找可执行文件，只在默认路径中查找
set(CMAKE_FIND_ROOT_PATH_MODE_PROGRAM NEVER)

  • Q：如何在交叉编译时指定编译器呢？

  • A:

    设置如下的宏变量可以指定交叉编译时所要使用的编译器：

    • CMAKE_C_COMPILER: 指定C编译器
    • CMAKE_CXX_COMPILER: 指定C++编译器

    而对于交叉编译，尤其重要的是指定平台，以ARM为例，需要指定如下：

    • CMAKE_SYSTEM_NAME: set(CMAKE_SYSTEM_NAME Linux)
    • CMAKE_SYSTEM_PROCESSOER: set(CMAKE_SYSTEM_PROCESSOR arm)

2 Knowledge point

  • **.cmake： 称为工具链文件

  • CMAKE_CXX_COMPILER_ARG1：是 CMake 的一个内部变量，用于指定传递给 C++ 编译器的第一个命令行参数。

    在大多数情况下，不会直接使用或设置这个变量。它主要用于特殊情况下，尤其是涉及某些编译器或工具链时，CMake 可能需要为编译器命令行添加特定的参数。

    通常情况下，CMAKE_CXX_COMPILER_ARG1 不是用户直接配置的变量。更可能会通过工具链文件或高级构建脚本来间接设置它，如下示例：

    • 示例

      假设你需要为你的 C++ 编译器添加一个特殊的参数，例如 -foo，你可以在你的工具链文件（toolchain.cmake）中设置这个变量：

      # toolchain.cmake，当前工具链的名字

# 设置 C++ 编译器
set(CMAKE_CXX_COMPILER /usr/bin/g++)

# 设置第一个参数
set(CMAKE_CXX_COMPILER_ARG1 -foo) # 该变量是在工具链中所使用的

      然后在命令行中使用该工具链文件：

      cmake -DCMAKE_TOOLCHAIN_FILE=toolchain.cmake ..

    • 注意事项

      • 慎重使用：CMAKE_CXX_COMPILER_ARG1 是一个内部变量，通常仅用于特定的高级配置或工具链文件。直接修改或使用它可能会导致意想不到的行为或构建错误。
      • 工具链文件：在工具链文件中设置该变量是最常见的用法，因为工具链文件通常用于配置交叉编译环境或其他复杂的编译设置。
      • 调试和验证：如果你必须使用这个变量，确保通过 CMake 输出（例如，cmake --trace 或检查生成的构建文件）验证编译器命令行参数的正确性。

    • 结论:

      CMAKE_CXX_COMPILER_ARG1 是一个用于传递给 C++ 编译器的第一个命令行参数的内部变量。它主要用于特殊配置或工具链文件中，帮助确保编译器以特定方式运行。对于大多数用户和常规项目配置，不需要直接使用或修改这个变量。如果确实需要，请谨慎操作，并在工具链文件中进行适当的设置。

  • 条件判断语句

    if (condition)
  ...
else()
  ...
endif()

  • set解释

    SET(CMAKE_BUILD_TYPE Release CACHE STRING "Choose the type of build, options are: None(CMAKE_CXX_FLAGS or CMAKE_C_FLAGS used) Debug Release RelWithDebInfo MinSizeRel." FORCE)

    • 设置构建类型：
      SET(CMAKE_BUILD_TYPE Release ...) 这部分代码将CMAKE_BUILD_TYPE变量设置为Release。这意味着当项目被构建时，默认会生成优化过的二进制文件，以便在生产环境中使用，而不是包含调试信息的版本。

    • CACHE STRING：
      表明CMAKE_BUILD_TYPE变量被添加到CMake的缓存中，并且它的类型是字符串。这意味着一旦设置，它将在CMake的缓存中保留其值，直到显式更改。这对于在多次运行CMake时保持一致的构建配置非常有用。

    • FORCE：
      关键字表示即使CMAKE_BUILD_TYPE变量已经在CMake缓存中有了值，也会强制使用这里指定的新值（即Release）。这在你想要确保构建类型总是被设置为特定值，而不受之前CMake运行的影响时非常有用。

  • set_target_properties:设置目标的一些属性来改变它们构建的方式，如设置输出的名称，对于动态库，还可以用来指定动态库版本和API版本。我能够使用任何你想要的属性/值对，并且在随后的代码中调用get_target_property后get_target命令取出属性的值。

  • add_library: 用于生成动态库或静态库

    • 静态库：静态库没有版本号

      目标是hello_static, 源代码是${LIBHELLO_SRC}

      add_library(hello_static STATIC ${LIBHELLO_SRC})

    • 动态库：按照规定，动态库包含版本号

      • VERSION：指代动态库版本，

      • SOVERSION：指代API版本

      • 示例：

        # 要注意到这里的使用带s的set_target_properties, 那么参数中也要使用properties，是一一对应关系
set_target_properties(hello PROPERTIES VERSION 1.2 SOVERSION 1)

  • get_target_property: 获取某一个目标文件的属性信息，如下所示

    # 将当前的目标文件hello_static，生成时修改为自己想要的名字hello，这里的关键key是OUTPUT_NAME
# 还有就是，原先的hello_static名字对应库文件或可执行文件会被CMake清理，而只保留一个hello对应的可执行文件
set_target_properties(hello_static PROPERTIES OUTPUT_NAME "hello")

# 获取目标文件hello_static的输出文件名，这里的OUTPUT_VALUE是一个变量
get_target_property(OUTPUT_VALUE hello_static OUTPUT_NAME)

  • install：需要将libhello.a, libhello.so.x以及hello.h安装到系统目录，才能真正让其他人开发使用

    1. 将hello的共享库安装到<prefix>/lib目录；
    2. 将hello.h安装到<prefix>/include/hello目录;

    示例代码如下所示，注意这里是TARGETS带S，表示有多个目标文件，目标文件和输出文件是两个不同的概念，注意体会。还有就是FILES是指非可执行文件，就是普通的源代码。而DESTINATION后边跟着的是目的地文件夹。

    • LIBRARY：表示so动态库文件;

    • ARCHIVE: 表示lib静态库文件;

      install(TARGETS hello hello_static LIBRARY DESTINATION lib ARCHIVE DESTINATION lib)
install(FILES hello.h DESTINATION include/hello)

  • 可以指定so生成的位置，有两种方法

    1. 在主工程文件CMakeLists.txt中修改add_subdirectory(lib)指令来指定一个编译输出位置；
    2. 或者在lib/CMakeLists.txt中添加set(LIBRARY_OUTPUT_PATH <路径>)来指定一个新的位置;

  • 整体的CMakeLists.txt如下所示:

    SET (LIBHELLO_SRC hello.cpp)
# SET (LIBRARY_OUTPUT_PATH ${PROJECT_BINARY_DIR}/lib)
# 添加动态库，关键词为shared，不需要写全称libhello.so，
# 只需要填写hello即可，cmake系统会自动为你生成 libhello.X

ADD_LIBRARY (hello SHARED ${LIBHELLO_SRC})

# 添加静态库，关键词为static，ADD_LIBRARY (hello STATIC ${LIBHELLO_SRC})
# 仍然用hello作为target名时，是不能成功创建所需的静态库的，
# 因为hello作为一个target是不能重名的， 故把上面的hello修改为hello_static
# 同理，我不需要写全libhello_static.a
# 只需要填写hello即可，cmake系统会自动为我生成 libhello_static.X
ADD_LIBRARY (hello_static STATIC ${LIBHELLO_SRC})

# 按照一般的习惯，静态库名字跟动态库名字应该是一致的，只是扩展名不同；
# 即：静态库名为 libhello.a； 动态库名为libhello.so ；
# 所以，希望 "hello_static" 在输出时，不是"hello_static"，而是以"hello"的名字显示，故设置如下：
SET_TARGET_PROPERTIES (hello_static PROPERTIES OUTPUT_NAME "hello")
GET_TARGET_PROPERTY (OUTPUT_VALUE hello_static OUTPUT_NAME)
MESSAGE (STATUS "This is the hello_static OUTPUT_NAME: " ${OUTPUT_VALUE})

# cmake在构建一个新的target时，会尝试清理掉其他使用这个名字的库，
# 因此，在构建libhello.a时，就会清理掉libhello.so.
# 为了回避这个问题，比如再次使用SET_TARGET_PROPERTIES定义 CLEAN_DIRECT_OUTPUT属性。
SET_TARGET_PROPERTIES (hello_static PROPERTIES CLEAN_DIRECT_OUTPUT 1)
SET_TARGET_PROPERTIES (hello PROPERTIES CLEAN_DIRECT_OUTPUT 1)

# 按照规则，动态库是应该包含一个版本号的，
# VERSION指代动态库版本，SOVERSION指代API版本。

SET_TARGET_PROPERTIES (hello PROPERTIES VERSION 1.2 SOVERSION 1)

# 我们需要将libhello.a, libhello.so.x以及hello.h安装到系统目录，才能真正让其他人开发使用，
# 在本例中我们将hello的共享库安装到<prefix>/lib目录；
# 将hello.h安装<prefix>/include/hello目录。

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

  • set_target_properties有哪些key?

    是 CMake 中的一个命令，用于设置特定目标（例如可执行文件、库等）的属性。以下是一些常见的 key 属性及其含义：

    4 + 2 + 2 + 2 + 1

    • ARCHIVE_OUTPUT_DIRECTORY:指定目标的归档文件（静态库）的输出目录。

    • LIBRARY_OUTPUT_DIRECTORY: 指定目标的库文件（共享库、模块库等）的输出目录。

    • RUNTIME_OUTPUT_DIRECTORY: 指定目标的运行时文件（可执行文件）的输出目录。

    • OUTPUT_NAME：指定目标生成的文件的名称，而不是使用默认的目标名称。

    • VERSION：设置目标的版本号（通常用于共享库）。

    • SOVERSION：设置共享库的接口版本号。

    • COMPILE_FLAGS：设置编译器标志（flags）。如：-std=c++0x是指C++11，是针对编译器而言的设置，是控制编译的不同行为的开关

    • COMPILE_DEFINITIONS： 为目标添加编译器定义（如宏定义）

    • LINK_FLAGS：设置链接器标志（flags）。比如

      • LINK_FLAGS "-Wl,-zdefs"
        • -Wl:告诉编译器将后面的选项传递给链接器，是GCC和Clang常用前缀，用于将选项传递给链接器
        • -z defs：表示连接器在链接时检查所有符号，确保所有符号在链接时得到解析。若有任何未定义的符号，链接过程将失败并报告错误

    • INCLUDE_DIRECTORIES： 为目标添加包含目录。

    • INSTALL_RPATH： 设置目标在安装后的运行时搜索库的路径（即 RPATH）。

    • CLEAR_DIRECT_OUTPUT: 设置为 1 时，CMake 会在生成新的目标输出文件之前清除以前生成的同名文件。这对于避免冲突和确保生成的文件是最新的非常有用。

    以下是一个使用 set_target_properties 的简单示例：

    add_executable(myapp main.cpp)
set_target_properties(myapp PROPERTIES
    RUNTIME_OUTPUT_DIRECTORY "${CMAKE_BINARY_DIR}/bin"
    OUTPUT_NAME "my_application"
    VERSION "1.0.0"
    SOVERSION "1"
    COMPILE_FLAGS "-Wall"
)
    • 详细介绍

      • COMPILE_DEFINITIONS： 为目标添加编译器定义（如宏定义），就是在开始编译时，源代码中添加相应的宏。这样在源代码中，就可以使用预处理命令#ifdef #endif，来选择性的打开某些我们关心的代码，示例如下：

        以下是一个简单的示例 CMakeLists.txt 文件，展示了如何使用 COMPILE_DEFINITIONS 属性：

        cmake_minimum_required(VERSION 3.0)
project(MyProject)

# 添加一个可执行文件
add_executable(myapp main.cpp)

# 设置编译器定义
target_compile_definitions(myapp PRIVATE
    DEBUG_MODE                # 定义一个名为 DEBUG_MODE 的宏
    VERSION_NUMBER=123        # 定义一个名为 VERSION_NUMBER 的宏，并设定其值为 123
    USE_FEATURE_X            # 定义一个名为 USE_FEATURE_X 的宏，没有赋值，相当于 #define USE_FEATURE_X
)

# 另一种设置方式，直接使用 set_target_properties，注意它们之间使用分号隔开
# set_target_properties(myapp PROPERTIES
#     # 就是对应Visual Studio中项目属性页中配置属性/C/C++/预处理器中的预处理器定义，由于可以有很多，所有使用S结尾
#     COMPILE_DEFINITIONS "DEBUG_MODE;VERSION_NUMBER=123;USE_FEATURE_X" 
# )

      • INSTALL_RPATH： 设置目标在安装后的运行时搜索库的路径（即 RPATH）。

        用途: 当我安装一个目标（例如共享库或可执行文件）时，RPATH用于指定该目标在运行时如何找到它所依赖的共享库。

        假设有一个目标 myapp，它依赖于某些安装在特定目录（例如 /usr/local/lib）中的库。我就可以使用 INSTALL_RPATH 属性来指定安装后的运行路径

        add_executable(myapp main.cpp)
set_target_properties(myapp PROPERTIES
  INSTALL_RPATH "/usr/local/lib"
)

  • CMAKE_INSTALL_PREFIX：宏展开之后为/usr/local,该目录通常存放本地安装的软件和文件

  • INSTALL： 该函数用于指定项目安装的目标和安装路径，其中

    • RUNTIME：指定可执行文件的安装路径。与其他关键字（如 LIBRARY 和 ARCHIVE）一起使用，可以分别为可执行文件、共享库和静态库指定安装路径。

      • 若value指定为绝对路径，就会用使用到/usr/local
      • 若value指定为相对路径，就会使用了${CMAKE_INSTALL_PREFIX}, 即安装在/usr/local下

    • LIBRARY：指定共享库文件安装路径。

    • ARCHIVE：指定静态库指定安装路径。

    • EXPORT: 导出目标及其属性，以便其它项目能够使用 find_package 导入这些目标，注意这里是导入库了，库中可以有很多静态库或动态库

      以上三种二进制文件都是目标文件，所以统一用TARGETS来表示

    INSTALL 中的 EXPORT 属性

    • 作用: 导出目标及其属性，以便其他项目能够使用 find_package 导入这些目标。

    • 用途: 使项目的构建配置可以被其他项目重用，简化依赖管理和集成过程。

    • 使用示例

      假设我有一个库项目，并希望其它项目能够使用这个库，可以这样设置

        cmake_minimum_required(VERSION 3.10)
  project(MyLibraryProject)

  # 创建一个库
  add_library(mylib mylib.cpp)

  # 定义安装目标
  install(TARGETS mylib
      EXPORT MyLibraryTargets
      LIBRARY DESTINATION lib
      ARCHIVE DESTINATION lib
      RUNTIME DESTINATION bin
      INCLUDES DESTINATION include
  )

  # 安装头文件
  install(FILES mylib.h DESTINATION include)

  # 安装导出文件
  install(EXPORT MyLibraryTargets
      FILE MyLibraryTargets.cmake
      DESTINATION lib/cmake/MyLibrary
  )

      在这个示例中：

      • add_library(mylib mylib.cpp)： 创建了一个库 mylib。
      • install(TARGETS mylib ... EXPORT MyLibraryTargets ...)： 指定安装目标，并将mylib导出为 MyLibraryTargets。
      • install(EXPORT MyLibraryTargets ...)： 安装导出文件 MyLibraryTargets.cmake，这个文件包含了mylib的安装信息。

      生成导出文件

      生成的 MyLibraryTargets.cmake 文件包含了关于 mylib 的安装路径和其他相关信息，使得其他项目可以通过 find_package 轻松导入 mylib。

      在其他项目中使用导出的目标

      假设有一个新的项目想要使用导出的 mylib 库，可以这样写：

        cmake_minimum_required(VERSION 3.10)
  project(MyAppProject)

  # 查找安装的库，注意：安装的库和链接导入的库是两个不同的概念，安装的库通过`install(... export MyLib)`来完成，并生成对象的MyLib.cmake文件，find_package通过该文件找到安装的库名，并找到该库名下的静态库文件
  find_package(MyLibrary REQUIRED PATHS /path/to/installed/lib/cmake/MyLibrary)

  # 创建可执行文件，并链接导入的库
  add_executable(myapp main.cpp)
  target_link_libraries(myapp PRIVATE mylib)

      在这个示例中：

      • find_package(MyLibrary REQUIRED PATHS /path/to/installed/lib/cmake/MyLibrary)： 查找并导入 MyLibrary。
      • target_link_libraries(myapp PRIVATE mylib)： 链接导入的 mylib 库。

      优势：

      • 简化依赖管理: 通过导出和导入目标，可以轻松管理项目之间的依赖关系，而不需要手动指定库的路径和其他细节。
      • 提高可重用性: 项目的构建配置可以被其他项目重用，减少重复工作。
      • 增强集成性: 使用 EXPORT 属性，可以更好地集成多个项目，特别是当这些项目需要共享库或其他目标时。

      总结：

      INSTALL 命令中的 EXPORT 属性用于导出目标的安装信息。

      导出的信息可以生成一个 CMake 脚本文件，使其他项目可以通过 find_package 导入这些目标。

      这种机制简化了依赖管理，提高了项目的可重用性和集成性

使用 RUNTIME 关键字的示例

假设我有一个可执行文件 myapp 和一个库 mylib，我希望在安装过程中将它们分别安装到不同的目录中，如下所示：

  cmake_minimum_required(VERSION 3.10)
  project(MyProject)

  # 创建库
  add_library(mylib SHARED mylib.cpp)

  # 创建可执行文件
  add_executable(myapp main.cpp)

  # 链接库
  target_link_libraries(myapp PRIVATE mylib)

  # 安装库文件
  install(TARGETS mylib
      LIBRARY DESTINATION lib
  )

  # 安装可执行文件
  install(TARGETS myapp
      RUNTIME DESTINATION bin
  )

  • 文件说明：

    • RUNTIME: 指定安装可执行文件（如 .exe、.bin、.dll 文件）的路径。主要用于安装可运行的二进制文件。
    • LIBRARY: 指定安装动态库（如 .so 文件）的路径。主要用于安装动态链接库。
    • ARCHIVE: 指定安装静态库（如 .a 文件）的路径。主要用于安装静态链接库。

    以下是一个综合的例子：

    cmake_minimum_required(VERSION 3.10)
project(MyProject)

# 创建静态库
add_library(mylib_static STATIC mylib_static.cpp)

# 创建动态库
add_library(mylib_shared SHARED mylib_shared.cpp)

# 创建可执行文件
add_executable(myapp main.cpp)

# 链接动态库
target_link_libraries(myapp PRIVATE mylib_shared)

# 安装静态库
install(TARGETS mylib_static
    ARCHIVE DESTINATION lib/static
)

# 安装动态库
install(TARGETS mylib_shared
    LIBRARY DESTINATION lib/shared
)

# 安装可执行文件
install(TARGETS myapp
    RUNTIME DESTINATION bin
)

  • $ENV{...}

    在 CMake 中，$ENV{...} 用于访问环境变量。通过这种方式，我可以在 CMake 脚本中使用操作系统环境变量的值。例如，$ENV{ASDF} 将访问名为 ASDF 的环境变量的值。

    • 使用示例
      假设我有一个环境变量 ASDF，并希望在 CMake 脚本中使用它的值，可以这样做：

      设置环境变量，在命令行中设置环境变量 ASDF，如下所示：

      export ASDF=/path/to/some/directory

    • 在 CMake 脚本中使用环境变量
      在我的 CMakeLists.txt 文件中，可以使用 $ENV{ASDF} 来访问 ASDF 环境变量的值：

      cmake_minimum_required(VERSION 3.10)
project(MyProject)

# 获取环境变量 ASDF 的值
set(MY_ASDF_PATH $ENV{ASDF})

# 打印环境变量的值
message(STATUS "ASDF is set to ${MY_ASDF_PATH}")

# 使用环境变量的值
include_directories(${MY_ASDF_PATH}/include)
link_directories(${MY_ASDF_PATH}/lib)

add_executable(myapp main.cpp)
target_link_libraries(myapp mylib)

      在这个示例中：

      set(MY_ASDF_PATH $ENV{ASDF}) 将环境变量 ASDF 的值赋给 CMake 变量 MY_ASDF_PATH。
message(STATUS "ASDF is set to ${MY_ASDF_PATH}") 打印环境变量 ASDF 的值。
include_directories(${MY_ASDF_PATH}/include) 使用环境变量 ASDF 的值指定包含目录。
link_directories(${MY_ASDF_PATH}/lib) 使用环境变量 ASDF 的值指定库目录。

      适用场景

      • 配置依赖路径: 例如，您可以将第三方库的路径设置为环境变量，并在 CMake 脚本中引用它，以便在不同的开发环境中灵活配置。
      • 条件编译: 根据环境变量的值来启用或禁用某些功能或编译选项。
      • 跨平台构建: 使用环境变量来处理不同平台上的路径或设置差异。

      注意事项

      确保在运行 CMake 之前环境变量已被设置。

      如果环境变量未设置或为空，CMake 中对应的变量也将为空，可能会导致构建错误。因此，可以使用 CMake 的 if 语句来检查环境变量是否设置。

      if(NOT DEFINED ENV{ASDF})
    message(FATAL_ERROR "Environment variable ASDF is not set")
endif()

      通过这种方式，您可以在构建过程中灵活地使用和管理环境变量，从而更好地适应各种构建需求和环境。

  • INCLUDE_DIRECTORIES：

    在 CMake 中，INCLUDE_DIRECTORIES 指令用于指定编译器在编译源文件时搜索头文件的目录。INCLUDE_DIRECTORIES 还可以使用 BEFORE 关键字来控制包含目录的优先级。

    多个BEFORE，后面指定的BEFORE目录的优先级更高

    使用示例

    include_directories(BEFORE ${PROJ_SOURCE_DIR}/src/)

    解释

    • ${PROJ_SOURCE_DIR}/src/: 这是一个包含目录的路径，它通常是项目源代码目录的子目录。在这个示例中，它表示在 ${PROJ_SOURCE_DIR} 下的 src 目录。

    • BEFORE: 这个关键字用于确保指定的包含目录在包含搜索路径列表的前面（即具有更高的优先级）。
      含义

    通过使用 BEFORE 关键字，您可以确保 ${PROJ_SOURCE_DIR}/src/ 目录中的头文件比其他任何通过 include_directories 指定的目录中的头文件更优先被找到和使用。

    详细解释：

    • 优先级控制:

      当编译器查找头文件时，它会按照包含目录的顺序进行搜索。使用 BEFORE 关键字，可以将 ${PROJ_SOURCE_DIR}/src/ 放在搜索路径的前面，确保该目录中的头文件首先被找到。

    • 避免命名冲突:

      如果项目中有多个包含目录，且这些目录中有同名的头文件，使用 BEFORE 可以确保指定目录中的头文件优先被使用，避免不必要的命名冲突。

    • 示例场景

      假设我的项目结构如下：

      MyProject/
├── CMakeLists.txt
├── src/
│   └── myheader.h
└── include/
    └── myheader.h

      在 CMakeLists.txt 中：

      cmake_minimum_required(VERSION 3.10)
project(MyProject)

# 指定源文件
add_executable(myapp src/main.cpp)

# 指定包含目录，使用 BEFORE 确保 src 目录优先
include_directories(BEFORE ${PROJ_SOURCE_DIR}/src/)
include_directories(${PROJ_SOURCE_DIR}/include/)

      在这个例子中，如果 src/main.cpp 文件包含了 #include "myheader.h"，那么编译器会首先在 src/ 目录中查找 myheader.h，因为 src/ 目录被指定为优先目录。只有在 src/ 目录中找不到 myheader.h 时，编译器才会去 include/ 目录中查找。

      通过这种方式，可以更精细地控制包含目录的搜索顺序，以满足项目的特定需求。

  • PROJ_SOURCE_DIR： 表示当前工程的根目录，获取方式为${PROJ_SOURCE_DIR}

  • $<TARGET_FILE:ABC>： 是生成器表达式，用于获取可执行文件ABC的完整文件路径

posted @ 2024-07-18 17:43  绍荣  阅读(3)  评论(0)  编辑  收藏  举报