CMake常见的命令

研來如此

已于 2025-04-14 15:19:52 修改

阅读量1.1k

点赞数 41

文章标签： linux cmake 学习笔记

于 2025-03-24 23:03:13 首次发布

本文链接：https://blog.csdn.net/yan_lai/article/details/146469701

版权

指定使用的 cmake 的最低版本-cmake_minimum_required

cmake_minimum_required(VERSION 3.0)

指定项目名称-project

project(MyProject)

生成可执行程序-add_executable

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

定义变量-SET

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

# VAR：变量名
# VALUE：变量值

查找某个路径下的所有源文件-aux_source_directory

aux_source_directory(< dir > < variable >)

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

搜索文件-file

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

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

包含头文件-include_directories

include_directories(headpath)

制作静态库-add_library

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

制作动态库-add_library

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

链接静态库-link_libraries

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

指定库的路径-link_directories

link_directories(<lib path>)

链接动态库-target_link_libraries

target_link_libraries(
    <target> 
    <PRIVATE|PUBLIC|INTERFACE> <item>... 
    [<PRIVATE|PUBLIC|INTERFACE> <item>...]...)

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

显示信息-message

message([STATUS|WARNING|AUTHOR_WARNING|FATAL_ERROR|SEND_ERROR] "message to display" ...)

宏定义-add_definitions

add_definitions(-D宏名称)

添加子目录-add_subdirectory

add_subdirectory(目录名称)

find_package--查找并加载外部软件包

# 自动处理包的依赖关系、头文件路径、库文件路径等信息
find_package(<PackageName> [version] [EXACT] [QUIET] [MODULE]
             [REQUIRED] [[COMPONENTS] [components...]]
             [OPTIONAL_COMPONENTS components...]
             [NO_POLICY_SCOPE])

#  <PackageName>  要查找的软件包的名称，例如 Boost、OpenCV 等
# [version]
# 指定要查找的软件包的版本号，可以是具体的版本号（如 1.69.0），也可以是版本范围（如 >=1.69.0）
# [EXACT] 如果指定了 EXACT，则要求找到的软件包版本必须与指定的版本完全一致
# [QUIET] 使用 QUIET 参数时，如果未找到软件包，CMake 不会输出错误信息，而是继续执行后续脚本
# [MODULE] 指定使用 CMake 的模块模式查找软件包。通常，CMake 会先在 CMAKE_MODULE_PATH 中查找对应的 Find<PackageName>.cmake 模块文件
# [REQUIRED] 如果指定了 REQUIRED，当未找到软件包时，CMake 会停止配置过程并输出错误信息
# [[COMPONENTS] [components...]] 指定要查找的软件包的组件。有些软件包包含多个组件，你可以只选择需要的组件进行查找
# [OPTIONAL_COMPONENTS components...] 指定可选的组件。如果找不到这些组件，CMake 不会报错
# [NO_POLICY_SCOPE] 此参数用于控制策略的作用范围，一般较少使用

比如：
FIND_PACKAGE(OpenCV 4 PATHS ./libopencv REQUIRED)
整体功能概述

FIND_PACKAGE 是 CMake 里用于查找并加载外部软件包的命令。这段代码的主要功能是在 CMake 构建过程中查找 OpenCV 库，要求其版本为 4.x，并且会在指定路径 ./libopencv 下进行搜索，同时将其作为必需的依赖项。

参数详细解释

OpenCV：这是要查找的软件包名称，表明你期望在项目里使用 OpenCV 库。

4：代表版本要求，指定需要查找的 OpenCV 版本为 4.x。这里没有使用 EXACT 关键字，意味着只要找到的 OpenCV 版本大于或等于 4.0.0 就可以满足要求。

PATHS ./libopencv：PATHS 用于指定查找软件包的路径。这里明确指定在当前目录下的 libopencv 文件夹里查找 OpenCV 库。CMake 会优先在这个指定路径下搜索，若未找到，再去其他默认路径查找。

REQUIRED：此参数表示该软件包是项目必需的。若在指定路径以及其他默认路径中都未能找到符合要求的 OpenCV 库，CMake 会停止配置过程并输出错误信息，从而避免继续构建一个缺少必要依赖的项目。

find_library--在指定的路径中查找特定名称的库文件

find_library(<VAR>
             name | NAMES name1 [name2 ...]
             [HINTS path1 [path2 ... ENV var]]
             [PATHS path1 [path2 ... ENV var]]
             [PATH_SUFFIXES suffix1 [suffix2 ...]]
             [DOC "cache documentation string"]
             [REQUIRED]
             [NO_DEFAULT_PATH]
             [NO_CMAKE_ENVIRONMENT_PATH]
             [NO_CMAKE_PATH]
             [NO_SYSTEM_ENVIRONMENT_PATH]
             [NO_CMAKE_SYSTEM_PATH]
             [CMAKE_FIND_ROOT_PATH_BOTH |
              ONLY_CMAKE_FIND_ROOT_PATH |
              NO_CMAKE_FIND_ROOT_PATH])

1. <VAR>

用于存储找到的库文件的完整路径的变量名。如果找到了库，该变量将被设置为库文件的路径；如果未找到，变量将被设置为空。

2. name | NAMES name1 [name2 ...]

指定要查找的库的名称。可以只提供一个名称，也可以提供多个名称，CMake 会按顺序尝试查找这些名称对应的库。在不同操作系统上，库文件的命名可能有所不同，例如在 Linux 上，共享库通常以 lib 开头，以 .so 结尾；在 Windows 上，动态链接库以 .dll 结尾。

3. [HINTS path1 [path2 ... ENV var]]

指定查找库的提示路径。这些路径是优先搜索的，通常用于指定用户自定义的库路径。ENV var 表示从环境变量 var 中获取路径。

4. [PATHS path1 [path2 ... ENV var]]

指定查找库的搜索路径。这些路径在 HINTS 路径之后进行搜索。同样，ENV var 可以从环境变量中获取路径。

5. [PATH_SUFFIXES suffix1 [suffix2 ...]]

指定在搜索路径中追加的后缀。例如，如果搜索路径是 /usr/local，后缀是 lib，则实际搜索的路径是 /usr/local/lib。

6. [DOC "cache documentation string"]

为存储库路径的变量提供文档说明，该说明会显示在 CMake 的缓存中。

7. [REQUIRED]

如果指定了 REQUIRED，当未找到库时，CMake 会停止配置过程并输出错误信息。

8. [NO_DEFAULT_PATH]

不搜索默认的库路径，只在 HINTS 和 PATHS 指定的路径中搜索。

9. [NO_CMAKE_ENVIRONMENT_PATH]

不搜索 CMake 环境变量指定的路径。

10. [NO_CMAKE_PATH]

不搜索 CMake 特定的路径。

11. [NO_SYSTEM_ENVIRONMENT_PATH]

不搜索系统环境变量指定的路径。

12. [NO_CMAKE_SYSTEM_PATH]

