目录
2.12 cmake之set_target_properties
本文参考：
1、https://blog.csdn.net/whahu1989/article/details/82078563
2、https://blog.csdn.net/kai_zone/article/details/82656964
1 Cmake安装
命令安装：
sudo apt install cmake用命令安装，不是最新版本。在终端下输入cmake -version查看cmake版本。
官网下载安装：
- 官网地址：
Download | CMake
https://cmake.org/download/
安装步骤：
- 解压：tar -xzvf cmake-3.22.0-rc2.tar.gz
- 进入目录：cd cmake-3.22.0-rc2
- 运行：./bootstrap
- 编译：make
- 安装：make install
ps：cmake 会默认安装在 /usr/local/bin 下面
可能会出现以下错误：
可使用以下指令更新g++来解决：
sudo apt-get install g++若出现以下错误：
则使用以下指令解决缺库问题：
sudo apt-get install libssl-dev2 Cmake使用
注意：CMakeLists.txt注意大小写。
官网手册：cmake-commands(7) — CMake 3.27.0-rc5 Documentation
2.1 简单样例
首先让我们从最简单的代码入手，先来体验下cmake是如何操作的。编写main.c，如下：
#include <stdio.h>
int main(void)
{
printf("Hello World\n");
return 0;
}然后在main.c相同目录下编写CMakeLists.txt，内容如下：
cmake_minimum_required (VERSION 2.8)
project (demo)
add_executable(main main.c)
- 第一行意思是表示cmake的最低版本要求是2.8，我们安装的是3.10.2；
- 第二行是表示本工程信息，也就是工程名叫demo；
- 第三行比较关键，表示最终要生成的elf文件的名字叫main，使用的源文件是main.c
在终端下切到main.c所在的目录下，然后输入以下命令运行cmake：
cmake .可以看到成功生成了Makefile，还有一些cmake运行时自动生成的文件：
执行make命令，生成可执行文件：
2.2 同一目录下多个源文件
目录结构如下：
testFunc.c内容如下：
/*
** testFunc.c
*/
#include <stdio.h>
#include "testFunc.h"
void func(int data)
{
printf("data is %d\n", data);
}
testFunc.h内容如下:
/*
** testFunc.h
*/
#ifndef _TEST_FUNC_H_
#define _TEST_FUNC_H_
void func(int data);
#endif
修改main.c，调用testFunc.h里声明的函数func()：
#include <stdio.h>
#include "testFunc.h"
int main(void)
{
func(100);
return 0;
}
修改CMakeLists.txt，在add_executable的参数里把testFunc.c加进来：
cmake_minimum_required (VERSION 2.8)
project (demo)
add_executable(main main.c testFunc.c)编译运行同上。
可以类推，如果在同一目录下有多个源文件，那么只要在add_executable里把所有源文件都添加进去就可以了。但是如果有一百个源文件，再这样做就有点坑了，无法体现cmake的优越性。
cmake提供了一个命令可以把指定目录下所有的源文件存储在一个变量中：
aux_source_directory(dir var)
第一个参数：dir是指定目录，
第二个参数：var是用于存放源文件列表的变量；变量名自定义。
我们在main.c所在目录下再添加2个文件，testFunc1.c和testFunc1.h。添加完后整体文件结构如下：
testFunc1.c如下：
/*
** testFunc1.c
*/
#include <stdio.h>
#include "testFunc1.h"
void func1(int data)
{
printf("data is %d\n", data);
}
testFunc1.h如下
/*
** testFunc1.h
*/
#ifndef _TEST_FUNC1_H_
#define _TEST_FUNC1_H_
void func1(int data);
#endif
再修改main.c，调用testFunc1.h里声明的函数func1()：
#include <stdio.h>
#include "testFunc.h"
#include "testFunc1.h"
int main(void)
{
func(100);
func1(200);
return 0;
}
修改CMakeLists.txt：
cmake_minimum_required (VERSION 2.8)
project (demo)
aux_source_directory(. SRC_LIST)
add_executable(main ${SRC_LIST})
使用aux_source_directory把当前目录下的源文件存列表存放到变量SRC_LIST里，然后在add_executable里调用SRC_LIST（注意调用变量时的写法）。
aux_source_directory()也存在弊端，它会把指定目录下的所有源文件都加进来，可能会加入一些我们不需要的文件，此时我们可以使用set命令去新建变量来存放需要的源文件。
cmake_minimum_required (VERSION 2.8)
project (demo)
set( SRC_LIST
./main.c
./testFunc1.c
./testFunc.c)
add_executable(main ${SRC_LIST})
2.3 不同目录下多个源文件
一般来说，当程序文件比较多时，我们会进行分类管理，把代码根据功能放在不同的目录下，这样方便查找。那么这种情况下如何编写CMakeLists.txt呢？
我们把之前的源文件整理一下（新建2个目录test_func和test_func1），整理好后整体文件结构如下：
把之前的testFunc.c和testFunc.h放到test_func目录下，testFunc1.c和testFunc1.h则放到test_func1目录下。
其中，CMakeLists.txt和main.c在同一目录下，内容修改成如下所示：
cmake_minimum_required (VERSION 2.8)
project (demo)
include_directories (test_func test_func1)
aux_source_directory (test_func SRC_LIST)
aux_source_directory (test_func1 SRC_LIST1)
add_executable (main main.c ${SRC_LIST} ${SRC_LIST1})这里出现了一个新的命令：include_directories。
该命令是用来向工程添加多个指定头文件的搜索路径，路径之间用空格分隔。
因为main.c里include了testFunc.h和testFunc1.h，如果没有这个命令来指定头文件所在位置，就会无法编译。当然，也可以在main.c里使用include来指定路径，只是这种写法不好看，如下：
#include "test_func/testFunc.h"
#include "test_func1/testFunc1.h"2.4 正规一点的组织结构
正规一点的做法：
- 一般会把源文件放到src目录下；
- 把头文件放入到include文件下；
- 生成的对象文件放入到build目录下；
- 最终输出的执行文件(elf文件)会放到bin目录下。
这样整个结构更加清晰。让我们把前面的文件再次重新组织下：
方法一：
我们在最外层目录下新建一个CMakeLists.txt，内容如下：
cmake_minimum_required (VERSION 2.8)
project (demo)
add_subdirectory (src)这里出现一个新的命令add_subdirectory()
这个命令可以向当前工程添加存放源文件的子目录，并可以指定中间二进制和目标二进制的存放位置，具体用法可以百度。
这里指定src目录下存放了源文件，当执行cmake时，就会进入src目录下去找src目录下的CMakeLists.txt，所以在src目录下也建立一个CMakeLists.txt，内容如下：
aux_source_directory (. SRC_LIST)
include_directories (../include)
add_executable (main ${SRC_LIST})
set (EXECUTABLE_OUTPUT_PATH ${PROJECT_SOURCE_DIR}/bin)这里又出现一个新的命令set，是用于定义变量的，EXECUTABLE_OUT_PATH和PROJECT_SOURCE_DIR是CMake自带的预定义变量，其意义如下，
EXECUTABLE_OUTPUT_PATH ：目标二进制可执行文件的存放位置；
PROJECT_SOURCE_DIR：工程的根目录；
所以，这里set的意思是把存放elf文件的位置设置为工程根目录下的bin目录。（cmake有很多预定义变量，详细的可以网上搜索一下）
添加好以上这2个CMakeLists.txt后，整体文件结构如下：
下面来运行cmake，不过这次先让我们切到build目录下，然后输入以下命令：
cmake ..Makefile会在build目录下生成，然后在build目录下运行make。
这里解释一下为什么在build目录下运行cmake？从前面几个case中可以看到，如果不这样做，cmake运行时生成的附带文件就会跟源码文件混在一起，这样会对程序的目录结构造成污染，而在build目录下运行cmake，生成的附带文件就只会待在build目录下，如果我们不想要这些文件了就可以直接清空build目录，非常方便。
方法二：
方法一中使用了2个CMakeLists.txt，最外层的CMakeLists.txt用于掌控全局，使用add_subdirectory来控制其它目录下的CMakeLists.txt的运行。
也可以只使用一个CMakeLists.txt，把src目录下的CMakeLists.txt删除。把最外层的CMakeLists.txt内容改成如下：
cmake_minimum_required (VERSION 2.8)
project (demo)
set (EXECUTABLE_OUTPUT_PATH ${PROJECT_SOURCE_DIR}/bin)
aux_source_directory (src SRC_LIST)
include_directories (include)
add_executable (main ${SRC_LIST})2.5 动态库和静态库的编译控制
有时只需要编译出动态库和静态库，然后等着让其它程序去使用。让我们看下这种情况该如何使用cmake。首先按照如下重新组织文件，只留下testFunc.h和TestFunc.c，结构如下：
我们会在build目录下运行cmake，并把生成的库文件存放到lib目录下。
CMakeLists.txt内容如下：
cmake_minimum_required (VERSION 3.5)
project (demo)
set (SRC_LIST ${PROJECT_SOURCE_DIR}/testFunc/testFunc.c)
add_library (testFunc_shared SHARED ${SRC_LIST})
add_library (testFunc_static STATIC ${SRC_LIST})
set_target_properties (testFunc_shared PROPERTIES OUTPUT_NAME "testFunc")
set_target_properties (testFunc_static PROPERTIES OUTPUT_NAME "testFunc")
set (LIBRARY_OUTPUT_PATH ${PROJECT_SOURCE_DIR}/lib)这里又出现了新的命令和预定义变量：
add_library(): 生成动态库或静态库。
- 第1个参数：指定库的名字；
- 第2个参数：决定是动态还是静态，如果没有就默认静态；
- 第3个参数：指定生成库的源文件。
set_target_properties: 设置最终生成的库的名称，还有其它功能，如设置库的版本号等等.
LIBRARY_OUTPUT_PATH: 库文件的默认输出路径，这里设置为工程目录下的lib目录.
PS：前面使用set_target_properties重新定义了库的输出名称，如果不使用set_target_properties也可以，那么库的名称就是add_library里定义的名称，只是连续2次使用add_library指定库名称时（第一个参数），这个名称不能相同，而set_target_properties可以把名称设置为相同，只是最终生成的库文件后缀不同（一个是.so，一个是.a），这样相对来说会好看点。
好了，让我们进入build目录下运行cmake ..，成功后再运行make。
到lib目录下进行查看，发现已经成功生成了动态库和静态库 。
查看库：
- 查看动态库的所有内容：
nm -D xxx.so- 查看动态库中某个函数：
nm -D xxx.so | grep func- 查看静态库的所有内容：
nm -a xxx.a- 查看静态库中某个函数：
nm -a xxx.a | grep func
2.6 对库进行连接
既然我们已经生成了库，那么就进行链接测试下。重新建一个工程目录，然后把上节生成的库拷贝过来，然后在在工程目录下新建src目录和bin目录，在src目录下添加一个main.c，整体结构如下：
main.c内容如下：
#include <stdio.h>
#include "testFunc.h"
int main(void)
{
func(100);
return 0;
}工程目录下的CMakeLists.txt内容如下：
cmake_minimum_required (VERSION 3.5)
project (demo)
set (EXECUTABLE_OUTPUT_PATH ${PROJECT_SOURCE_DIR}/bin)
set (SRC_LIST ${PROJECT_SOURCE_DIR}/src/main.c)
# find testFunc.h
include_directories (${PROJECT_SOURCE_DIR}/testFunc/inc)
find_library(TESTFUNC_LIB testFunc HINTS ${PROJECT_SOURCE_DIR}/testFunc/lib)
add_executable (main ${SRC_LIST})
target_link_libraries (main ${TESTFUNC_LIB})这里出现2个新的命令：
find_library(): 在指定目录下查找指定库，并把库的绝对路径存放到变量里.
- 第一个参数：是变量名称；
- 第二个参数：是库名称；
- 第三个参数：是HINTS；
- 第四个参数：是路径，其它用法可以参考cmake文档。
使用find_library的好处是在执行cmake ..时就会去查找库是否存在，这样可以提前发现错误，不用等到链接时。
find_library(TESTFUNC_LIB testFunc ...默认是查找动态库，如果想直接指定使用动态库还是静态库，可以写成find_library(TESTFUNC_LIB libtestFunc.so ...或者find_library(TESTFUNC_LIB libtestFunc.a ...
target_link_libraries(): 把目标文件与库文件进行链接。
查看执行文件(elf文件)使用了哪些库，可以使用readelf -d ./xx来查看
一个工程实现编译库和连接库，如下：
1、工程结构：
2、代码
3、最外层CMakefile.txt
cmake_minimum_required (VERSION 3.5)
project (demo)
add_subdirectory(func)
add_subdirectory(src)4、src/CMakefile.txt
cmake_minimum_required (VERSION 3.5)
project (demo_src)
set(oject_name "obj_demo")
set (SRC_LIST ${PROJECT_SOURCE_DIR}/main.c)
# 生成执行文件
add_executable(${oject_name} ${SRC_LIST})
# 设置执行文件的路径
set (EXECUTABLE_OUTPUT_PATH ${PROJECT_SOURCE_DIR}/../bin)
# 头文件路径
target_include_directories(
${oject_name}
#PRIVATE
PUBLIC
${PROJECT_SOURCE_DIR}/../func/inc/
)
#find_library(TESTFUNC_LIB func HINTS ${PROJECT_SOURCE_DIR}/lib)
#target_link_libraries(
${oject_name}
#PRIVATE
${TESTFUNC_LIB}
)
# 与注释同等效果，都是连接库
target_link_libraries(
${oject_name}
#PRIVATE
${PROJECT_SOURCE_DIR}/../lib/libfunc.so
)
5、func/CMakefile.txt
cmake_minimum_required(VERSION 3.10)
project(func)
set(LIBRARY_NAME "func")
# 设置库文件的输出路径
set (LIBRARY_OUTPUT_PATH ${PROJECT_SOURCE_DIR}/../lib)
# 生产动/静态库
add_library(
${LIBRARY_NAME}
SHARED
#STATIC
src/func.c
)
# 头文件路径
target_include_directories(
${LIBRARY_NAME}
PRIVATE
#PUBLIC
./inc/
)6、进入build目录，执行cmake .. 和 make命令
target_link_libraries：把目标文件与库文件进行链接
target_link_libraries(<target> ... <item>... ...) target_link_libraries(<target> <PRIVATE|PUBLIC|INTERFACE> <item>... [<PRIVATE|PUBLIC|INTERFACE> <item>...]...)第一参数：目标文件
第二参数（可省略）：PUBLIC、PRIVATE、INTERFACE
第三参数：库文件
注意：1、二三参数可有多个；
2、link_libraries用在add_executable之前，target_link_libraries用在add_executable之后；
target_include_directories：添加头文件路径，与target_link_libraries用法一样
target_include_directories与include_directories区别：include_directories(header-dir) 是一个全局包含，向下传递。什么意思呢？就是说如果某个目录的 CMakeLists.txt 中使用了该指令，其下所有的子目录默认也包含了header-dir 目录。
2.7 编译选项
有时编译程序时想添加一些编译选项，如-Wall，-std=c++11等，就可以使用add_compile_options来进行操作。
这里以一个简单程序来做演示，main.cpp如下：
#include <iostream>
int main(void)
{
auto data = 100;
std::cout << "data: " << data << "\n";
return 0;
}CMakeLists.txt内容如下：
cmake_minimum_required (VERSION 2.8)
project (demo)
set (EXECUTABLE_OUTPUT_PATH ${PROJECT_SOURCE_DIR}/bin)
add_compile_options(-std=c++11 -Wall)
add_executable(main main.cpp)也可以通过set设置编译选项：
SET(CMAKE_C_FLAGS "-Wno-pointer-sign -Wno-unused-function -Wno-parentheses-equality ")
SET(CMAKE_CXX_FLAGS "-Wno-header-guard -Wno-unused-command-line-argument")2.8 添加控制选项
有时希望在编译代码时只编译一些指定的源码，可以使用cmake的option命令，主要遇到的情况分为2种：
- 本来要生成多个bin或库文件，现在只想生成部分指定的bin或库文件；
- 对于同一个bin文件，只想编译其中部分代码（使用宏来控制）；
第1种情况：
假设我们现在的工程会生成2个bin文件，main1和main2，现在整体结构体如下：
外层的CMakeLists.txt内容如下：
cmake_minimum_required(VERSION 3.5)
project(demo)
option(MYDEBUG "enable debug compilation" OFF)
set (EXECUTABLE_OUTPUT_PATH ${PROJECT_SOURCE_DIR}/bin)
add_subdirectory(src)这里使用了option命令。
- 第一个参数是这个option的名字，
- 第二个参数是字符串，用来描述这个option是来干嘛的，
- 第三个是option的值，ON或OFF，也可以不写，不写就是默认OFF。
然后编写src目录下的CMakeLists.txt，如下：
cmake_minimum_required (VERSION 3.5)
add_executable(main1 main1.c)
if (MYDEBUG)
add_executable(main2 main2.c)
else()
message(STATUS "Currently is not in debug mode")
endif()注意，这里使用了if-else来根据option来决定是否编译main2.c。
其中main1.c和main2.c的内容如下：
// main1.c
#include <stdio.h>
int main(void)
{
printf("hello, this main1\n");
return 0;
}// main2.c
#include <stdio.h>
int main(void)
{
printf("hello, this main2\n");
return 0;
}然后cd到build目录下输入cmake .. && make就可以只编译出main1，如果想编译出main2，就把MYDEBUG设置为ON，再次输入cmake .. && make重新编译。
每次想改变MYDEBUG时都需要去修改CMakeLists.txt，有点麻烦，其实可以通过cmake的命令行去操作，例如我们想把MYDEBUG设置为OFF，先cd到build目录，然后输入cmake .. -DMYDEBUG=ON，这样就可以编译出main1和main2 （在bin目录下）
第2种情况：
假设我们有个main.c，其内容如下：
#include <stdio.h>
int main(void)
{
#ifdef WWW1
printf("hello world1\n");
#endif
#ifdef WWW2
printf("hello world2\n");
#endif
return 0;
}可以通过定义宏来控制打印的信息，我们CMakeLists.txt内容如下：
cmake_minimum_required(VERSION 3.5)
project(demo)
set (EXECUTABLE_OUTPUT_PATH ${PROJECT_SOURCE_DIR}/bin)
option(WWW1 "print one message" OFF)
option(WWW2 "print another message" OFF)
if (WWW1)
add_definitions(-DWWW1)
endif()
if (WWW2)
add_definitions(-DWWW2)
endif()
add_executable(main main.c)这里把option的名字保持和main.c里的宏名称一致，这样更加直观，也可以选择不同的名字。通过与add_definitions()的配合，就可以控制单个bin文件的打印输出了。
整体工程结构如下：
cd到build目录下执行cmake .. && make，然后到bin目录下执行./main，可以看到打印为空，
接着分别按照下面指令去执行，然后查看打印效果，
- cmake .. -DWWW1=ON -DWWW2=OFF && make
- cmake .. -DWWW1=OFF -DWWW2=ON && make
- cmake .. -DWWW1=ON -DWWW2=ON && make
这里有个小坑要注意下：假设有2个options叫A和B，先调用cmake设置了A，下次再调用cmake去设置B，如果没有删除上次执行cmake时产生的缓存文件，那么这次虽然没设置A，也会默认使用A上次的option值。
2.9 其他常用用法
2.9.1 宏
ADD_DEFINITIONS(-D DEBUG) #定义一个宏
ADD_DEFINITIONS(-D LOG_LVL=4) #设置宏LOG_LVL值为4
ADD_DEFINITIONS(-DHELLODEF="hello") #这里-D要与宏连着
#set(HELLO "hello world")
#ADD_DEFINITIONS(-DHELLODEF="${HELLO}") main.c
#include <stdio.h>
int main()
{
#ifdef DEBUG
printf("set debug");
#endif
if (LOG_LVL == 4)
{
printf("LOG_LVL = %d\n",LOG_LVL);
}
printf("HELLODEF = %s\n",HELLODEF);
}CMakeLists.txt：
cmake_minimum_required (VERSION 3.5)
project (demo)
ADD_DEFINITIONS(-D DEBUG)
ADD_DEFINITIONS(-D LOG_LVL=4) #设置宏LOG_LVL值为4
ADD_DEFINITIONS(-DHELLODEF="hello") #这里-D要与宏连着
#set(HELLO "hello world")
#ADD_DEFINITIONS(-DHELLODEF="${HELLO}") #这样也可以
add_executable(main ./main.c)2.9.2 set设置选项
set(SWICH ON) #可以设置ON/OFF，可控制子级CMakefiles.txtcmake_minimum_required (VERSION 3.5)
project (demo)
set(SWICH OFF)
if(SWICH)
message("*****SWICH = ${SWICH}")
else()
message("*****SWICH = ${SWICH}")
endif()2.9.3 比较（MATCHES/STREQUAL）
set(SYSTEM_NAME "Linux")
if(${SYSTEM_NAME} MATCHES Linux) #Linux也可以加双引号"Linux"
message("1 SYSTEM_NAME = ${SYSTEM_NAME}")
elseif(${SYSTEM_NAME} MATCHES "X86")
message("2 SYSTEM_NAME = ${SYSTEM_NAME}")
else()
message("3 SYSTEM_NAME = ${SYSTEM_NAME}")
endif()
#############################################
# STREQUAL 用于比较字符串，相同返回 true
set(SYSTEM_NAME "Linux")
if(${SYSTEM_NAME} STREQUAL Linux) #或if(SYSTEM_NAME STREQUAL Linux)
message("SYSTEM_NAME = ${SYSTEM_NAME}")
endif()2.10 cmake之include
1、include(fileName [OPTIONAL] [RESULT_VARIABLE <var>] [NO_POLICY_SCOPE])
与add_subdirectory()命令有点类似，区别如下：
- include()读取文件的名称；而add_subdirectory()是一个目录，并在该目录下查找CMakeLists.txt；
- 传递给include()的文件名通常具有拓展名.cmake（.cmake与CMakeLists.txt一样），但可以是其他任何格式的；（.cmake文件里包含了一些cmake命令和一些宏/函数，当CMakeLists.txt包含该.cmake文件时，当编译运行时，该.cmake里的一些命令就会在该包含处得到执行，并且在包含以后的地方能够调用该.cmake里的一些宏和函数）
- CMAKE_CURRENT_SOURCE_DIR和CMAKE_CURRENT_BINARY_DIR变量的值在处理include()命名引入的文件时不会变（CMAKE_CURRENT_SOURCE_DIR表示调include(xx.cmake)命令所在的目录，而不是xx.cmake目录），而add_subdirectory()引入子目录会改变
- CMAKE_CURRENT_LIST_DIR与CMAKE_CURRENT_SOURCE_DIR类似，只是在处理include(xx.cmake)命令文件时，路径为xx.cmake路径
- 另外再介绍两个宏：
- CMAKE_CURRENT_LIST_FILE当前正在处理文件的名称，始终是文件的绝对路径，不仅仅是文件名；
- CMAKE_CURRENT_LIST_LINE当前正在处理的文件的行号
2、include(module> [OPTIONAL] [RESULT_VARIABLE <var>] [NO_POLICY_SCOPE])
此种用法暂不关注
可选参数：
1、OPTIONAL
include(xxxx.cmake OPTIONAL) # xxxx.cmake不存在也不会触发warning或error
include(xxxx.cmake) # xxxx.cmake不存在,会触发error2、RESULT_VARIABLE
include(xxx.cmake RESULT_VARIABLE var)
message("var: ${var}") #输出xxx.cmake的绝对路径
cmake_minimum_required (VERSION 3.5) project (demo) include(sub2/test.cmake RESULT_VARIABLE var) message("var: ${var}") #输出 sub2/test.cmake路径3、NO_POLICY_SCOPE
如果include命令读取的文件包含对cmake_policy命令的使用，则默认情况下该policy的设置不会影响调用者，可通过include命令中可选的NO_POLICY_SCOPE关键字来控制此行为。
例1：
CMakeLists.txt：
cmake_minimum_required (VERSION 3.5)
project (demo)
message("top CMAKE_CURRENT_SOURCE_DIR = ${CMAKE_CURRENT_SOURCE_DIR}")
message("top CMAKE_CURRENT_BINARY_DIR = ${CMAKE_CURRENT_BINARY_DIR}")
message("top CMAKE_CURRENT_LIST_DIR = ${CMAKE_CURRENT_LIST_DIR}")
message("top CMAKE_CURRENT_LIST_FILE = ${CMAKE_CURRENT_LIST_FILE}")
message("top CMAKE_CURRENT_LIST_LINE = ${CMAKE_CURRENT_LIST_LINE}")
add_subdirectory(sub1)
include(sub2/test.cmake)sub1/ CMakeLists.txt：
cmake_minimum_required (VERSION 3.5)
project (sub1)
message("sub1 CMAKE_CURRENT_SOURCE_DIR = ${CMAKE_CURRENT_SOURCE_DIR}")
message("sub1 CMAKE_CURRENT_BINARY_DIR = ${CMAKE_CURRENT_BINARY_DIR}")
message("sub1 CMAKE_CURRENT_LIST_DIR = ${CMAKE_CURRENT_LIST_DIR}")
message("sub1 CMAKE_CURRENT_LIST_FILE = ${CMAKE_CURRENT_LIST_FILE}")
message("sub1 CMAKE_CURRENT_LIST_LINE = ${CMAKE_CURRENT_LIST_LINE}")sub2/ CMakeLists.txt：
cmake_minimum_required (VERSION 3.5)
project (sub2)
message("sub2 CMAKE_CURRENT_SOURCE_DIR = ${CMAKE_CURRENT_SOURCE_DIR}")
message("sub2 CMAKE_CURRENT_BINARY_DIR = ${CMAKE_CURRENT_BINARY_DIR}")
message("sub2 CMAKE_CURRENT_LIST_DIR = ${CMAKE_CURRENT_LIST_DIR}")
message("sub2 CMAKE_CURRENT_LIST_FILE = ${CMAKE_CURRENT_LIST_FILE}")
message("sub2 CMAKE_CURRENT_LIST_LINE = ${CMAKE_CURRENT_LIST_LINE}")输出结果：
2.11 cmake之install
install 命令用于指定文件的输出路径，这个文件可以是二进制执行文件、动态库文件、静态库文件，甚至是目录。通俗的来讲，install 其实就是把生成的文件统一拷贝到某个目录下，方便打包或者转移。install 在不同场合，使用的格式也会有所不同，大体可分为安装目标文件、安装目录、安装文件。
1、安装目录文件
install(TARGETS <target_name>
[RUNTIME | LIBRARY | ARCHIVE]
DESTINATION <target_dir>......#还有其他参数，暂不关注
)参数：
- TARGETS：表示后面目标文件(target_name)为可执行文件、静态库、动态库，可有多个目标；
- RUNTIME：为可执行文件、 LIBRARY：为动态库、 ARCHIVE：静态库
- DESTINATION：后面(target_dir)为目标要存放的路径
注意：make后，需要make install才会复制
Install()命令安装路径：
1、CMAKE_INSTALL_PREFIX为install()命令安装的路径，默认为 /usr/local/（cmake安装目录），可更改如下：
set(CMAKE_INSTALL_PREFIX ${CMAKE_CURRENT_LIST_DIR}/install) set(CMAKE_INSTALL_PREFIX ${CMAKE_CURRENT_LIST_DIR}/install) #需在install命令的上一级CMakeLists.txt设置，即在add_subdirectory()前设置；
也可以通过cmake编译时设置CMAKE_INSTALL_PREFIX路径
cmake -DCMAKE_INSTALL_PREFIX="/root/work/test/demo1/install" ..例1：
外层CMakeLists.txt：
cmake_minimum_required (VERSION 3.6)
project (demo)
#需在install命令的上一级CMakeLists.txt设置，即在add_subdirectory()前设置；
set(CMAKE_INSTALL_PREFIX ${CMAKE_CURRENT_LIST_DIR}/install)#会在当前工程建install目录
add_subdirectory(func)func/CMakeLists.txt：
cmake_minimum_required (VERSION 3.5)
project (func)
add_executable(main main.c)
add_library (func_static STATIC func.c)
add_library (func_shared SHARED func.c)
install(TARGETS main func_static func_shared
RUNTIME DESTINATION bin #自动在install目录下新建bin
ARCHIVE DESTINATION lib #自动在install目录下新建bin
LIBRARY DESTINATION lib
)
make install后结果如下：
2、install()参数中设置绝对路径；
外层CMakeLists.txt：
cmake_minimum_required (VERSION 3.6)
project (demo)
#set(CMAKE_INSTALL_PREFIX ${CMAKE_CURRENT_LIST_DIR}/install)
add_subdirectory(func)func/CMakeLists.txt：
cmake_minimum_required (VERSION 3.5)
project (func)
add_executable(main main.c)
add_library (func_static STATIC func.c)
add_library (func_shared SHARED func.c)
install(TARGETS main func_static func_shared
RUNTIME DESTINATION /root/work/test/demo1/bin
ARCHIVE DESTINATION /root/work/test/demo1/lib
LIBRARY DESTINATION ${CMAKE_CURRENT_LIST_DIR}/../lib
)make install后结果如下：
2、安装普通文件
install(<FILES|PROGRAMS> files...
TYPE <type> | DESTINATION <dir>
[PERMISSIONS permissions...]
[CONFIGURATIONS [Debug|Release|...]]
[COMPONENT <component>]
[RENAME <name>] [OPTIONAL] [EXCLUDE_FROM_ALL])参数：
FILES|PROGRAMS：若为相对路径给出的文件名，将相对于当前源目录进行解释。其中，FILES为普通的文本文件，PROGRAMS指的是非目标文件的可执行程序(如脚本文件)。- TYPE|DESTINATION：两个选其一，TYPE为文件类型（BIN、SBIN、LIB...），有相关默认安装路径；DESTINATION与前面用法一样；
- PERMISSIONS：指定安装文件的权限，默认情况下，普通的文本文件将具有OWNER_WRITE，OWNER_READ，GROUP_READ和WORLD_READ权限，即644权限；而非目标文件的可执行程序将具有OWNER_EXECUTE, GROUP_EXECUTE,和WORLD_EXECUTE，即755权限。
- CONFIGURATIONS：指定安装规则适用的构建配置列表(DEBUG或RELEASE等)
- EXCLUDE_FROM_ALL：指定该文件从完整安装中排除，仅作为特定于组件的安装的一部分进行安装；
- OPTIONAL：如果要安装的文件不存在，则指定不是错误；
- RENAME：指定已安装文件的名称，该名称可能与原始文件不同。仅当命令安装了单个文件时，才允许重命名。
- COMPONENT选项指定了该安装规则相关的一个安装部件的名字，比如“runtime”或“development”。对于那些指定安装部件的安装过程来说，在安装时只有与给定的部件名相关的安装规则会被执行。对于完整安装，所有部件都会被安装。
cmake_minimum_required (VERSION 3.5)
project (func)
add_executable(main main.c)
add_library (func_static STATIC func.c)
add_library (func_shared SHARED func.c)
install(TARGETS main func_static func_shared
RUNTIME DESTINATION bin
ARCHIVE DESTINATION lib
LIBRARY DESTINATION lib
)
install(FILES ${CMAKE_CURRENT_LIST_DIR}/func.c
DESTINATION lib
)2.12 cmake之set_target_properties
参考：(131条消息) 【cmake学习】set_target_properties 常见属性以及获取target 属性_仲夏夜之梦~的博客-CSDN博客
set_target_properties 的作用是设置目标的属性，可以是目标文件输出的名称或者目录、目标文件的版本号。与之对应的，我们可以使用 get_target_properties 来获取目标文件某一属性对应的值。
格式如下：
set_target_properties(目标文件1 目标文件2 ...
PROPERTIES
属性1 属性值1 属性2 属性值2 ...) 1、更改目标文件的输出名称（OUTPUT_NAME）
命令格式：
set_target_properties(<old_name> PROPERTIES OUTPUT_NAME <new_name>)其实就是备份重命名
cmake_minimum_required (VERSION 3.5)
project (func)
add_executable(main main.c)
add_library (func_static STATIC func.c)
add_library (func_shared SHARED func.c)
set_target_properties(main PROPERTIES OUTPUT_NAME obj_main)
set_target_properties(func_static PROPERTIES OUTPUT_NAME static_func)
set_target_properties(func_shared PROPERTIES OUTPUT_NAME "shared_func")2、设置版本号（VERSION）
命令格式：
# VERSION: 一般指代动态库版本
# SOVERSION: 指代API版本
SET_TARGET_PROPERTIES (<target> PROPERTIES
VERSION <version_number>
SOVERSION <soversion_number>
)cmake_minimum_required (VERSION 3.5)
project (func)
add_executable(main main.c)
add_library (func_static STATIC func.c)
add_library (func_shared SHARED func.c)
set_target_properties (func_shared PROPERTIES VERSION 2.1 SOVERSION 1.1)输出：
3、将目标文件保存到指定目录下
方式一：set设置输出目录
以设置动态库的保存目录，然后所有的动态库都会被保存到该目录下（静态库和二进制执行文件也是同理），对应的属性如下：
- CMAKE_RUNTIME_OUTPUT_DIRECTORY：二进制执行文件的输出目录
- CMAKE_LIBRARY_OUTPUT_DIRECTORY：动态库的输出目录
- CMAKE_ARCHIVE_OUTPUT_DIRECTORY：静态库的输出目录
set(CMAKE_LIBRARY_OUTPUT_DIRECTORY ${PROJECT_SOURCE_DIR}/lib) # 动态库
set(CMAKE_ARCHIVE_OUTPUT_DIRECTORY ${PROJECT_SOURCE_DIR}/static) # 静态库
set(CMAKE_RUNTIME_OUTPUT_DIRECTORY ${PROJECT_SOURCE_DIR}/bin) # 执行文件方式二：指向性保存
同样是指定输出目录，但是不同的动态库文件指定不同的输出目录。（静态库和二进制执行文件也是同理）。目标文件可以大致分为三种类型：二进制执行文件、动态库、静态库。保存不同目标文件所用到的属性不一样。具体分类如下。
- RUNTIME_OUTPUT_DIRECTORY：二进制执行文件
- LIBRARY_OUTPUT_DIRECTORY：动态库
- ARCHIVE_OUTPUT_DIRECTORY：静态库、
命令格式如下：
# <target> 需要安装的目标文件
# <folder_type> 属性类型
# <target_dir> 目标目录
SET_TARGET_PROPERTIES (<target> PROPERTIES <folder_type> <target_dir>)cmake_minimum_required (VERSION 3.5)
project (func)
add_executable(main main.c)
add_library (func_static STATIC func.c)
add_library (func_shared SHARED func.c)
set_target_properties(main PROPERTIES RUNTIME_OUTPUT_DIRECTORY ${PROJECT_SOURCE_DIR}/../bin)
set_target_properties(func_static PROPERTIES ARCHIVE_OUTPUT_DIRECTORY ${PROJECT_SOURCE_DIR}/../lib)
set_target_properties(func_shared PROPERTIES LIBRARY_OUTPUT_DIRECTORY ${PROJECT_SOURCE_DIR}/../lib)2.13 cmake之list
list就是列表，跟c++ list一样，主要有增、删、改、查；
cmake把list分为了4大类，读、查、改
官网手册：list — CMake 3.27.0-rc5 Documentation
https://cmake.org/cmake/help/latest/command/list.html
1、读相关
（1）获取长度
list(LENGTH <list> <out-var>)#<>为必填项cmake_minimum_required (VERSION 3.6)
project (demo)
set(myList a b c d e) #创建list
message("myList: ${myList}") # myList: a;b;c;d;e
list(LENGTH myList len)
message("len: ${len}") # len:5
set(myList1 "a b c d e") #
list(LENGTH myList1 len)
message("len: ${len}") # len:1（2）获取list列表值
list(GET <list> <element index> [<index> ...] <out-var>)set(myList a b c d e) #创建list
list(GET myList 1 value)#获取第二元素
message("value: ${value}") # value:b
list(GET myList 1 3 value)#获取第2,4元素
message("value: ${value}") # value:b;d（3）加入
list(JOIN <list> <glue> <out-var>)#在两个元素中添加
cmake_minimum_required (VERSION 3.6)
project (demo)
set(myList a b c d e) #创建list
list(JOIN myList "-" value)#等价：list(JOIN myList - value)
message("value: ${value}") #value: a-b-c-d-e
list(LENGTH myList len)
message("len: ${len}") # len:5，注意长度无变化(4)获取连续几个值
list(SUBLIST <list> <begin> <length> <out-var>)set(myList a b c d e) #创建list
list(SUBLIST myList 1 3 value)
message("value: ${value}") #value: b;c;d2、查找
list(FIND <list> <value> <out-var>)Search:返回list中指定元素的的索引，如果未找到则返回-1
cmake_minimum_required (VERSION 3.6)
project (demo)
set(myList a b c d e) #创建list
list(FIND myList d value)
message("value: ${value}") #value: 3
list(FIND myList g value)
message("value: ${value}") #value: -1
3、修改
（1）APPEND
list(APPEND <list> [<element>...])cmake_minimum_required (VERSION 3.6)
project (demo)
set(myList a b c d e) #创建list
list(APPEND myList d)
message("myList: ${myList}") # myList: a;b;c;d;e;d
list(APPEND myList f g)
message("myList: ${myList}") # myList: a;b;c;d;e;d
set(myList2 1 2 3 4) #创建list
list(APPEND myList ${myList2})
message("myList: ${myList}") # myList: a;b;c;d;e;d;f;g;1;2;3;4（2）FILTER
从list中INCLUDE 或EXCLUDE模式匹配的项(item)。在REGEX模式下，items将与给定的正则表达式匹配
list(FILTER <list> {INCLUDE | EXCLUDE} REGEX <regex>)cmake_minimum_required (VERSION 3.6)
project (demo)
set(myList a b c d e 1 2 3) #创建list
list(FILTER myList INCLUDE REGEX "[a-z]")
message("myList: ${myList}") # myList: a;b;c;d;e
list(FILTER myList EXCLUDE REGEX [a-z]) #myList: 1;2;3
message("myList: ${myList}")（3）INSERT
list(INSERT <list> <index> [<element>...])cmake_minimum_required (VERSION 3.6)
project (demo)
set(myList a b c d e 1 2 3) #创建list
list(INSERT myList 3 W)
message("myList: ${myList}") #myList: a;b;c;W;d;e;1;2;3（4）还有其他的，就不一一说明了
list(APPEND <list> [<element>...])
list(FILTER <list> {INCLUDE | EXCLUDE} REGEX <regex>)
list(INSERT <list> <index> [<element>...])
list(POP_BACK <list> [<out-var>...])
list(POP_FRONT <list> [<out-var>...])
list(PREPEND <list> [<element>...])
list(REMOVE_ITEM <list> <value>...)
list(REMOVE_AT <list> <index>...)
list(REMOVE_DUPLICATES <list>)
list(TRANSFORM <list> <ACTION> [...])4、排序
（1）翻转
list(REVERSE <list>) #REVERSE:就地反转list的内容（2）排序
list(SORT <list> [COMPARE <compare>] [CASE <case>] [ORDER <order>])使用COMPARE关键字选择排序的比较方法，<compare>选项应该是其中之一：
- STRING:按字母顺序对字符串list进行排序。如果没有给出COMPARE选项，这是默认行为
- FILE_BASENAME:按文件的basenames对文件的路径名list进行排序
- NATURAL:使用自然顺序(natural order)对字符串list进行排序
使用CASE关键字选择区分大小写或不区分大小写的排序模式。<case>选项应该是其中之一：
- SENSITIVE:list items以区分大小写(case-sensitive)的方式排序。如果没有给出CASE选项，这是默认行为
- INSENSITIVE:list items不区分大小写
要控制排序顺序，可以给出ORDER关键字。<order>选项应该是其中之一：
- ASCENDING:按升序对list进行排序。这是未给出ORDER选项时的默认行为
- DESCENDING:按降序对list进行排序
set(values c 4 a I f 9 -1 B b)
list(SORT values COMPARE STRING)
message("values: ${values}") # values: -1;4;9;B;I;a;b;c;f
set(values 10.0 1.1 2.1 8.0 2.0 3.1)
list(SORT values)
message("values: ${values}") # values: 1.1;10.0;2.0;2.1;3.1;8.0
set(values 10.0 1.1 2.1 8.0 2.0 3.1)
list(SORT values COMPARE NATURAL)
message("values: ${values}") # values: 1.1;2.0;2.1;3.1;8.0;10.0
set(values A c B e i H)
list(SORT values CASE SENSITIVE)
message("values: ${values}") # values: A;B;H;c;e;i
set(values A c B e i H)
list(SORT values CASE INSENSITIVE)
message("values: ${values}") # values: A;B;c;e;H;i
set(values A c B e i H)
list(SORT values ORDER ASCENDING)
message("values: ${values}") # values: A;B;H;c;e;i
set(values A c B e i H)
list(SORT values ORDER DESCENDING)
message("values: ${values}") # values: i;e;c;H;B;A实际应用 ：
cmake_minimum_required (VERSION 3.5)
project (func)
set(SRC_LIST main.c)
if (DEBUG)
list(APPEND SRC_LIST func.c)
endif()
add_executable(main ${SRC_LIST })
1097
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
