modern cmake Doc文档
Modern CMake文档
- 安装
- Windows安装
- macOS安装
- 网址：https://cmake.org/download/，下载CMake，并正常安装
- 安装完成之后，使用以下指令创建/usr/local/bin下的CMake的软连接
- sudo "/Applications/CMake.app/Contents/bin/cmake-gui" --install
- 注意：执行此命令的时候确保CMake处于关闭状态
- 重新打开Terminal，即可正常使用 CMake 的各种指令了，也可以在应用程序列表中使用带 GUI 的 CMake 工具。
- Linux安装
- 网址：https://cmake.org/download/，下载对应版本的CMake（32位或者64位）
- 将下载的安装包上传到Linux服务器，比如:/root
- 输入以下命令进行解压
- tar -zxvf cmake-3.13.0-rc1-Linux-x86_64.tar.gz
- 注意：后面是官网下载的对应版本的名字
- 把解压后的目录改名为：cmake
- mv cmake-3.10.0-rc4-Linux-x86_64 cmake
- 设置环境变量
- 使用指令“vi .bash_profile”来设置环境变量，找到PATH=$PATH:$....这一行，后面添加CMake安装目录里面的bin目录的地址
- 如果是在/root目录安装的CMake，那添加的目录就是：/root/cmake/bin
- 安装完毕，环境变量设置成功之后，命令行输入：cmake --version检测是否安装成功
- 输出：cmake version 3.13，表示安装成功
- 使用CMake生成项目
- 使用Windows或者Linux生成项目
- 进入项目目录（CMakeLists.txt所在目录），新建一个build文件夹，因为CMake会产生很多自己的中间文件。
- 执行 ：cmake ../ 就会在build目录产生项目文件，windows下面默认产生vs的项目。
- 如果要产生其他编译器的makefile，就需要使用-G指定编译器
- cmake -G "MinGW Makefiles" ../
- 可以使用cmake --help 来查看使用的编译器的名字
- 生成项目工程文件或者makefile之后，就可以使用对应的编译器来编译项目
- 使用macOS生成项目
- mac下基本操作和windows、Linux相同，不过cmake命令使用的是：cmake .. （没有右斜杠）
- 注意：（默认已经配置好环境变量）
- 使用Windows或者Linux生成项目
- CMake命令行选项的设置
- 指定构建系统生成器：-G
- 使用：-G 命令可以指定编译器，当前平台支持的编译器名称可以通过帮助手册查看：cmake --help，
例如：cmake -G "Visual Studio 15 2017" ../ 使用vs2017构建工程
- 使用：-G 命令可以指定编译器，当前平台支持的编译器名称可以通过帮助手册查看：cmake --help，
- CMakeCache.txt文件
- 当cmake第一次运行一个空的构建的时候，他就会创建一个CMakeCache.txt文件，文件里面存放了一些可以用来制定工程的设置，比如：变量、选项等
- 对于同一个变量，如果Cache文件里面有设置，那么CMakeLists文件里就会优先使用Cache文件里面的同名变量。
- CMakeLists里面通过设置了一个Cache里面没有的变量，那就将这个变量的值写入到Cache里面
- 例子：
- SET（var 1024）
//变量var的值被设置成1024，如果变量var在Cache中已经存在，该命令不会覆盖cache里面的值 - SET（var 1024..CACHE..）
//如果var在Cache中存在，就优先使用Cache里面的值，如果不存在，就将该值写入Cache里面 - SET（var..CACHE..FORCE）
//无论Cache里面是否存在，都始终使用该值
- SET（var 1024）
- 添加变量到Cache文件中：-D
- 注意：-D后面不能有空格，例如：cmake -DCMAKE_BUILD_TYPE:STRING=Debug
- 从Cache文件中删除变量：-U
- 此选项和-D功能相反，从Cache文件中删除变量，支持使用*和？通配符
- CMake命令行模式：-E
- CMake提供了很多和平台无关的命令，在任何平台都可以使用：chdir, copy, copy_if_different等
- 可以使用：cmake -E help进行查询
- 打印运行的每一行CMake
- 命令行选项中：--trace，将打印运行的每一行CMake，例如windows下执行: cmake --trace ..
- 命令：--trace-source="filename"就会打印出有关filename的执行
- 设置编译参数
- add_definitions（-DENABLED），当在CMake里面添加该定义的时候，如果代码里面定义了#ifdef ENABLED #endif相关的片段，此时代码里面这一块代码就会生效
- //add_definitions( “-Wall -ansi –pedantic –g”)
- 该命令现已经被取代，使用： add_compile_definitions(WITH_OPENCV2)
- 设置默认值命令：option
- option命令可以帮助我们设置一个自定义的宏，如下：
- option(MY-MESSAGE "this is my message" ON)
- 第一个参数就是我们要设置的默认值的名字
- 第二个参数是对值的解释，类似于注释
- 第三个值是这个默认值的值，如果没有声明，CMake默认的是OFF
- 使用：设置好之后我们在命令行去使用的时候，也可以去给他设定值：cmake -DMY-MESSAGE=on ../
- 注意：使用的时候我们应该在值的前面加“D”
- 这条命令可将MY-MESSAGE的值设置为on，通过这个值我们可以去触发相关的判断
- 指定构建系统生成器：-G
- CMake基础知识简介
- 最低版本
- 每一个CMake.txt的第一行都会写：cmake_minimum_required(VERSION 3.1)，该命令指定了CMake的最低版本是3.1
- 命令名称cmake_minimum_required不区分大小写
- 设置版本范围：cmake_minimum_required(VERSION 3.1...3.12)
该命令表示支持3.1至3.12之间的版本 - 判断CMake版本：
- if(${CMAKE_VERSION} VERSION_LESS 3.12)
- cmake_policy(VERSION ${CMAKE_MAJOR_VERSION}.${CMAKE_MINOR_VERSION})
- endif()
- 该命令表示：如果CMake版本小于3.12，则if块将为true，然后将设置为当前CMake版本；如果CMake版本高于3.12，if块为假，cmake_minimum_required将被正确执行
- 注意：如果需要支持非命令行Windows版本则需在上面的if判断加上else分支，如下：
cmake_minimum_required(VERSION 3.1)
if(${CMAKE_VERSION} VERSION_LESS 3.12)
cmake_policy(VERSION ${CMAKE_MAJOR_VERSION}.${CMAKE_MINOR_VERSION})
else()
cmake_policy(VERSION 3.12)
endif()
- 设置生成项目名称
- 使用的命令：project（MyProject）
- 表示我们生成的工程名字叫做：MyProject
- 命令还可以标识项目支持的语言，写法：project（MyProject[C] [C++]）,不过通常将后面的参数省掉，因为默认支持所有语言
- 使用该指令之后系统会自动创建两个变量：<projectname>_BINARY_DIR:二进制文件保存路径、<projectname>_SOURCE_DIR：源代码路径
- 执行：project(MyProject)，就是定义了一个项目的名称为：MyProject，对应的就会生成两个变量：_BINARY_DIR和_SOURCE_DIR，但是cmake中其实已经有两个预定义的变量：PROJECT_BINARY_DIR和PROJECT_SOURCR_DIR
- 关于两个变量是否相同，涉及到是内部构建还是外部构建
- 内部构建
cmake ./
make - 外部构建
mkdir build
cd ./build
cmake ../
make - 内部构建和外部构建的不同在于：cmake 的工作目录不同。内部构建会将cmake生成的中间文件和可执行文件放在和项目同一目录；外部构建的话，中间文件和可执行文件会放在build目录。
- PROJECT_SOURCE_DIR和_SOURCE_DIR无论内部构建还是外部构建，指向的内容都是一样的，都指向工程的根目录
- PROJECT_BINARY_DIR和_BINARY_DIR指向的相同内容，内部构建的时候指向CMakeLists.txt文件的目录，外部构建的，指向target编译的目录
- 内部构建
- 生成可执行文件
- 语法：add_executable(exename srcname)
exename:生成的可执行文件的名字
srcname:以来的源文件 - 该命令指定生成exe的名字以及指出需要依赖的源文件的文件名
- 获取文件路径中的所有源文件
- 命令：aux_sourcr_directory(<dir> <variable>)
- 例子：aux_sourcr_directory(. DIR_SRCS)，将当前目录下的源文件名字存放到变量DIR_SRCS里面 ，如果源文件比较多，直接用DIR_SRCS变量即可
- 生成可执行文件：add_executable(Demo ${DIR_SRCS})，将生成的可执行文件命名为：Demo.exe
- 语法：add_executable(exename srcname)
- 生成lib库
- 命令：add_library(libname [SHARED|STATIC|MODULE] [EXCLUDE_FROM_ALL] source1 source2 ... sourceN)
libname:生成的库文件的名字
[SHARED|STATIC|MODULE]：生成库文件的类型（动态库|静态库|模块）
[EXCLUDE_FROM_ALL]：有这个参数表示该库不会被默认构建
source2 ... sourceN：生成库依赖的源文件，如果源文件比较多，可以使用aux_sourcr_directory命令获取路径下所有源文件，具体章节参见：CMake基础知识简介->生成可执行文件->获取路径中所有源文件 - 例子：add_library(ALib SHARE alib.cpp)
- 命令：add_library(libname [SHARED|STATIC|MODULE] [EXCLUDE_FROM_ALL] source1 source2 ... sourceN)
- 添加头文件目录
- 命令1：target_include_directories(<target> [SYSTEM] [BEFORE] <INTERFACE|PUBLIC|PRIVATE> [items1...] [<INTERFACE|PUBLIC|PRIVATE> [items2...] ...])
当我们添加子项目之后还需要设置一个include路径，例子：
eg:target_include_directories(RigelEditor PUBLIC ./include/rgeditor)，表示给RigelEditor 这个子项目添加一个库文件的路径 - 命令2：include_directories([AFTER|BEFORE] [SYSTEM] dir1 [dir2 …])
参数解析：
[AFTER|BEFORE]：指定了要添加路径是添加到原有列表之前还是之后
[SYSTEM]：若指定了system参数，则把被包含的路径当做系统包含路径来处理
dir1 [dir2 …]把这些路径添加到CMakeLists及其子目录的CMakeLists的头文件包含项目中
相当于g++选项中的-l的参数的作用
举例：
include_directories("/opt/MATLAB/R2012a/extern/include") - 两条指令的作用都是讲将include的目录添加到目标区别在于include_directories是CMake编译所有目标的目录进行添加，target_include_directories是将CMake编译的指定的特定目标的包含目录进行添加
- 命令1：target_include_directories(<target> [SYSTEM] [BEFORE] <INTERFACE|PUBLIC|PRIVATE> [items1...] [<INTERFACE|PUBLIC|PRIVATE> [items2...] ...])
- 添加需要链接的库文件路径
- 命令1:target_link_libraries(<target> [item1 [item2 [...]]] [[debug|optimized|general] <item>] ...)
- 作用：为给定的目标设置链接时使用的库（设置要链接的库文件的名称）
- eg:target_link_libraries(MyProject a b.a c.so) //将若干库文件链接到hello中，target_link_libraries里的库文件的顺序符合gcc/g++链接顺序规则，即：被依赖的库放在依赖他的库的后面，如果顺序有错，链接将会报错
- 关键字：debug对应于调试配置
- 关键字：optimized对应于所有其他的配置类型
- 关键字：general对应于所有的配置（该属性是默认值）
- 命令2：link_libraries
- 作用：给当前工程链接需要的库文件（全路径）
- eg:link_libraries(("/opt/MATLAB/R2012a/bin/glnxa64/libeng.so")//必须添加带名字的全路径
- 区别：link_libraries和target_link_libraries命令的区别：target_link_libraries可以给工程或者库文件设置其需要链接的库文件，而且不需要填写全路径，但是link_libraries只能给工程添加依赖的库，而且必须添加全路径
- 添加需要链接的库文件目录
- 命令：link_directories（添加需要链接的库文件目录）
- 语法：link_directories(directory1 directory2 ...)
- 例子：link_directories("/opt/MATLAB/R2012a/bin/glnxa64")
- 指令的区别：指令的前缀带target，表示针对某一个目标进行设置，必须指明设置的目标；include_directories是在编译时用，指明.h文件的路径；link_directoeies是在链接时用的，指明链接库的路径；target_link_libraries是指明链接库的名字，也就是具体谁链接到哪个库。link_libraries不常用，因为必须指明带文件名全路径
- 命令1:target_link_libraries(<target> [item1 [item2 [...]]] [[debug|optimized|general] <item>] ...)
- 控制目标属性
- 以上的几条命令的区分都是：是否带target前缀，在CMake里面，一个target有自己的属性集，如果我们没有显示的设置这些target的属性的话，CMake默认是由相关的全局属性来填充target的属性，我们如果需要单独的设置target的属性，需要使用命令：set_target_properties()
- 命令格式
格式：
set_target_properties(target1 target2 ...
PROPERTIES
属性名称1 值
属性名称2 值
...
) - 控制编译选项的属性是：COMPILE_FLAGS
- 控制链接选项的属性是：LINK_FLAGS
- 控制输出路径的属性：EXECUTABLE_OUTPUT_PATH（exe的输出路径）、LIBRARY_OUTPUT_PATH（库文件的输出路径）
- 举例：
命令：
set_target_properties(exe
PROPERTIES
LINK_FLAGS -static
LINK_FLAGS_RELEASE -s
) - 这条指令会使得exe这个目标在所有的情况下都采用-static选项，而且在release build的时候 -static -s 选项。但是这个属性仅仅在exe这个target上面有效
- 最低版本
- 变量和缓存
- 局部变量
- CMakeLists.txt相当于一个函数，第一个执行的CMakeLists.txt相当于主函数，正常设置的变量不能跨越CMakeLists.txt文件，相当于局部变量只在当前函数域里面作用一样，
- 设置变量：set(MY_VARIABLE "value")
- 变量的名称通常大写
- 访问变量：${MY_VARIABLE}
- 缓存变量
- 缓存变量就是cache变量，相当于全局变量，都是在第一个执行的CMakeLists.txt里面被设置的，不过在子项目的CMakeLists.txt文件里面也是可以修改这个变量的，此时会影响父目录的CMakeLists.txt，这些变量用来配置整个工程，配置好之后对整个工程使用。
- 设置缓存变量：set(MY_CACHE_VALUE "cache_value" CACHE INTERNAL "THIS IS MY CACHE VALUE")
//THIS IS MY CACHE VALUE，这个字符串相当于对变量的描述说明，不能省略，但可以自己随便定义
- 环境变量
- 设置环境变量：set(ENV{variable_name} value)
- 获取环境变量：$ENV{variable_name}
- 内置变量
- CMake里面包含大量的内置变量，和自定义的变量相同，常用的有以下：
- CMAKE_C_COMPILER：指定C编译器
- CMAKE_CXX_COMPILER：指定C++编译器
- EXECUTABLE_OUTPUT_PATH：指定可执行文件的存放路径
- LIBRARY_OUTPUT_PATH：指定库文件的放置路径
- CMAKE_CURRENT_SOURCE_DIR：当前处理的CMakeLists.txt所在的路径
- CMAKE_BUILD_TYPE：控制构建的时候是Debug还是Release
命令：set(CMAKE_BUILD_TYPE Debug) - CMAKE_SOURCR_DIR：无论外部构建还是内部构建，都指的是工程的顶层目录（参考project命令执行之后，生成的_SOURCR_DIR以及CMake预定义的变量PROJECT_SOURCE_DIR）
- CMAKE_BINARY_DIR：内部构建指的是工程顶层目录，外部构建指的是工程发生编译的目录（参考project命令执行之后，生成的_BINARY_DIR以及CMake预定义的变量PROJECT_BINARY_DIR）
- CMAKE_CURRENT_LIST_LINE：输出这个内置变量所在的行
- 缓存
- 缓存就是之前提到的CMakeCache文件，参见：CMake命令行选项的设置->CMakeCache.txt文件
- 局部变量
- CMake基本控制语法
- If
- 基本语法
if (expression)
COMMAND1(ARGS ...)
COMMAND2(ARGS ...)
...
else (expression)
COMMAND1(ARGS ...)
COMMAND2(ARGS ...)
...
endif (expression)
注意：ENDIF要和IF对应- if (expression)，expression不为：空,0,N,NO,OFF,FALSE,NOTFOUND或< var >_NOTFOUND,为真
- IF (not exp)，与上面相反
- if (var1 AND var2)，var1且var2都为真，条件成立
- if (var1 OR var2)，var1或var2其中某一个为真，条件成立
- if (COMMAND cmd)， 如果cmd确实是命令并可调用，为真；
- if (EXISTS dir) 如果目录存在，为真
- if (EXISTS file) 如果文件存在，为真
- if (file1 IS_NEWER_THAN file2)，当file1比file2新，或file1/file2中有一个不存在时为真，文件名需使用全路径
- if (IS_DIRECTORY dir) 当dir是目录时，为真
- if (DEFINED var) 如果变量被定义，为真
- if (string MATCHES regex) 当给定变量或字符串能匹配正则表达式regex时，为真
例：
IF ("hello" MATCHES "ell")
MESSAGE("true")
ENDIF ("hello" MATCHES "ell")
- 数字表达式
- if (var LESS number)，var小于number为真
- if (var GREATER number)，var大于number为真
- if (var EQUAL number)，var等于number为真
- 字母表顺序比较
- IF (var1 STRLESS var2)，var1字母顺序小于var2为真
- IF (var1 STRGREATER var2)，var1字母顺序大于var2为真
- IF (var1 STREQUAL var2)，var1和var2字母顺序相等为真
- 基本语法
- While
- 语法结构
WHILE(condition)
COMMAND1(ARGS ...)
COMMAND2(ARGS ...)
...
ENDWHILE(condition) - 真假条件的判断参考if
- 语法结构
- Foreach
- FOREACH有三种使用形式的语法，且每个FOREACH都需要一个ENDFOREACH()与之匹配。
- 列表循环
- 语法
FOREACH(loop_var arg1 arg2 ...)
COMMAND1(ARGS ...)
COMMAND2(ARGS ...)
...
ENDFOREACH(loop_var) - 例子
eg:
AUX_SOURCE_DIRECTORY(. SRC_LIST)
FOREACH(F ${SRC_LIST})
MESSAGE(${F})
ENDFOREACH(F) - 例子中，先将当前路径的源文件名放到变量SRC_LIST里面，然后遍历输出文件名
- 语法
- 范围循环
- 语法
FOREACH(loop_var RANGE total)
COMMAND1(ARGS ...)
COMMAND2(ARGS ...)
...
ENDFOREACH(loop_var) - 例子
eg:
FOREACH(VAR RANGE 100)
MESSAGE(${VAR})
ENDFOREACH(VAR)
- 例子中默认起点为0，步进为1，作用就是输出：0~100
- 语法
- 范围步进循环
- 语法
FOREACH(loop_var RANGE start stop [step])
COMMAND1(ARGS ...)
COMMAND2(ARGS ...)
...
ENDFOREACH(loop_var) - 例子
eg:
FOREACH(A RANGE 0 100 10)
MESSAGE(${A})
ENDFOREACH(A) - 例子中，起点是0，终点是100，步进是10，输出：0,10,20,30,40,50,60,70,80,90,100
- 语法
- If
- 构建规范以及构建属性//
- 用于指定构建规则以及程序使用要求的指令：target_include_directories(), target_compile_definitions(), target_compile_options()
- 指令格式
- target_include_directories(<target> [SYSTEM] [BEFORE]<INTERFACE|PUBLIC|PRIVATE> [items1...] [<INTERFACE|PUBLIC|PRIVATE> [items2...] ...])
Include的头文件的查找目录，也就是Gcc的[-Idir...]选项 - target_compile_definitions(<target> <INTERFACE|PUBLIC|PRIVATE> [items1...][<INTERFACE|PUBLIC|PRIVATE> [items2...] ...])
通过命令行定义的宏变量 - target_compile_options(<target> [BEFORE] <INTERFACE|PUBLIC|PRIVATE> [items1...] [<INTERFACE|PUBLIC|PRIVATE> [items2...] ...]
gcc其他的一些编译选项指定，比如-fPIC
- -fPIC选项说明
说明：-fPIC 作用于编译阶段，告诉编译器产生与位置无关代码(Position-Independent Code)，
则产生的代码中，没有绝对地址，全部使用相对地址，故而代码可以被加载器加载到内存的任意
位置，都可以正确的执行。这正是共享库所要求的，共享库被加载时，在内存的位置不是固定的。 - -ldir选项说明
说明：在你是用 #include "file" 的时候, gcc/g++ 会先在当前目录查找你所制定的头文件, 如果没有找到, 他会到缺省的头文件目录找, 如果使用 -I 制定了目录,他会先在你所制定的目录查找, 然后再按常规的顺序去找。
- target_include_directories(<target> [SYSTEM] [BEFORE]<INTERFACE|PUBLIC|PRIVATE> [items1...] [<INTERFACE|PUBLIC|PRIVATE> [items2...] ...])
- 以上的额三个命令会生成INCLUDE_DIRECTORIES, COMPILE_DEFINITIONS, COMPILE_OPTIONS变量的值,。或者 INTERFACE_INCLUDE_DIRECTORIES,INTERFACE_COMPILE_DEFINITIONS, INTERFACE_COMPILE_OPTIONS的值.
- 这三个命令都有三种可选模式: PRIVATE, PUBLIC。 INTERFACE. PRIVATE模式仅填充不是接口的目标属性; INTERFACE模式仅填充接口目标的属性.PUBLIC模式填充这两种的目标属性。
- 宏和函数
- CMake里面可以定义自己的函数（function）和宏（macro）
- 区别1：范围。函数是有范围的，而宏没有。如果希望函数设置的变量在函数的外部也可以看见，就需要使用PARENT_SCOPE来修饰，但是函数对于变量的控制会比较好，不会有变量泄露
- 例子
- 宏（macro）
eg:
macro( [arg1 [arg2 [arg3 ...]]])
COMMAND1(ARGS ...)
COMMAND2(ARGS ...)
...
endmacro() - 函数（function）
eg:
function( [arg1 [arg2 [arg3 ...]]])
COMMAND1(ARGS ...)
COMMAND2(ARGS ...)
...
endfunction()
- 宏（macro）
- 函数和宏的区别还在于，函数很难将计算结果传出来，使用宏就可以将一些值简单的传出来
- 例子
eg:
macro(macroTest)
set(test1 "aaa")
endmacro()
function(funTest)
set(test2 "bbb")
endfunction()
macroTest()
message("${test1}")
funTest()
message("${test2}")
- 运行上面这个代码，就会显示“aaa”，因为函数里面的test1是局部的，出了这个函数就出了他的作用域
- 和其他文件的交互
- 在代码中使用CMake中定义的变量
- 命令：configure_file
- 作用：让普通文件也能使用CMake中的变量。
- 语法
configure_file(<input> <output>
[COPYONLY] [ESCAPE_QUOTES] [@ONLY]
[NEWLINE_STYLE [UNIX|DOS|WIN32|LF|CRLF] ])
解释：拷贝一个 <input>（输入文件） 文件到 <output> （输出文件），并且替换输入文件中被 @VAR@ 或者 ${VAR} 引用的变量值。每一个变量将被替换成当前的变量值 - 参数解析
- COPYONLY：只拷贝文件，不进行任何的变量替换。这个选项在指定了 NEWLINE_STYLE 选项时不能使用（无效）。
- ESCAPE_QUOTES：躲过任何的反斜杠(C风格)转义。
注：躲避转义，比如你有个变量在CMake中是这样的 set(FOO_STRING "\"foo\"") 那么在没有 ESCAPE_QUOTES 选项的状态下，通过变量替换将变为 ""foo""，如果指定了 ESCAPE_QUOTES 选项，变量将不变。 - @ONLY：限制变量替换，让其只替换被 @VAR@ 引用的变量（那么 ${VAR} 格式的变量将不会被替换）。这在配置 ${VAR} 语法的脚本时是非常有用的。
- NEWLINE_STYLE <style>：指定输出文件中的新行格式。UNIX 和 LF 的新行是 \n ，DOS 和 WIN32 和 CRLF 的新行格式是 \r\n 。 这个选项在指定了 COPYONLY 选项时不能使用（无效）。
- 在CMake对文件的操作
- file命令
- file(WRITE filename "message to write"... )
- 解释：WRITE选项会写一条消息到名为filename中，如果文件存在，则会覆盖原文件，如果文件不存在，他将创建该文件
- file(APPEND filename "message to write"... )
- 解释：APPEND选项和WRITE选项一样，只是APPEND会写到文件的末尾
- file(READ filename variable [LIMIT numBytes] [OFFSET offset] [HEX])
- 解释：READ选项会将读取的文件内容存放到变量variable ，读取numBytes个字节，从offset位置开始，如果指定了[HEX]参数，二进制代码就会转换为十六进制的转换方式
- file(STRINGS filename variable [LIMIT_COUNT num] [LIMIT_INPUT numBytes] [LIMIT_OUTPUT numBytes] [LENGTH_MINIMUM numBytes] [LENGTH_MAXIMUM numBytes] [NEWLINE_CONSUME] [REGEX regex] [NO_HEX_CONVERSION])
- 解释：STRINGS标志，将会从一个文件中将ASCII字符串的list解析出来，然后储存在variable 变量中，文件中的二进制数据将会被忽略，回车换行符会被忽略（可以设置NO_HEX_CONVERSION选项来禁止这个功能）。LIMIT_COUNT：设定了返回字符串的最大数量；LIMIT_INPUT：设置了从输入文件中读取的最大字节数；LIMIT_OUTPUT：设置了在输出变量中允许存储的最大字节数；LENGTH_MINIMUM：设置了返回字符串的最小长度，小于该长度的字符串将会被忽略；LENGTH_MAXIMUM设置了返回字符串的最大长度，大于该长度的字符串将会被忽略；NEWLINE_CONSUME：该标志允许新行被包含到字符串中，而不是终止他们；REGEX：指定了返回的字符串必须满足的正则表达式
- 典型的使用方式：file(STRINGS myfile.txt myfile)
- 该命令在变量myfile中储存了一个list,该list每一项是myfile.txt中的一行文本
- file(GLOB variable [RELATIVE path] [globbing expressions]...)
- 解释：GLOB：该选项将会为所有匹配表达式的文件生成一个文件list，并将该list存放在variable 里面，文件名的查询表达式和正则表达式类似，
- 查询表达式的例子：①*.cpp -匹配所有后缀是.cpp的文件②*.vb? -匹配文件后缀是.vba——.vbz的文件③f[3-5].txt ：匹配f3.txt,f4.txt,f5.txt文件
- file(GLOB_RECURSE variable [RELATIVE path] [FOLLOW_SYMLINKS] [globbing expressions]...)
- 解释：GLOB_RECURSE会生成一个类似于通常GLOB选项的list，不过该选项可以递归查找文件中的匹配项
- 比如：/dir/*.py -就会匹配所有在/dir文件下面的python文件，
- file(RENAME <oldname> <newname>)
- 解释：RENAME选项对同一个文件系统下的一个文件或目录重命名
- file(REMOVE [file1 ...])
- 解释：REMOVE选项将会删除指定的文件，包括在子路径下的文件
- file(REMOVE_RECURSE [file1 ...])
- 解释：REMOVE_RECURSE选项会删除给定的文件以及目录，包括非空目录
- file(MAKE_DIRECTORY [directory1 directory2 ...])
- 解释：MAKE_DIRECTORY选项将会创建指定的目录，如果它们的父目录不存在时，同样也会创建
- file(RELATIVE_PATH variable directory file)
- 解释：RELATIVE_PATH选项会确定从direcroty参数到指定文件的相对路径，然后存到变量variable中
- file(TO_CMAKE_PATH path result)
- 解释：TO_CMAKE_PATH选项会把path转换为一个以unix的 / 开头的cmake风格的路径
- file(TO_NATIVE_PATH path result)
- 解释：TO_NATIVE_PATH选项与TO_CMAKE_PATH选项很相似，但是它会把cmake风格的路径转换为本地路径风格
- file(DOWNLOAD url file [TIMEOUT timeout] [STATUS status] [LOG log] [EXPECTED_MD5 sum] [SHOW_PROGRESS])
- 解释：DOWNLOAD将给定的url下载到指定的文件中，如果指定了LOG log，下载的日志将会被输出到log中，如果指定了STATUS status选项下载操作的状态就会被输出到status里面，该状态的返回值是一个长度为2的list，list第一个元素是操作的返回值，是一个数字 ，第二个返回值是错误的字符串，错误信息如果是0，就表示没有错误；如果指定了TIMEOUT time选项，time秒之后，操作就会推出。如果指定了EXPECTED_MD5 sum选项，下载操作会认证下载的文件的实际MD5和是否与期望值相匹配，如果不匹配，操作将返回一个错误；如果指定了SHOW_PROGRESS，进度信息会被打印出来，直到操作完成
- source_group命令
- 使用该命令可以将文件在VS中进行分组显示
- source_group("Header Files" FILES ${HEADER_FILES})
- 以上命令是将变量HEADER_FILES里面的文件，在VS显示的时候都显示在“Header Files”选项下面
- file命令
- 在代码中使用CMake中定义的变量
- 如何构建项目
- 工程文件结构
- lib文件夹
- libA.c
- libB.c
- CMakeLists.txt
- include文件夹
- includeA.h
- inclueeB.h
- CMakeLists.txt
- main.c
- CMakeLists.txt
- lib文件夹
- 第一层CMakeLists
内容如下：
#项目名称
project(main)
#需要的cmake最低版本
cmake_minium_required(VERSION 2.8)
#将当前目录下的源文件名都赋给DIR_SRC目录
aux_source_directories(. DIR_SRC)
#添加include目录
include_directories(include)
#生成可执行文件
add_executable(main ${DIR_SRC})
#添加子目录
add_subdirectories(lib)
#将生成的文件与动态库相连
target_link_libraries(main test)
#test是lib目录里面生成的 - lib目录下的CMakeLists
内容如下：
#将当前的源文件名字都添加到DIR_LIB变量下
aux_source_director(. DIR_LIB)
#生成库文件命名为test
add_libraries(test ${DIR_LIB}) - include目录的CMakeLists可以为空，因为我们已经将include目录包含在第一层的文件里面
- 工程文件结构
- 运行其他程序
- 在配置时运行命令
- 指令：execute_process
参数：
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]) - 作用：这条指令可以执行系统命令，将输出保存到cmake变量或文件中去，运行一个或多个给定的命令序列，每一个进程的标准输出通过管道流向下一个进程的标准输入。
- 参数解析
- COMMAND：子进程的命令行，CMake使用操作系统的API直接执行子进程，所有的参数逐字传输，没有中间脚本参与，像“>”的输出重定向也会被直接的传输到子进程里面，当做普通的参数进行处理。
- WORKING_DIRECTORY：指定的工作目录将会设置为子进程的工作目录
- TIMEOUT：子进程如果在指定的秒数之内没有结束就会被中断
- RESULT_VARIABLE：变量被设置为包含子进程的运算结果，也就是命令执行的最后结果将会保存在这个变量之中，返回码将是来自最后一个子进程的整数或者一个错误描述字符串
- OUTPUT_VARIABLE、ERROR_VARIABLE：输出变量和错误变量//
- INPUT_FILE、OUTPUT_FILE、ERROR_FILE：输入文件、输出文件、错误文件//
- OUTPUT_QUIET、ERROR_QUIET:输出忽略、错误忽略，标准输出和标准错误的结果将被默认忽略
- 例子
eg:
set(MAKE_CMD "/src/bin/make.bat")
MESSAGE("COMMAND: ${MAKE_CMD}")
execute_process(COMMAND "${MAKE_CMD}"
RESULT_VARIABLE CMD_ERROR
OUTPUT_FILE CMD_OUTPUT)
MESSAGE( STATUS "CMD_ERROR:" ${CMD_ERROR})
MESSAGE( STATUS "CMD_OUTPUT:" ${CMD_OUTPUT})
输出：
COMMAND:/src/bin/make.bat
CMD_ERROR:No such file or directory
CMD_OUTPUT:
（因为这个路径下面没有这个文件）
- 指令：execute_process
- 在构建的时运行命令
https://www.jianshu.com/p/0fc0e1613587- 例子（调用python脚本生成头文件）：
find_package(PythonInterp REQUIRED)
add_custom_command(OUTPUT "${CMAKE_CURRENT_BINARY_DIR}/include/Generated.hpp"
COMMAND "${PYTHON_EXECUTABLE}" "${CMAKE_CURRENT_SOURCE_DIR}/scripts/GenerateHeader.py" --argument
DEPENDS some_target)
add_custom_target(generate_header ALL
DEPENDS "${CMAKE_CURRENT_BINARY_DIR}/include/Generated.hpp")
install(FILES ${CMAKE_CURRENT_BINARY_DIR}/include/Generated.hpp DESTINATION include) - find_package：查找链接库
如果编译的过程使用了外部的库，事先并不知道其头文件和链接库的位置，得在编译命令中加上包含外部库的查找路径，CMake中使用find_package方法- find_package（）命令查找***.cmake的顺序
- 介绍这个命令之前，首先得介绍一个变量：CMAKE_MODULE_PATH
- 工程比较大的时候，我们会创建自己的cmake模块，我们需要告诉cmake这个模块在哪里，CMake就是通过CMAKE_MODULE_PATH这个变量来获取模块路径的
- 我们使用set来设置模块的路径：set(CMAKE_MODULE_PATH ${PROJECT_SOURCE_DIR}/cmake)
- 如果上面的没有找到，就会在../.cmake/packages或者../uesr/local/share/中的包目录中查找：<库名字大写>Config.cmake或者<库名字小写>-config.cmake。这种查找模式称作Config模式。
- 如果找到这个包，则可以通过在工程的顶层目录中的CMakeLists.txt中添加：include_directories(<Name>_INCLUDE_DIRS)来包含库的头文件，使用命令：target_link_libraries(源文件 <NAME>_LIBRARIES)将源文件以及库文件链接起来
- 无论哪一种方式，只要找到***.cmake文件，***.cmake里面都会定义下面这些变量
<NAME>_FOUND
<NAME>_INCLUDE_DIRS or <NAME>_INCLUDES
<NAME>_LIBRARIES or <NAME>_LIBRARIES or <NAME>_LIBS
<NAME>_DEFINITIONS
注：<NAME>就是库名 - CMake中使用：cmake --help-module-list命令来查看当前CMake中有哪些支持的模块
- find_package（<Name>）命令首先会在模块路径,也就是刚才我们介绍的CMAKE_MODULE_PATH变量里面存放的路径中查找Find<Name>.cmake。查找路径依次为：变量${CMAKE_MODULE_PATH}中的所有目录，这种查找模式被称为Module模式。
- find_package
- 命令参数
- FIND_PACKAGE( <name> [version] [EXACT] [QUIET] [NO_MODULE] [ [ REQUIRED | COMPONENTS ] [ componets... ] ] )
- version：需要一个版本号，给出这个参数而没有给出EXACT，那个就是找到和给出的这个版本号相互兼容就符合条件
- EXACT：要求版本号必须和version给出的精确匹配。
- QUIET：会禁掉查找的包没有被发现的警告信息。对应于Find<Name>.cmake模块里面的的NAME_FIND_QUIETLY变量。
- NO_MODULE：给出该指令之后，cmake将直接跳过Module模式的查找，直接使用Config模式查找。查找模式详见下方
- REQUIRED：该选项表示如果没有找到需要的包就会停止并且报错
- COMPONENTS：在REQUIRED选项之后，或者如果没有指定REQUIRED选项但是指定了COMPONENTS选项，在COMPONENTS后面就可以列出一些与包相关部分组件的清单
- 搜索原理
- Cmake可以支持很多外部内部的库，通过命令可以查看当前cmake支持的模块有哪些： cmake --help-module-list 。或者直接查看模块路径。Windosw的路径在cmak的安装目录：..\share\cmake-3.13\Modules
- cmake本身是不提供任何搜索库的便捷方法，所有搜索库并给变量赋值的操作必须由cmake代码完成
- find_psckage的搜索模式：
- Module模式：搜索CMAKE_MODULE_PATH指定路径下的FindXXX.cmake文件（XXX就是我们要搜索的库的名字），这个CMAKE_MODULE_PATH变量是cmake预先定义，但是没有值，我们一旦给这个变量赋值之后，cmake就会最高优先级的在这个变量里面去查找，没有找到就在自己的安装库里面去找有没有FindXXX.cmake模块，找到之后，执行该文件从而找到XXX库，其中具体查找库并给XXX_INCLUDE_DIR和XXX_LIBRARIES这两个变量赋值的操作有FindXXX.cmake模块完成
- Config模式：如果Module模式没有找到，则启用Config模式查找，搜索XXX_DIR路径下的XXXConfig.cmake文件，执行该文件从而找到XXX库，其中查找库以及给XXX_INCLUDE_DIR和XXX_LIBRARY赋值的操作都是由XXXConfig.cmake模块完成
- cmake默认采取的时Module模式，如果Module模式没有找到，才会使用Config模式查找，
- ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------
- version选项和EXACT
- 介绍这个命令之前，首先得介绍一个变量：CMAKE_MODULE_PATH
- find_package（）命令查找***.cmake的顺序
- 例子（调用python脚本生成头文件）：
- 在配置时运行命令
- -----------------------------------------------------------------------------------------------------------------------------------------------------------------------------
- COMPONENTS选项，有些库不是一个整体比如Qt，其中还包含QtOpenGL和QtXml组件，当我们需要使用库的组件的时候，就使用COMPONENTS这个选项
- find_package(Qt COMPONENTS QtOpenGL QtXml REQUIRED)
- -----------------------------------------------------------------------------------------------------------------------------------------------------------------------------
- 找到之后给一些预定义的变量赋值
- 无论哪一种查找模式，只要找到包之后，就会给以下变量赋值：<NAME>_FOUND,<NAME>_INCLUDE_DIRS或者<NAME>_INCLUDES,<NAME>_LIBRARIES,<NAME>_DEFINITIONS。这些变量都在Find<NAME>.cmake文件中。
- 我们可以在CMakeLists.txt中使用<NAME>_FOUND变量来检测摆包是否被找到，
- -----------------------------------------------------------------------------------------------------------------------------------------------------------------------------
- find_package的本质是执行一个.cmake文件，相当于cmake的内置的脚本，这个脚本将设置我们之前提到的相关的变量，相当于根据传进来的参数来使用一个查找模块，每一个常用的库在cmake里面就有一个对应的查找模块。
- ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
- find模块的编写流程：
- 首先使用：find_path和find_library查找模块的头文件以及库文件，然后将结果放到<NAME>_INCLUDE_DIR和<NAME>_LIBRARY里面
- find_path()：
- find_path(<VAR> name1 [path1 path2 ...])
- 该命令搜索包含某个文件的路径，用于给定名字的文件所在路径，
- 一条名为：<VAR>的变量的Cache将会被创建。
- 如果在某个文件下面发现了该文件，路径就会被储存到变量里面，除非变量被清除，否则搜搜将不会进行。
- 如果没有发现该文件，<VAR>里面储存的就是<VAR>-NOTFOUND
- find_library():
- find_library(<VAR> name1 [path1 path2 ...])
- 查找一个库文件
- 设置：<NAME>_INCLUDE_DIRS为<NAME>_INCLUDE_DIR<dependency1>_INCLUDE_DIRS ...
- 设置 <name>_LIBRARIES 为 <name>_LIBRARY <dependency1>_LIBRARIES ...
- 调用宏 find_package_handle_standard_args() 设置 <name>_FOUND 并打印或失败信息
- ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
- 我们以Cmake里面自带的bzip2库为例，Cmake的module目录里面有一个：FindBZip.cmake模块，我们使用find_package（BZip2），然后CMake就会给相关的变量赋值，我们就可以调用这个模块，就可以使用模块里面的变量，模块里面的变量有哪些，我们可以使用命令： cmake --help-module FindBZip2来查看，最后面的参数就是带上Find前缀之后的模块的名字。
- 假如一个程序需要使用BZip2库，编译器需要知道bzlib.h的位置，链接器需要知道bzip2库（动态链接：.so或者.dll）
- 添加库的指令：find_package(BZip2 REQUIRED)
- CMake里面又很多内置的库，当我们使用find_package查找包的时候CMake首先会去CMAKE_MODULE_PATH这个变量存放的路径里面去寻找
- 注意：CMAKE_MODULE_PATH的路径设置需要在顶层的CMakeLists.txt里面去设置。
- find_package之后，变量：BZIP_INCLUDE_DIRS以及BZIP2_LIBRARIES就会被设置，然后我们使用include_directories以及target_link_libraries来使用即可
- ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
- 使用一个cmake里面没有带的库
- cmake的/share/cmake-X.XX/Modules里面带的都是一些常用的库，如果我们现在需要使用一个cmake里面没有提供给我们find模块的库，做法如下：
- 首先模拟生成一个生成lib文件
- 创建工程，名为：ThirdLIB
- 生成一个lib文件，名为：ThirdDLL.lib
- lib文件里面只提供了一个求和的add函数，返回两个int值的和
- 在CMakeLists.txt里面设置CMAKE_MODULE_PATH，这里设置的是本地的路径，这个路径存放的find模块
- 编写自己的find模块
- 注意：cmake使用find_package查找使用的库，当我们把库名字传进去之后，cmake会在按照指定的模式查找一个：Find<NAME>.cmake的文件，常用的库，cmake都会提供对应的.cmake文件，但是现在我们使用的是自己编写的库，所以cmake是没有提供的，需要自己编写
- 编写大致流程已经给出，我们编写的文件名必须是：Find<Name>.cmake,现在就是“FindThidrDLL.cmake”
- FindThirDLL.cmake内容如下
- 修改CMakeLists.txt文件，在里面使用find_package命令添加模块、
- 完成之后，打开生成的工程，查看工程的依赖项，就会有ThirdLIB.lib的选项
- ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
- 当我们在CMake里面使用一个库时候，如何在网上查找，比如现在需要查找：apr库，在goole里面搜索：find package apr cmake，就可以直接找到对应的CMake脚本。然后复制粘贴，创建.cmake文件，放在工程根目录下面的modules目录，没有则创建之
- ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
- add_custom_command：（1）为某一个工程添加一个自定义的命令
add_custom_command(TARGET target
PRE_BUILD | PRE_LINK| POST_BUILD
COMMAND command1[ARGS] [args1...]
[COMMAND command2[ARGS] [args2...] ...]
[WORKING_DIRECTORYdir]
[COMMENT comment][VERBATIM])
作者：drybeans
链接：https://www.jianshu.com/p/66df9650a9e2
來源：简书
简书著作权归作者所有，任何形式的转载都请联系作者获得授权并注明出处。- 执行命令的时间由第二个参数决定
1.PRE_BUILD - 命令将会在其他依赖项执行前执行
2.PRE_LINK - 命令将会在其他依赖项执行完后执行
3.POST_BUILD - 命令将会在目标构建完后执行。 - 例子1：
add_custom_command (
TARGET ${PROJECT_NAME}
POST_BUILD
COMMAND ${CMAKE_COMMAND} -E sleep 5
)
#目标就是TARGET后面跟的工程，当PROJECT_NAME被生成的时候就会执行COMMAND后面的命令 - 例子2：
add_custom_command(TARGET test_elf
PRE_BUILD
COMMAND
move E:/cfg/start.o ${CMAKE_BINARY_DIR}/. &&
)
#在test_el执行依赖之前，将start.o文件复制到编译目录 - add_custom_command：（2）添加自定义命令来产生一个输出
add_custom_command(OUTPUT output1 [output2 ...]
COMMAND command1[ARGS] [args1...]
[COMMAND command2 [ARGS] [args2...] ...]
[MAIN_DEPENDENCYdepend]
[DEPENDS[depends...]]
[IMPLICIT_DEPENDS<lang1> depend1 ...]
[WORKING_DIRECTORYdir]
[COMMENT comment] [VERBATIM] [APPEND])- 其中ARGS选项 是为了向后兼容，MAIN_DEPENDENCY选项是针对Visual Studio给出一个建议，这两选项可以忽略
- COMMAND：指定一些在构建阶段执行的命令。如果指定了多于一条的命令，他会按照顺序去执行。如果指定了一个可执行目标的名字（被add_executable()命令创建），他会自动被在构建阶段创建的可执行文件的路径替换，
- DEPENDS:指定目标依赖的文件，如果依赖的文件是和CMakeLists.txt相同目录的文件，则命令就会在CMakeLists.txt文件的，目录执行。如果没有指定DEPENDS，则只要缺少OUTPUT，该命令就会执行。如果指定的位置和CMAkeLists.txt不是同一位置，会先去创建依赖关系，先去将依赖的目标或者命令先去编译。
- WORKING_DIRECTORY：使用给定的当前目录执行命令，如果是相对路径，则相对于当前源目录对应的目录结构进行解析
- 例子
#首先生成creator的可执行文件
add_executable(creator creator.cxx)
#获取EXE_LOC的LOCATION属性存放到creator里面
get_target_property(creator EXE_LOC LOCATION)
#生成created.c文件
add_custom_command (
OUTPUT ${PROJECT_BINARY_DIR}/created.c
DEPENDS creator
COMMAND ${EXE_LOC}
ARGS ${PROJECT_BINARY_DIR}/created.c
)
#使用上一步生成的created.c文件来生成Foo可执行文件
add_executable(Foo ${PROJECT_BINARY_DIR}/created.c) - 注意：不要再多个相互独立的文件中使用该命令产生相同的文件，防止冲突。
- add_custom_target：增加定制目标
add_custom_target(Name [ALL] [command1 [args1...]]
[COMMAND command2 [args2...] ...]
[DEPENDS depend depend depend ... ]
[BYPRODUCTS [files...]]
[WORKING_DIRECTORY dir]
[COMMENT comment]
[VERBATIM] [USES_TERMINAL]
[SOURCES src1 [src2...]])- 命令 add_custom_target 可以增加定制目标，常常用于编译文档、运行测试用例等。
- add_custom_command和add_custom_target的区别
- 命令命名里面的区别就在于：command和target，前者是自定义命令，后者是自定义目标
- 目标：一般来说目标是调用：add_library或者add_executable生成的exe或者库，他们具有许多属性集，这些就是所谓目标，而使用add_custom_target定义的叫做自定义目标，因此这些“目标”区别于正常的目标，他们不生成exe或者lib，但是仍然会具有一些正常目标相同的属性，构建他们的时候，只是调用了为他们设置的命令，如果自定义目标对于其他目标有依赖，那么就会优先生成依赖的那些目标
- 自定义命令：自定义命令不是一个“可构建”的对象，并且没有可以设置的属性，自定义命令是一个在构建依赖目标之前被调用的命令，自定义命令的依赖可以通过add_custom_command(TARGET target …)形式显式设置，也可以通过add_custom_command(OUTPUT output1 …)生成文件的形式隐式设置。显示执行的时候，每次构建目标，首先会执行自定义的命令，隐式执行的时候，如果自定义的命令依赖于其他文件，则在构建目标的时候先去执行生成其他文件。
- 执行命令的时间由第二个参数决定
- 如何添加C++项目中的常用选项
如：如何支持C++11、如何支持IDE等- 如何激活C++11功能
语法：target_compile_features(<target> <PRIVATE|PUBLIC|INTERFACE> <feature> [...])- target_compile_features(<project_name> PUBLIC cxx_std_11)
- 参数target必须是由：add_executable或者add_library生成的目标
- 另外一种支持C++标准的方法
#设置C++标准级别
set(CMAKE_CXX_STANDARD 11)
#告诉CMake使用他它
set(CMAKE_CXX_STANDARD_REQUIRED ON)
#（可选）确保-std=C++11
set(CMAKE_CXX_EXTENSIONS OFF)
- CMake的过程间优化
- 如果编译器不支持，就会将设置的过程间优化标记为错误，可以使用命令：check_ipo_supported()来查看
#检测编译器是否支持过程间优化
check_ipo_supported(RESULT result)
#如果不支持，判断进不去
if(result)
#为工程foo设置过程间优化
set_target_properties(foo PROPERTIES INTERPROCEDURAL_OPTIMIZATION TRUE)
endif()
- 如果编译器不支持，就会将设置的过程间优化标记为错误，可以使用命令：check_ipo_supported()来查看
- CMake的option简介
- option命令可以设置默认值
option(address "this is path for value" ON) - 命令表示，当用户没有设置address的时候，默认值就是ON，当用户显示的设置address的时候，address里面就是用户设置的值
- 注意：加入有一些变量依赖了address，但是这些变量的使用在option语句之前，此时对于这些变量来说，address还是属于没有定义的。
- 在用户没有提供ON或者OFF的时候，默认是OFF。如果option有改变，一定要清理CMakeCache.txt文件和CMakeFiles文件夹
- CMake编译选项的管理
- 在工程的根目录，编写CMakeLists.txt，另外单独创建option.txt文件，专门管理编译选项
- 在CMakeLists.txt中加入：
include option.txt - 在option.txt中添加：
/*USE_MYMATH 为编译开关，中间的字符串为描述信息，ON/OFF 为默认选项*/
option (USE_MYMATH
"Use tutorial provided math implementation" ON) - 在编译之前，执行ccmake . 就会弹出cmake GUI，进行配置所有的编译开关，配置结束之后会生成一个CMakeCache.txt，配置后的编译选项会保存在这个文件中
https://blog.csdn.net/haima1998/article/details/23352881
- option命令可以设置默认值
- 怎么生成依赖于其他option的option
#设置option：USE_CURL
option(USE_CURL "use libcurl" ON)
#设置option：USE_MATH
option(USE_MATH "use libm" ON)
#设置一个option：DEPENT_USE_CURL,第二个参数是他的说明，ON后面的参数是一个表达式，当“USE_CURL”且“USE_MATH”为真的时候，DEPENT_USE_CURL取ON，为假取OFF
cmake_dependent_option(DEPENT_USE_CURL "this is dependent on USE_CURL" ON "USE_CURL;NOT USE_MATH" OFF) - 属性调试模块（CMakePrintHelpers）
CMAKE_PRINT_PROPERTIES([TARGETS target1 .. targetN]
[SOURCES source1 .. sourceN]
[DIRECTORIES dir1 .. dirN]
[TESTS test1 .. testN]
[CACHE_ENTRIES entry1 .. entryN]
PROPERTIES prop1 .. propN )- 如果要检查foo目标的INTERFACE_INCLUDE_DIRS和LOCATION的值，则执行：
cmake_print_properties （ TARGETS foo
PROPERTIES
INTERFACE_INCLUDE_DIRS
LOCATION ）
- 如果要检查foo目标的INTERFACE_INCLUDE_DIRS和LOCATION的值，则执行：
- 如何激活C++11功能
- //CMake3.8以上叫做Modern CMake
Talk is cheap. Show me the code