不搜索 CMake 系统路径。

13. [CMAKE_FIND_ROOT_PATH_BOTH | ONLY_CMAKE_FIND_ROOT_PATH | NO_CMAKE_FIND_ROOT_PATH]

控制在交叉编译时如何处理搜索路径。CMAKE_FIND_ROOT_PATH_BOTH 表示同时搜索根路径和非根路径；ONLY_CMAKE_FIND_ROOT_PATH 表示只搜索根路径；NO_CMAKE_FIND_ROOT_PATH 表示不搜索根路径。

比如
FIND_LIBRARY(tensorflow_framework tensorflow_framework PATHS ./libtensorflow/lib REQUIRED)
整体功能概述

FIND_LIBRARY 是 CMake 中的一个命令，其主要作用是在指定路径中查找特定名称的库文件。这行命令的目的就是在 CMake 构建项目的过程里，查找 tensorflow_framework 库文件，并且将其作为项目必需的依赖项。

参数详细解释

tensorflow_framework：
这是一个变量名，用于存储找到的 tensorflow_framework 库文件的完整路径。要是成功找到了对应的库文件，tensorflow_framework 这个变量就会被设置为该库文件的实际路径；若未找到，此变量会为空。

tensorflow_framework：
这里指定了要查找的库文件的名称。在不同操作系统下，库文件的命名可能存在差异。例如在 Linux 系统中，共享库一般以 lib 开头，以 .so 结尾；在 macOS 上，动态库以 .dylib 结尾；在 Windows 上，动态链接库以 .dll 结尾。所以，CMake 会在搜索路径中查找名为 libtensorflow_framework.so（Linux）、libtensorflow_framework.dylib（macOS）或者 tensorflow_framework.dll（Windows）的文件。

PATHS ./libtensorflow/lib：
PATHS 用于指定查找库文件的搜索路径。此命令明确指定在当前目录下的 libtensorflow/lib 文件夹中查找 tensorflow_framework 库文件。如果在这个指定路径下找不到该库文件，CMake 还会尝试在其他默认路径中进行搜索。

REQUIRED：
该参数表明 tensorflow_framework 库是项目必需的依赖项。若在指定路径以及其他默认路径中都未能找到符合要求的 tensorflow_framework 库文件，CMake 会停止配置过程，并输出错误信息，以此避免继续构建一个缺少必要依赖的项目。

`find_path` --用于在指定的路径中查找包含特定文件的目录

find_path(<VAR>
          name | NAMES name1 [name2 ...]
          [HINTS path1 [path2 ... ENV var]]
          [PATHS path1 [path2 ... ENV var]]
          [PATH_SUFFIXES suffix1 [suffix2 ...]]
          [DOC "cache documentation string"]
          [REQUIRED]
          [NO_DEFAULT_PATH]
          [NO_CMAKE_ENVIRONMENT_PATH]
          [NO_CMAKE_PATH]
          [NO_SYSTEM_ENVIRONMENT_PATH]
          [NO_CMAKE_SYSTEM_PATH]
          [CMAKE_FIND_ROOT_PATH_BOTH |
           ONLY_CMAKE_FIND_ROOT_PATH |
           NO_CMAKE_FIND_ROOT_PATH])

1. <VAR>

用于存储找到的包含指定文件的目录的路径的变量名。如果找到了该目录，变量将被设置为该目录的路径；如果未找到，变量将被设置为空。

2. name | NAMES name1 [name2 ...]

指定要查找的文件的名称。可以只提供一个名称，也可以提供多个名称，CMake 会按顺序尝试查找这些名称对应的文件。

3. [HINTS path1 [path2 ... ENV var]]

指定查找目录的提示路径。这些路径是优先搜索的，通常用于指定用户自定义的路径。ENV var 表示从环境变量 var 中获取路径。

4. [PATHS path1 [path2 ... ENV var]]

指定查找目录的搜索路径。这些路径在 HINTS 路径之后进行搜索。同样，ENV var 可以从环境变量中获取路径。

5. [PATH_SUFFIXES suffix1 [suffix2 ...]]

指定在搜索路径中追加的后缀。例如，如果搜索路径是 /usr/local，后缀是 include，则实际搜索的路径是 /usr/local/include。

6. [DOC "cache documentation string"]

为存储目录路径的变量提供文档说明，该说明会显示在 CMake 的缓存中。

7. [REQUIRED]

如果指定了 REQUIRED，当未找到包含指定文件的目录时，CMake 会停止配置过程并输出错误信息。

8. [NO_DEFAULT_PATH]

不搜索默认的路径，只在 HINTS 和 PATHS 指定的路径中搜索。

9. [NO_CMAKE_ENVIRONMENT_PATH]

不搜索 CMake 环境变量指定的路径。

10. [NO_CMAKE_PATH]

不搜索 CMake 特定的路径。

11. [NO_SYSTEM_ENVIRONMENT_PATH]

不搜索系统环境变量指定的路径。

12. [NO_CMAKE_SYSTEM_PATH]

不搜索 CMake 系统路径。

13. [CMAKE_FIND_ROOT_PATH_BOTH | ONLY_CMAKE_FIND_ROOT_PATH | NO_CMAKE_FIND_ROOT_PATH]

控制在交叉编译时如何处理搜索路径。CMAKE_FIND_ROOT_PATH_BOTH 表示同时搜索根路径和非根路径；ONLY_CMAKE_FIND_ROOT_PATH 表示只搜索根路径；NO_CMAKE_FIND_ROOT_PATH 表示不搜索根路径。

比如
find_path(GFLAGS_INCLUDE_PATH gflags/gflags.h)
find_path 命令概述

find_path 是 CMake 里用于查找包含特定文件的目录的命令。当你在项目中需要使用某个库的头文件时，就可以用这个命令来确定这些头文件所在的目录。

参数解释

GFLAGS_INCLUDE_PATH：
这是一个变量名，用于存储找到的包含 gflags/gflags.h 头文件的目录的路径。在后续的 CMake 脚本里，你可以通过这个变量来引用该目录，比如将其添加到项目的包含目录列表中。

gflags/gflags.h：
这指定了要查找的文件的名称。find_path 命令会在一系列默认路径以及可能指定的额外路径中搜索包含 gflags/gflags.h 文件的目录。这里的 gflags 是一个目录名，gflags.h 是头文件的名称，意味着该头文件位于 gflags 目录下。

查找路径

在没有指定其他查找路径的情况下，find_path 会按照以下顺序搜索目录：

环境变量 CMAKE_PREFIX_PATH 中指定的路径。

系统默认的包含文件搜索路径，像 /usr/include、/usr/local/include 等。

configure_file--把一个输入文件复制到指定的输出文件，并且在复制过程中替换其中的 CMake 变量

configure_file(<input> <output>
               [COPYONLY] [ESCAPE_QUOTES] [@ONLY]
               [NEWLINE_STYLE [UNIX|DOS|WIN32|LF|CRLF]])

1. <input>

这是输入文件的路径，也就是你要进行处理的源文件。该文件可以包含 CMake 变量，这些变量会在配置过程中被替换为实际的值。

2. <output>

指定输出文件的路径，即经过处理后的文件要保存的位置。如果输出路径是相对路径，它会相对于当前的 CMake 二进制目录。

3. [COPYONLY]

若使用了 COPYONLY 参数，configure_file 只会简单地复制输入文件到输出文件，而不会对文件中的 CMake 变量进行替换。

4. [ESCAPE_QUOTES]

当指定 ESCAPE_QUOTES 时，在替换 CMake 变量时会对引号进行转义处理，避免引号在替换过程中引发问题。

5. [@ONLY]

使用 @ONLY 参数后，只有以 @VAR@ 这种形式表示的 CMake 变量才会被替换，而 ${VAR} 形式的变量不会被替换。

6. [NEWLINE_STYLE [UNIX|DOS|WIN32|LF|CRLF]]

此参数用于指定输出文件的换行符风格。UNIX 或 LF 表示使用 Unix 风格的换行符（\n）；DOS、WIN32 或 CRLF 表示使用 Windows 风格的换行符（\r\n）。

比如
CONFIGURE_FILE(
  ${CMAKE_CURRENT_LIST_DIR}/mcn.in.h
  ${CMAKE_CURRENT_LIST_DIR}/mcn.hh
)
这行 CMake 代码使用了 CONFIGURE_FILE 命令，其主要作用是将一个输入文件复制到指定的输出文件位置，并且在复制过程中替换输入文件里的 CMake 变量。

代码功能概述

这行代码的功能是把 mcn.in.h 文件复制到 mcn.hh，同时对 mcn.in.h 中出现的 CMake 变量进行替换操作。

参数详细解释

1. ${CMAKE_CURRENT_LIST_DIR}/mcn.in.h

CMAKE_CURRENT_LIST_DIR 是 CMake 内置的变量，它代表当前正在处理的 CMakeLists.txt 文件所在的目录。

整个路径表示输入文件 mcn.in.h 的完整位置。mcn.in.h 一般是一个模板文件，其中可能包含一些以特定格式（如 @VAR@ 或 ${VAR}）表示的 CMake 变量，这些变量会在配置过程中被实际的值替换。

2. ${CMAKE_CURRENT_LIST_DIR}/mcn.hh

同样借助 CMAKE_CURRENT_LIST_DIR 来确定目录，此路径指定了输出文件 mcn.hh 的完整位置。经过配置处理后，包含实际变量值的文件会被保存到这个位置。

option--定义可由用户控制的布尔型选项

option(<variable> "<help_text>" [initial value])

在 CMake 中，option 命令用于定义一个可由用户控制的布尔型选项，这在项目配置时十分实用，用户可以通过 CMake 命令行或者 CMake GUI 来开启或关闭某些特性。

1. <variable>

这是定义的选项对应的变量名。在 CMake 脚本后续的代码里，可以通过这个变量名来判断该选项是否被启用。若选项被启用，变量的值为 ON；若未启用，值为 OFF。

2. <help_text>

这是一个描述该选项用途的字符串，会在 CMake 生成配置时显示出来，帮助用户了解该选项的作用。当用户使用 cmake -LH 命令查看项目的可配置选项时，就会看到这个帮助文本。

3. [initial value]

这是选项的初始值，是一个可选参数。初始值可以是 ON 或者 OFF，分别代表选项默认开启或关闭。若不指定初始值，默认值为 OFF。

比如
# 定义一个名为 BUILD_TESTS 的选项，默认关闭
option(BUILD_TESTS "Build the test suite" OFF)
在这个示例中，定义了一个名为 BUILD_TESTS 的选项，其帮助文本为 "Build the test suite"，初始值为 OFF。

在命令行中设置选项

用户可以在命令行中使用 -D 选项来设置 option 定义的变量。例如，要开启上述示例中的 BUILD_TESTS 选项，可以这样执行 CMake 命令：
cmake -DBUILD_TESTS=ON ..
这样，在 CMake 配置过程中，BUILD_TESTS 变量的值就会被设置为 ON，从而执行构建测试套件的相关代码。

set_source_files_properties--为指定的源文件设置特定的属性

set_source_files_properties(<file1> [<file2> ...]
                            PROPERTIES <prop1> <value1>
                                       [<prop2> <value2> ...])

1. <file1> [<file2> ...]

指定要设置属性的源文件，可以是单个文件，也可以是多个文件，文件之间用空格分隔。文件路径可以是相对路径或绝对路径。

2. PROPERTIES

这是一个关键字，用于标识后面跟着的是要设置的属性和对应的值。

3. <prop1> <value1> [<prop2> <value2> ...]

这是一系列的属性 - 值对，用于指定要为源文件设置的属性及其对应的值。常见的属性如下：

COMPILE_FLAGS：为指定的源文件添加额外的编译标志。例如，可以为某个源文件设置特定的警告级别或优化选项。

OBJECT_DEPENDS：指定源文件生成的目标文件依赖的其他文件。当这些依赖文件发生变化时，CMake 会重新编译该源文件。

LANGUAGE：指定源文件的编程语言，例如 C、CXX（C++）等。这在混合语言项目中很有用。

GENERATED：将源文件标记为生成文件。生成文件通常是在构建过程中动态生成的，而不是手动编写的。

HEADER_FILE_ONLY：将源文件标记为仅头文件。这意味着该文件不会被编译成目标文件。

比如
# 标记 generated_file.cpp 为生成文件
set_source_files_properties(generated_file.cpp PROPERTIES GENERATED TRUE)
在这个示例中，将 generated_file.cpp 标记为生成文件，CMake 会知道该文件是在构建过程中动态生成的。通过 set_source_files_properties 命令，可以针对不同的源文件进行个性化的配置，以满足项目的特定需求。

set_source_files_properties--载入并执行指定的 CMake 脚本文件

(file1 [OPTIONAL] [RESULT_VARIABLE var] [NO_POLICY_SCOPE])

1. file1

这是必选参数，代表要包含的 CMake 脚本文件的路径。该路径可以是绝对路径，也能是相对路径。若为相对路径，CMake 会在当前目录以及 CMAKE_MODULE_PATH 所指定的目录中进行查找。

2. [OPTIONAL]

此为可选参数。若指定了 OPTIONAL，当指定的文件不存在时，CMake 不会报错，而是会继续执行后续的脚本。若未指定该参数，当文件不存在时，CMake 会抛出错误并终止配置过程。

3. [RESULT_VARIABLE var]

这也是可选参数。若指定了 RESULT_VARIABLE，CMake 会把包含文件的结果存储在指定的变量 var 中。若文件成功包含，变量的值为文件的完整路径；若文件不存在且使用了 OPTIONAL 参数，变量的值为空。

4. [NO_POLICY_SCOPE]

同样是可选参数。默认情况下，被包含的文件会在一个新的作用域中执行，这样可以避免变量名冲突。若指定了 NO_POLICY_SCOPE，被包含的文件会在当前作用域中执行。

INSTALL--用于指定项目在安装阶段的操作

安装目标（可执行文件、库等）

INSTALL(TARGETS <target1> <target2> ...
        [EXPORT <export-name>]
        [RUNTIME DESTINATION <dir>]
        [LIBRARY DESTINATION <dir>]
        [ARCHIVE DESTINATION <dir>]
        [INCLUDES DESTINATION <dir>]
        [PERMISSIONS permissions...]
        [CONFIGURATIONS [Debug|Release|...]]
        [COMPONENT <component>]
        [OPTIONAL])

参数说明：
<target1> <target2> ...：要安装的目标名称，这些目标通常是通过 add_executable 或 add_library 命令创建的。
EXPORT <export-name>：可选参数，将目标导出到一个导出集中，方便其他项目使用。
RUNTIME DESTINATION <dir>：指定可执行文件的安装目录。
LIBRARY DESTINATION <dir>：指定共享库的安装目录。
ARCHIVE DESTINATION <dir>：指定静态库的安装目录。
INCLUDES DESTINATION <dir>：指定包含目录的安装位置。
PERMISSIONS permissions...：可选参数，设置安装文件的权限，例如 OWNER_READ OWNER_WRITE GROUP_READ WORLD_READ。
CONFIGURATIONS [Debug|Release|...]：可选参数，指定在哪些配置下进行安装，如 Debug 或 Release。
COMPONENT <component>：可选参数，将目标归为一个安装组件，方便用户选择安装哪些组件。
OPTIONAL：可选参数，如果安装文件不存在，不会报错。

安装文件

INSTALL(FILES <file1> <file2> ...
        DESTINATION <dir>
        [PERMISSIONS permissions...]
        [CONFIGURATIONS [Debug|Release|...]]
        [COMPONENT <component>]
        [RENAME <name>]
        [OPTIONAL])

参数说明：
<file1> <file2> ...：要安装的文件列表。
DESTINATION <dir>：指定文件的安装目录。
PERMISSIONS permissions...：设置安装文件的权限。
CONFIGURATIONS [Debug|Release|...]：指定在哪些配置下进行安装。
COMPONENT <component>：将文件归为一个安装组件。
RENAME <name>：可选参数，重命名安装的文件。
OPTIONAL：如果文件不存在，不会报错。

安装目录

INSTALL(DIRECTORY <dir1> <dir2> ...
        DESTINATION <dir>
        [FILE_PERMISSIONS permissions...]
        [DIRECTORY_PERMISSIONS permissions...]
        [USE_SOURCE_PERMISSIONS]
        [CONFIGURATIONS [Debug|Release|...]]
        [COMPONENT <component>]
        [FILES_MATCHING]
        [PATTERN <pattern> | REGEX <regex>]
        [EXCLUDE])

参数说明：
<dir1> <dir2> ...：要安装的目录列表。
DESTINATION <dir>：指定目录的安装位置。
FILE_PERMISSIONS permissions...：设置安装文件的权限。
DIRECTORY_PERMISSIONS permissions...：设置安装目录的权限。
USE_SOURCE_PERMISSIONS：使用源文件的权限进行安装。
CONFIGURATIONS [Debug|Release|...]]：指定在哪些配置下进行安装。
COMPONENT <component>：将目录归为一个安装组件。
FILES_MATCHING：可选参数，结合 PATTERN 或 REGEX 使用，只安装匹配的文件。
PATTERN <pattern> | REGEX <regex>：指定匹配的文件模式或正则表达式。
EXCLUDE：可选参数，排除匹配的文件。

比如，
INSTALL(TARGETS McnApp RUNTIME DESTINATION bin)
这条指令的主要作用是告知 CMake 在执行安装操作时，应该如何处理指定的目标（target）。简单来说，它会将目标文件安装到指定的目录。

INSTALL：这是 CMake 的一个命令，用于定义安装规则。在项目构建完成后，使用 make install（对于 Unix Makefiles 生成器）或者 cmake --install 命令时，CMake 会依据这些规则来进行文件的安装操作。
TARGETS McnApp：TARGETS 关键字表明接下来要指定的是目标文件。McnApp 是你在 CMakeLists.txt 中通过 add_executable 或者 add_library 命令定义的目标名称。例如，如果你有这样的代码 add_executable(McnApp main.cpp)，那么 McnApp 就是一个可执行文件目标。
RUNTIME：这个关键字用于指定目标文件的类型。RUNTIME 表示可执行文件，通常是在 Windows 上的 .exe 文件，或者在类 Unix 系统上具有可执行权限的文件。在 CMake 里，除了 RUNTIME，还有其他类型，如 LIBRARY（动态库）、ARCHIVE（静态库）等。
DESTINATION bin：DESTINATION 关键字用于指定目标文件安装的目标目录。bin 是目标目录的名称，它通常是相对路径。在执行安装操作时，CMake 会将 McnApp 可执行文件安装到指定的 bin 目录下。这里的 bin 目录是相对于安装前缀（CMAKE_INSTALL_PREFIX）的，默认情况下，CMAKE_INSTALL_PREFIX 在类 Unix 系统上是 /usr/local，在 Windows 上是 C:\Program Files\项目名

execute_process--CMake 里用于在 CMake 配置过程中执行外部命令

execute_process(COMMAND <cmd1> [args1...]]
                [COMMAND <cmd2> [args2...] [...]]
                [WORKING_DIRECTORY <directory>]
                [TIMEOUT <seconds>]
                [RESULT_VARIABLE <variable>]
                [OUTPUT_VARIABLE <variable>]
                [ERROR_VARIABLE <variable>]
                [INPUT_FILE <file>]
                [OUTPUT_FILE <file>]
                [ERROR_FILE <file>]
                [OUTPUT_QUIET]
                [ERROR_QUIET]
                [OUTPUT_STRIP_TRAILING_WHITESPACE]
                [ERROR_STRIP_TRAILING_WHITESPACE])

参数说明

1. COMMAND <cmd1> [args1...]

这是必选参数，用于指定要执行的外部命令及其参数。你可以依次列出多个 COMMAND，它们会按顺序依次执行，前一个命令的输出会作为后一个命令的输入，类似于 Unix 管道。

2. WORKING_DIRECTORY <directory>

可选参数，用于指定命令执行时的工作目录。若不指定，默认是当前 CMake 配置文件所在的目录。

3. TIMEOUT <seconds>

可选参数，用于设置命令执行的超时时间（单位为秒）。若命令执行时间超过这个设定值，CMake 会终止该命令的执行。

4. RESULT_VARIABLE <variable>

可选参数，用于存储命令执行的返回结果。如果命令成功执行，返回值通常为 0；若执行失败，则返回非零值。

5. OUTPUT_VARIABLE <variable>

可选参数，用于存储命令的标准输出内容。执行结束后，标准输出的内容会被存储在指定的变量中。

6. ERROR_VARIABLE <variable>

可选参数，用于存储命令的错误输出内容。执行结束后，错误输出的内容会被存储在指定的变量中。

7. INPUT_FILE <file>

可选参数，用于指定命令的输入文件。命令会从该文件中读取输入数据。

8. OUTPUT_FILE <file>

可选参数，用于指定将命令的标准输出内容写入到指定的文件中。

9. ERROR_FILE <file>

可选参数，用于指定将命令的错误输出内容写入到指定的文件中。

10. OUTPUT_QUIET

可选参数，若指定该参数，命令的标准输出内容不会显示在 CMake 的输出中。

11. ERROR_QUIET

可选参数，若指定该参数，命令的错误输出内容不会显示在 CMake 的输出中。

12. OUTPUT_STRIP_TRAILING_WHITESPACE

可选参数，若指定该参数，会去除标准输出内容末尾的空白字符。

13. ERROR_STRIP_TRAILING_WHITESPACE

可选参数，若指定该参数，会去除错误输出内容末尾的空白字符。

比如
execute_process(
    COMMAND bash -c "find ${PROJECT_SOURCE_DIR}/../.. -type d -regex \".*output/include$\" | head -n1 | xargs dirname | tr -d '\n'"
    OUTPUT_VARIABLE OUTPUT_PATH
)
整体功能概述

这段 CMake 代码使用 execute_process 命令在 CMake 配置过程中执行一个外部的 Bash 命令。该 Bash 命令的主要目的是在指定目录下查找符合特定正则表达式的目录，然后提取出这些目录的上级目录路径，并将最终结果存储在 CMake 变量 OUTPUT_PATH 中。

代码逐行分析

execute_process(

这是 CMake 中用于执行外部命令的命令开始标记。

COMMAND bash -c "..."

bash -c：表示要在 Bash 环境中执行后续引号内的命令。-c 选项用于指定要执行的命令字符串。

引号内是具体的 Bash 命令，下面详细解释其各部分：

find ${PROJECT_SOURCE_DIR}/../.. -type d -regex ".*output/include$"

find：是一个常用的 Linux 命令，用于在指定目录下查找文件和目录。

${PROJECT_SOURCE_DIR}：这是 CMake 的内置变量，代表项目的源目录。${PROJECT_SOURCE_DIR}/../.. 表示从项目源目录向上两级的目录，也就是以此作为查找的起始目录。

-type d：指定查找的对象为目录。

-regex ".*output/include$"：使用正则表达式进行筛选，只查找名称以 output/include 结尾的目录。

| head -n1

|：是管道符号，用于将前一个命令的输出作为后一个命令的输入。

head -n1：从 find 命令的输出结果中取出第一行，也就是只保留第一个匹配到的目录路径。

| xargs dirname

xargs：用于将前一个命令的输出作为参数传递给后续命令。

dirname：是一个用于提取目录路径的命令，它会去掉文件或目录名的最后一部分，返回其父目录的路径。所以这里就是提取出第一个匹配目录的上级目录路径。

| tr -d '\n'

tr -d '\n'：tr 是用于字符转换和删除的命令，-d 选项表示删除指定的字符，这里删除的是换行符 \n，确保最终输出的路径不包含换行符。

OUTPUT_VARIABLE OUTPUT_PATH

将整个 Bash 命令的标准输出结果存储在 CMake 变量 OUTPUT_PATH 中，后续在 CMake 脚本里就可以使用这个变量了。

示例说明

假设项目源目录是 /home/user/project/src，那么查找起始目录就是 /home/user。如果在这个目录下找到了一个名为 /home/user/some_dir/output/include 的目录，经过上述命令处理后，OUTPUT_PATH 变量的值就会是 /home/user/some_dir。

综上所述，这段代码的核心功能是在指定目录下查找特定名称的目录，并获取其上级目录的路径，将结果存储在 OUTPUT_PATH 变量中，方便后续在 CMake 脚本中使用。

target_compile_options--为特定目标（可执行文件、库等）添加编译选项

target_compile_options(<target>
                       [BEFORE]
                       <INTERFACE|PUBLIC|PRIVATE> [items1...]
                       [<INTERFACE|PUBLIC|PRIVATE> [items2...] ...])

1. <target>

这是必选参数，用于指定要添加编译选项的目标名称。该目标必须是之前通过 add_executable 或 add_library 等命令创建的。例如，若有一个名为 my_app 的可执行文件目标，就可以使用 target_compile_options(my_app ...) 来为其添加编译选项。

2. [BEFORE]

可选参数。若指定了 BEFORE，新添加的编译选项会被插入到已有编译选项的前面；若不指定，新选项会被添加到已有选项的后面。

3. <INTERFACE|PUBLIC|PRIVATE>

这三个关键字用于指定编译选项的作用范围：

PRIVATE：编译选项仅应用于指定的目标本身。例如，若为一个库目标设置了 PRIVATE 编译选项，这些选项只会在编译该库时生效，不会影响链接该库的其他目标。

INTERFACE：编译选项仅应用于依赖该目标的其他目标。也就是说，当其他目标链接这个目标时，会继承这些 INTERFACE 编译选项，但该目标本身不会使用这些选项。

PUBLIC：编译选项既应用于指定的目标本身，也会传递给依赖该目标的其他目标。相当于同时具备 PRIVATE 和 INTERFACE 的特性。

4. [items1...]

这是要添加的编译选项列表，每个选项是一个字符串。例如，-Wall 用于开启所有常见的警告信息，-O2 用于设置优化级别为 2。

target_compile_definitions--为特定的目标（如可执行文件、库等）设置编译时的预处理器定义

target_compile_definitions(<target>
                           [BEFORE]
                           <INTERFACE|PUBLIC|PRIVATE> [items1...]
                           [<INTERFACE|PUBLIC|PRIVATE> [items2...] ...])

target_compile_definitions 是 CMake 中的一个命令，用于为特定的目标（如可执行文件、库等）设置编译时的预处理器定义。这些定义会在编译代码时被传递给编译器，类似于在命令行中使用 -D 选项。

1. <target>

这是必选参数，指定要设置编译定义的目标名称。该目标必须是之前通过 add_executable 或 add_library 等命令创建的。例如，若有一个名为 my_app 的可执行文件目标，就可以使用 target_compile_definitions(my_app ...) 来为其设置编译定义。

2. [BEFORE]

可选参数。若指定了 BEFORE，新添加的编译定义会被插入到已有编译定义的前面；若不指定，新定义会被添加到已有定义的后面。

3. <INTERFACE|PUBLIC|PRIVATE>

这三个关键字用于指定编译定义的作用范围：

PRIVATE：编译定义仅应用于指定的目标本身。例如，若为一个库目标设置了 PRIVATE 编译定义，这些定义只会在编译该库时生效，不会影响链接该库的其他目标。

INTERFACE：编译定义仅应用于依赖该目标的其他目标。也就是说，当其他目标链接这个目标时，会继承这些 INTERFACE 编译定义，但该目标本身不会使用这些定义。

PUBLIC：编译定义既应用于指定的目标本身，也会传递给依赖该目标的其他目标。相当于同时具备 PRIVATE 和 INTERFACE 的特性。

4. [items1...]

这是要添加的编译定义列表，每个定义是一个字符串。可以是简单的宏定义，如 DEBUG，也可以是带有值的定义，如 VERSION="1.0"。

target_include_directories--为特定的目标（像可执行文件、库等）指定包含目录

target_include_directories(<target> [SYSTEM] [AFTER|BEFORE]
  <INTERFACE|PUBLIC|PRIVATE> [items1...]
  [<INTERFACE|PUBLIC|PRIVATE> [items2...] ...])

target_include_directories 是 CMake 中的一个重要命令，主要用于为目标（如可执行文件、库等）指定包含目录。这些包含目录是编译器在查找头文件时会搜索的路径。

1. <target>

这是必选参数，指的是要指定包含目录的目标名称。这个目标得是之前通过 add_executable 或者 add_library 等命令创建的。例如，若有一个名为 my_app 的可执行文件目标，就可以用 target_include_directories(my_app ...) 来为它指定包含目录。

2. [SYSTEM]

这是一个可选参数。当指定 SYSTEM 时，CMake 会将这些包含目录视为系统包含目录。编译器在处理系统包含目录时，通常会采用不同的规则，比如忽略一些警告信息。

3. [AFTER|BEFORE]

也是可选参数，用于指定新添加的包含目录在搜索路径列表中的位置。

AFTER：表示新的包含目录会被添加到已有搜索路径的后面（默认行为）。

BEFORE：表示新的包含目录会被添加到已有搜索路径的前面。

4. <INTERFACE|PUBLIC|PRIVATE>

这三个关键字用于明确包含目录的作用范围：

PRIVATE：包含目录仅对指定的目标本身有效。例如，若为一个库目标设置了 PRIVATE 包含目录，这些目录仅在编译该库时被使用，不会影响链接该库的其他目标。

INTERFACE：包含目录仅对依赖该目标的其他目标有效。也就是说，当其他目标链接这个目标时，会继承这些 INTERFACE 包含目录，但该目标本身不会使用这些目录。

PUBLIC：包含目录既对指定的目标本身有效，也会传递给依赖该目标的其他目标。相当于同时具备 PRIVATE 和 INTERFACE 的特性。

5. [items1...]

这是要添加的包含目录列表，每个目录可以是绝对路径，也可以是相对路径。若为相对路径，通常是相对于当前 CMakeLists.txt 文件所在的目录。

set_target_properties--设置目标（如可执行文件、库等）属性

set_target_properties(<target1> <target2> ...
                      PROPERTIES <prop1> <value1>
                                 [<prop2> <value2> ...])

1. <target1> <target2> ...

指定要设置属性的目标名称，可以是一个或多个目标。这些目标必须是之前通过 add_executable 或 add_library 等命令创建的。

2. PROPERTIES

这是一个关键字，用于标识后面跟着的是要设置的属性和对应的值。

3. <prop1> <value1> [<prop2> <value2> ...]

这是一系列的属性 - 值对，用于指定要为目标设置的属性及其对应的值。常见的属性如下：

OUTPUT_NAME：设置目标的输出文件名。例如，将一个可执行文件的默认输出名修改为自定义名称。

VERSION：设置目标的版本号，通常用于库文件。

SOVERSION：设置共享库的 API 版本号，用于控制共享库的兼容性。

COMPILE_FLAGS：为目标添加额外的编译标志。

LINK_FLAGS：为目标添加额外的链接标志。

CXX_STANDARD：指定 C++ 标准版本，如 11、14、17 等。

RUNTIME_OUTPUT_DIRECTORY：设置目标的可执行文件输出目录。

LIBRARY_OUTPUT_DIRECTORY：设置目标的库文件输出目录。

ARCHIVE_OUTPUT_DIRECTORY：设置目标的静态库文件输出目录。

add_custom_target--创建自定义目标

自定义目标不对应具体的源文件编译，它可以执行任意的命令，比如运行脚本、生成文档等。

add_custom_target(<name>
                  [ALL]
                  [command1 [args1...]]
                  [COMMAND command2 [args2...] ...]
                  [DEPENDS depend1 depend2 ...]
                  [BYPRODUCTS [files...]]
                  [WORKING_DIRECTORY dir]
                  [COMMENT comment]
                  [VERBATIM]
                  [USES_TERMINAL]
                  [JOB_POOL job_pool])

1. <name>

必选参数，用于指定自定义目标的名称。这个名称在项目中必须是唯一的，后续可以通过该名称来引用这个自定义目标，例如在 add_dependencies 命令中。

2. [ALL]

可选参数。如果指定了 ALL，这个自定义目标会被添加到默认的构建目标中，意味着在执行 make（或其他构建工具）时，这个自定义目标会被自动执行。

3. [command1 [args1...]]

这是要执行的命令及其参数。可以指定一个或多个 COMMAND，它们会按顺序依次执行。例如，可以是 shell 命令、脚本文件等。

4. [DEPENDS depend1 depend2 ...]

可选参数，用于指定自定义目标的依赖项。这些依赖项可以是其他目标（如可执行文件、库等）或文件。只有当这些依赖项都满足（如文件存在、目标已构建）时，自定义目标才会执行。

5. [BYPRODUCTS [files...]]

可选参数，用于指定自定义目标执行过程中生成的副产品文件。CMake 会知道这些文件是由该自定义目标生成的，在清理构建目录时会进行相应处理。

6. [WORKING_DIRECTORY dir]

可选参数，用于指定命令执行时的工作目录。如果不指定，默认是当前的构建目录。

7. [COMMENT comment]

可选参数，用于为自定义目标添加注释信息。在执行构建过程中，这个注释会显示出来，帮助用户了解该自定义目标的作用。

8. [VERBATIM]

可选参数。如果指定了 VERBATIM，CMake 会确保命令参数被正确传递，避免在不同平台上出现参数解析问题。

9. [USES_TERMINAL]

可选参数。如果指定了 USES_TERMINAL，命令会在终端中执行，适合需要交互的命令。

10. [JOB_POOL job_pool]

可选参数，用于指定执行自定义目标的作业池，控制并行执行的规则。

add_custom_command--插入自定义的命令

add_custom_command 是 CMake 里的一个重要命令，它能让你在构建过程中插入自定义的命令。这些命令可以用于生成文件、预处理数据、运行脚本等。add_custom_command 有两种主要的使用形式：针对输出文件的和针对目标的，下面分别介绍。

针对输出文件

add_custom_command(OUTPUT output1 [output2 ...]
                   [COMMAND command1 [args1...]]
                   [COMMAND command2 [args2...] ...]
                   [DEPENDS [depends...]]
                   [IMPLICIT_DEPENDS <lang1> depend1 [lang2 depend2 ...]]
                   [WORKING_DIRECTORY dir]
                   [COMMENT comment]
                   [VERBATIM]
                   [APPEND])

OUTPUT output1 [output2 ...]：必选参数，指定自定义命令执行后生成的输出文件。当这些输出文件不存在或者依赖项有更新时，自定义命令会被执行。
COMMAND command1 [args1...]：要执行的命令及其参数。可以指定多个 COMMAND，它们会按顺序依次执行。
DEPENDS [depends...]：可选参数，指定自定义命令的依赖项，这些依赖项可以是文件或者其他目标。当依赖项有更新时，自定义命令会被重新执行。
IMPLICIT_DEPENDS <lang1> depend1 [lang2 depend2 ...]：可选参数，指定隐式依赖项，<lang1> 是编程语言，如 C、CXX 等。
WORKING_DIRECTORY dir：可选参数，指定命令执行时的工作目录。
COMMENT comment：可选参数，为自定义命令添加注释信息，在构建过程中会显示出来。
VERBATIM：可选参数，确保命令参数被正确传递，避免不同平台上的参数解析问题。
APPEND：可选参数，若指定，新的命令会追加到已有的针对相同输出文件的自定义命令之后。

针对目标

add_custom_command(TARGET <target>
                   PRE_BUILD | PRE_LINK | POST_BUILD
                   [COMMAND command1 [args1...]]
                   [COMMAND command2 [args2...] ...]
                   [WORKING_DIRECTORY dir]
                   [COMMENT comment]
                   [VERBATIM])

TARGET <target>：必选参数，指定要关联自定义命令的目标，该目标必须是之前通过 add_executable 或 add_library 等命令创建的。
PRE_BUILD | PRE_LINK | POST_BUILD：必选参数，指定自定义命令的执行时机：
PRE_BUILD：在目标构建之前执行。
PRE_LINK：在目标链接之前执行。
POST_BUILD：在目标构建完成之后执行。

COMMAND command1 [args1...]：要执行的命令及其参数，可指定多个，按顺序执行。
WORKING_DIRECTORY dir：可选参数，指定命令执行的工作目录。
COMMENT comment：可选参数，为自定义命令添加注释信息。
VERBATIM：可选参数，确保命令参数正确传递。

get_property--获取目标、目录、变量等对象的属性值

get_property(<variable>
             <GLOBAL |
              DIRECTORY [dir] |
              TARGET <target> |
              SOURCE <source> |
              TEST <test> |
              CACHE <entry> |
              INSTALL_COMPONENT <component>>
             PROPERTY <property>
             [SET | DEFINED | BRIEF_DOCS | FULL_DOCS])

1. <variable>

这是一个必选参数，用于存储获取到的属性值。在执行 get_property 命令后，指定属性的值会被存储到这个变量中。

2. <GLOBAL | DIRECTORY [dir] | TARGET <target> | SOURCE <source> | TEST <test> | CACHE <entry> | INSTALL_COMPONENT <component>>

这些关键字用于指定要获取属性的对象类型：

GLOBAL：获取全局属性的值。全局属性在整个 CMake 项目中是唯一的，可用于存储一些全局的配置信息。

DIRECTORY [dir]：获取指定目录的属性值。[dir] 是可选的，如果不指定，默认是当前目录。

TARGET <target>：获取指定目标（如可执行文件、库等）的属性值。<target> 必须是之前通过 add_executable 或 add_library 等命令创建的目标名称。

SOURCE <source>：获取指定源文件的属性值。<source> 是源文件的路径。

TEST <test>：获取指定测试用例的属性值。<test> 是通过 add_test 命令创建的测试用例名称。

CACHE <entry>：获取 CMake 缓存条目的属性值。<entry> 是缓存条目的名称。

INSTALL_COMPONENT <component>：获取指定安装组件的属性值。<component> 是安装组件的名称。

3. PROPERTY <property>

这是必选参数，用于指定要获取的属性名称。不同的对象类型有不同的属性，例如目标对象可能有 OUTPUT_NAME、VERSION 等属性。

4. [SET | DEFINED | BRIEF_DOCS | FULL_DOCS]

这些是可选参数，用于指定获取属性的不同方式：

SET：如果属性被设置了值，返回 TRUE；否则返回 FALSE。

DEFINED：如果属性被定义了（无论是否有值），返回 TRUE；否则返回 FALSE。

BRIEF_DOCS：获取属性的简要文档说明。

FULL_DOCS：获取属性的完整文档说明。

设定C++标准

DCMAKE_CXX_STANDARD

指定可执行程序输出的路径

EXECUTABLE_OUTPUT_PATH

当前访问的 CMakeLists.txt 文件所在的路径

CMAKE_CURRENT_SOURCE_DIR

PROJECT_SOURCE_DIR宏对应的值就是我们在使用cmake命令时，后面紧跟的目录，一般是工程的根目录。（build目录的上一级目录）（..表示上一级目录、.表示本级目录）

PROJECT_SOURCE_DIR

动态库路径

EXECUTABLE_OUTPUT_PATH

静态库路径

LIBRARY_OUTPUT_PATH

存储在使用 C++ 编译器编译代码时，启用 OpenMP（Open Multi-Processing，一种支持共享内存并行编程的 API）功能所需的编译选项

OpenMP_CXX_FLAGS

1. 用途

在使用 CMake 构建项目时，若要利用 OpenMP 实现并行计算，就需要在编译命令中添加特定的编译选项，而 OpenMP_CXX_FLAGS 变量就存储了这些必要的选项。通过将该变量的值添加到目标的编译选项中，能让编译器支持 OpenMP 并行编程。

2. 自动设置

通常，当你在 CMake 脚本里使用 find_package(OpenMP REQUIRED) 命令查找 OpenMP 时，CMake 会自动检测系统中是否存在 OpenMP 支持，并根据检测结果设置 OpenMP_CXX_FLAGS 变量。例如，在使用 GCC 或 Clang 编译器时，OpenMP_CXX_FLAGS 可能会被设置为 -fopenmp；在使用 Intel 编译器时，可能会被设置为 -qopenmp。

3. 代码示例

以下是一个完整的 CMake 示例，展示了如何使用 OpenMP_CXX_FLAGS：
cmake_minimum_required(VERSION 3.10)
project(OpenMPExample)

# 查找 OpenMP
find_package(OpenMP REQUIRED)

if(OpenMP_CXX_FOUND)
    # 创建可执行文件
    add_executable(openmp_app main.cpp)

    # 为目标添加 OpenMP 编译选项
    target_compile_options(openmp_app PUBLIC ${OpenMP_CXX_FLAGS})

    # 为目标添加 OpenMP 链接选项
    target_link_libraries(openmp_app PUBLIC OpenMP::OpenMP_CXX)
endif()
在这个示例中：

find_package(OpenMP REQUIRED) 用于查找系统中的 OpenMP 支持。
target_compile_options(openmp_app PUBLIC ${OpenMP_CXX_FLAGS}) 为 openmp_app 目标添加了 OpenMP_CXX_FLAGS 中的编译选项，从而让编译器在编译 main.cpp 时支持 OpenMP。
target_link_libraries(openmp_app PUBLIC OpenMP::OpenMP_CXX) 则为目标添加了 OpenMP 的链接选项，确保在链接阶段能够正确链接 OpenMP 库。

为 C++ 编译器设定编译选项

MAKE_CXX_FLAGS

优化级别设定：你可以借助这个变量来设置编译器的优化级别，例如-O0（无优化）、-O1（基本优化）、-O2（中等优化）、-O3（高级优化）等。
调试信息添加：使用-g选项，就能在编译时添加调试信息，这样在调试程序时就会方便很多。
警告选项设置：可以通过它设置警告选项，像-Wall（开启大部分常见警告）、-Werror（将所有警告当作错误处理）等。
特定编译器特性启用：启用特定编译器特性，例如-std=c++11、-std=c++14、-std=c++17、-std=c++20等，以此指定使用的 C++ 标准。

cmake_minimum_required(VERSION 3.10)

# 设置项目名称
project(MyProject)

# 设置C++编译器选项
set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -std=c++17 -Wall -O2 -g")

# 添加可执行文件
add_executable(MyExecutable main.cpp)

set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -std=c++17 -Wall -O2 -g")：这行代码把CMAKE_CXX_FLAGS变量的值更新为原来的值加上-std=c++17 -Wall -O2 -g这些选项。其中，-std=c++17指定使用 C++17 标准，-Wall开启大部分常见警告，-O2进行中等程度的优化，-g添加调试信息。
add_executable(MyExecutable main.cpp)：这行代码定义了一个名为MyExecutable的可执行文件，它由main.cpp源文件编译生成。

通过这种方式，在编译MyExecutable时，编译器就会使用CMAKE_CXX_FLAGS中设定的编译选项。

指定构建类型

CMAKE_BUILD_TYPE

构建类型能够影响编译选项、优化级别以及调试信息的生成。

# Debug用于调试程序
set(CMAKE_BUILD_TYPE Debug)
# Release用于发布程序
set(CMAKE_BUILD_TYPE Release)

调试程序会启用调试信息，并且不会进行代码优化，这样做便于调试器准确地定位问题。在这种构建类型下，编译器一般会添加 -g 选项以生成调试信息，例如在 GCC 中，可能会有类似 -g -O0 的编译选项，其中 -O0 表示不进行优化。

发布程序会开启较高的优化级别，同时不生成调试信息，这样能使生成的可执行文件运行速度更快，体积更小。在 GCC 里，通常会有 -O3 这样的优化选项，以此来提升程序的性能。

可以在 CMakeLists.txt 文件里直接设置 CMAKE_BUILD_TYPE 变量，也能在命令行中指定构建类型，示例如下：

cmake -DCMAKE_BUILD_TYPE=Release ..

这里 -D 选项用于定义 CMake 变量，Release 就是指定的构建类型。总之，CMAKE_BUILD_TYPE 变量让你可以依据不同的需求来灵活配置编译选项，进而生成合适的可执行文件。

CMake常见的命令

指定使用的 cmake 的最低版本-cmake_minimum_required

指定项目名称-project

生成可执行程序-add_executable

定义变量-SET

查找某个路径下的所有源文件-aux_source_directory

搜索文件-file

包含头文件-include_directories

制作静态库-add_library

制作动态库-add_library

链接静态库-link_libraries

指定库的路径-link_directories

链接动态库-target_link_libraries

显示信息-message

宏定义-add_definitions

添加子目录-add_subdirectory

find_package--查找并加载外部软件包

find_library--在指定的路径中查找特定名称的库文件

`find_path` --用于在指定的路径中查找包含特定文件的目录

configure_file--把一个输入文件复制到指定的输出文件，并且在复制过程中替换其中的 CMake 变量

option--定义可由用户控制的布尔型选项

set_source_files_properties--为指定的源文件设置特定的属性

set_source_files_properties--载入并执行指定的 CMake 脚本文件

INSTALL--用于指定项目在安装阶段的操作

execute_process--CMake 里用于在 CMake 配置过程中执行外部命令

`target_compile_options--`为特定目标（可执行文件、库等）添加编译选项

`target_compile_definitions--`为特定的目标（如可执行文件、库等）设置编译时的预处理器定义

`target_include_directories--`为特定的目标（像可执行文件、库等）指定包含目录

`set_target_properties--`设置目标（如可执行文件、库等）属性

`add_custom_target--`创建自定义目标

`add_custom_command--`插入自定义的命令

`get_property--`获取目标、目录、变量等对象的属性值

CMake常见的命令

指定使用的 cmake 的最低版本-cmake_minimum_required

指定项目名称-project

生成可执行程序-add_executable

定义变量-SET

查找某个路径下的所有源文件-aux_source_directory

搜索文件-file

包含头文件-include_directories

制作静态库-add_library

制作动态库-add_library

链接静态库-link_libraries

指定库的路径-link_directories

链接动态库-target_link_libraries

显示信息-message

宏定义-add_definitions

添加子目录-add_subdirectory

find_package--查找并加载外部软件包

find_library--在指定的路径中查找特定名称的库文件

find_path --用于在指定的路径中查找包含特定文件的目录

configure_file--把一个输入文件复制到指定的输出文件，并且在复制过程中替换其中的 CMake 变量

option--定义可由用户控制的布尔型选项

set_source_files_properties--为指定的源文件设置特定的属性

set_source_files_properties--载入并执行指定的 CMake 脚本文件

INSTALL--用于指定项目在安装阶段的操作

execute_process--CMake 里用于在 CMake 配置过程中执行外部命令

target_compile_options--为特定目标（可执行文件、库等）添加编译选项

target_compile_definitions--为特定的目标（如可执行文件、库等）设置编译时的预处理器定义

target_include_directories--为特定的目标（像可执行文件、库等）指定包含目录

set_target_properties--设置目标（如可执行文件、库等）属性

add_custom_target--创建自定义目标

add_custom_command--插入自定义的命令

get_property--获取目标、目录、变量等对象的属性值

`find_path` --用于在指定的路径中查找包含特定文件的目录

`target_compile_options--`为特定目标（可执行文件、库等）添加编译选项

`target_compile_definitions--`为特定的目标（如可执行文件、库等）设置编译时的预处理器定义

`target_include_directories--`为特定的目标（像可执行文件、库等）指定包含目录

`set_target_properties--`设置目标（如可执行文件、库等）属性

`add_custom_target--`创建自定义目标

`add_custom_command--`插入自定义的命令

`get_property--`获取目标、目录、变量等对象的属性值