C++Cmake使用教程（看这一篇就够了）

Posted 2023-04-03 隐居的遮天恶鬼

tags:

篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了C++Cmake使用教程（看这一篇就够了）相关的知识，希望对你有一定的参考价值。

文章目录

引言

CMake是开源、跨平台的构建工具，可以让我们通过编写简单的配置文件去生成本地的Makefile，这个配置文件是独立于运行平台和编译器的，这样就不用亲自去编写Makefile了，而且配置文件可以直接拿到其它平台上使用，无需修改，非常方便。

本文主要讲述在Linux下如何使用CMake来编译我们的程序。

一环境搭建

我使用的是ubuntu18.04，安装cmake使用如下命令：

sudo apt install cmake

安装完成后，在终端下输入:

cmake -version

查看cmake版本

这样cmake就安装好了。

二简单入门

首先让我们从最简单的代码入手，先来体验下cmake是如何操作的。

2.1 项目结构

2.2 示例源码

打开终端，输入：

touch main.c CMakeLists.txt

编写main.c，如下：

main.c

#include <stdio.h>

int main(void)

	printf("Hello World\\n");
	return 0;

然后在main.c同级目录下编写CMakeLists.txt，内容如下：

CMakeLists.txt

cmake_minimum_required (VERSION 2.8)

project (demo)

add_executable(main main.c)

2.3 运行查看

在终端下切到main.c所在的目录下，然后输入以下命令运行cmake：

cmake .

输出结果如下：

ps:此时，建议留意一下这个文件夹下多生成的文件都有哪些。

可以看到成功生成了Makefile，还有一些cmake运行时自动生成的文件。
然后在终端下输入make：

可以看到执行cmake生成的Makefile可以显示进度，并带颜色。再看下目录下的文件：

可以看到我们需要的可执行文件main也成功生成了！
然后运行main：

运行成功！

PS：如果想重新生成main，输入make clean就可以删除main这个文件。然后重新make就行。
需要注意的是：我希望你着重看一下这时候这个文件夹下都有哪些文件。

三编译多个源文件

3.1 在同一个目录下有多个源文件

3.1.1 简单版本

接下来进入稍微复杂的例子：在同一个目录下有多个源文件。

3.1.1.1 项目结构

3.1.1.2 示例代码

首先删除之前的文件：

rm -rf CMakeFiles CMakeCache.txt cmake_install.cmake Makefile main

在之前的目录下添加2个文件，testFunc.c和testFunc.h:

touch testFunc.c testFunc.h

添加完后整体文件结构如下：

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()：

main.c

#include <stdio.h>

#include "testFunc.h"

int main(void)

	func(100);
	return 0;

修改CMakeLists.txt，在add_executable的参数里把testFunc.c加进来:

CMakeLists.txt

cmake_minimum_required (VERSION 2.8)

project (demo)

add_executable(main main.c testFunc.c)

3.1.1.3 运行查看

cmake .
make

然后运行查看：

运行成功！

可以类推，如果在同一目录下有多个源文件，那么只要在add_executable里把所有源文件都添加进去就可以了。

但是如果有一百个源文件，再这样做就有点坑了，无法体现cmake的优越性。
因此cmake提供了一个命令可以把指定目录下所有的源文件存储在一个变量中，这个命令就是

aux_source_directory(dir var)

第一个参数dir是指定目录，第二个参数var是用于存放源文件列表的变量。

接下来写个进阶版的demo使用一下这个变量。

3.1.2 进阶版本

3.1.2.1 项目结构

3.1.2.2 示例源码

删除无关文件

rm -rf CMakeFiles CMakeCache.txt cmake_install.cmake  main Makefile

创建文件：

touch 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()：

main.c

#include <stdio.h>

#include "testFunc.h"
#include "testFunc1.h"

int main(void)

	func(100);
	func1(200);

	return 0;

修改CMakeLists.txt：

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（注意调用变量时的写法）。

3.1.2.3 运行查看

再次执行cmake和make，并运行main:

可以看到运行成功了。

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)

3.2 在不同目录下有多个源文件

一般来说，当程序文件比较多时，我们会进行分类管理，把代码根据功能放在不同的目录下，这样方便查找。那么这种情况下如何编写CMakeLists.txt呢？

3.2.1 项目结构

我们把之前的源文件整理一下（新建2个目录test_func和test_func1）：

rm -rf CMakeFiles CMakeCache.txt cmake_install.cmake  main Makefile

整理好后整体文件结构如下：

把之前的testFunc.c和testFunc.h放到test_func目录下，testFunc1.c和testFunc1.h则放到test_func1目录下。

3.2.2 示例源码

其中，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次aux_source_directory，因为源文件分布在2个目录下，所以添加2次。

3.2.2 运行查看

四项目级的组织结构

正规一点来说，一般会把源文件放到src目录下，把头文件放入到include文件下，生成的对象文件放入到build目录下，最终输出的可执行程序文件会放到bin目录下，这样整个结构更加清晰。

4.1 项目结构

让我们把前面的文件再次重新组织下：

4.2 示例源码

修改CMakeLists.txt：

CMakeLists.txt

cmake_minimum_required (VERSION 2.8)

project (demo)

add_subdirectory (src)

add_subdirectory：这个语句的作用是增加编译子目录。其基本语法格式是：

add_subdirectory(source_dir [binary_dir] [EXCLUDE_FROM_ALL])

一共有三个参数，后两个是可选参数.

指定一个包含CMakeLists.txt和代码文件所在的目录，该目录可以是绝对路径，也可以是相对路径，对于后者相对路径的起点是CMAKE_CURRENT_SOURCE_DIR。此外，如果子目录再次包含的CMakeLists.txt，则将继续处理里层的CMakeLists.txt，而不是继续处理当前源代码。

binary_dir 二进制代码目录

这个目录是可选的，如果指定，cmake命令执行后的输出文件将会存放在此处，若没有指定，默认情况等于source_dir没有进行相对路径计算前的路径，也就是CMAKE_BINARY_DIR。

EXCLUDE_FROM_ALL标记

这个标志是可选的，如果传递了该参数表示新增加的子目录将会排除在ALL目录之外（可能是make系统中的make all？），表示这个目录将从IDE的工程中排除。用户必须显式在子文件这个编译目标（手动cmake之类的）。指定了这个文件夹，表示这个文件夹是独立于源工程的，这些函数是有用但是不是必要的，比如说我们一系列的例子。

add_subdirectory 这个命令用于添加源文件子目录，同时还可以指定中间二进制和目标二进制的生成路径。EXCLUDE_FROM_ALL将会将这个目录从编译中排除，如工程的例子需要等待其他编译完成后再进行单独的编译。通常子目录应该包含自己的project()命令，这样以来整个编译命令将会产生各自的目标文件。如果把CMakeLists.txt与VS IDE比较，总的CMakeLists.txt就相当于解决方案，子CMakeLists.txt就相当于在解决方案下的工程文件。还有一个需要注意的是，如果编译父CMakeLists时依赖了子CMakeLists.txt中的源文件，那么该标志将会被覆盖（也就是也会处理），以满足编译任务。

这里指定src目录下存放了源文件，当执行cmake时，就会进入src目录下去找src目录下的CMakeLists.txt，所以在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_OUTPUT_PATH是个系统自带的预定义变量，其意义如下：

EXECUTABLE_OUTPUT_PATH ：目标二进制可执行文件的存放位置
PROJECT_SOURCE_DIR：工程的根目录

所以，这里set的意思是把存放elf文件的位置设置为工程根目录下的bin目录。（cmake有很多预定义变量，详细的可以网上搜索一下）

添加好以上这2个CMakeLists.txt后，整体文件结构如下：

4.3 运行查看

下面来运行cmake，不过这次先让我们切到build目录下:

cd build
cmake ..
make

这样Makefile会在build目录下生成，二进制程序会在bin目录下生成，然后运行可执行程序：

cd ../bin
./main

这里解释一下为什么在build目录下运行cmake？
还记得在第一个例子里我让你着重看一下cmake和make之后会生成什么文件吗？这个过程中会生成很多文件，但是可惜的是跟我们的运行并没有什么关系，因此，如果能把编译隔离在某个文件夹，这样cmake的时候所有的中间文件都将在这个目录下生成，删除的时候也很好删除，非常方便。如果不这样做，cmake运行时生成的附带文件就会跟源码文件混在一起，这样会对程序的目录结构造成污染。
另外一种写法：
前面的工程使用了2个CMakeLists.txt，最外层的CMakeLists.txt用于掌控全局，使用add_subdirectory来控制其它目录下的CMakeLists.txt的运行。

上面的例子也可以只使用一个CMakeLists.txt，把最外层的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)

同时，还要把src目录下的CMakeLists.txt删除。

然后正常编译运行就可以。

五动态库和静态库的编译控制

有时只需要编译出动态库和静态库，然后等着让其它程序去使用。让我们看下这种情况该如何使用cmake。

关于什么是静态库和动态库以及如何使用它们，请参见我的另一篇博客【C++】静态库与动态库的生成与使用介绍

5.1 生成库文件

5.1.1 项目结构

首先按照如下重新组织文件，只留下testFunc.h和TestFunc.c

我们会在build目录下运行cmake，并把生成的库文件存放到lib目录下。

5.1.2 示例源码

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），这样相对来说会好看点。

5.1.3 运行查看

cd build/
cmake ..
make
cd ../lib/
ls

5.2 链接库文件

既然我们已经生成了库，那么就进行链接测试下。

5.2.1 项目结构

重新建一个工程目录，然后把上节生成的库拷贝过来，然后在在工程目录下新建src目录和bin目录，在src目录下添加一个main.c，整体结构如下：

5.2.2 示例源码

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，第4个参数是路径，其它用法可以参考cmake文档
target_link_libraries: 把目标文件与库文件进行链接

使用find_library的好处是在执行cmake …时就会去查找库是否存在，这样可以提前发现错误，不用等到链接时。

5.2.3 运行查看

cd到build目录下，然后运行cmake … && make，最后进入到bin目录下查看，发现main已经生成，运行之：

cd build/
cmake ..
make
cd ../bin/
./main

ps：在lib目录下有testFunc的静态库和动态库，find_library(TESTFUNC_LIB testFunc
…默认是查找动态库，如果想直接指定使用动态库还是静态库，可以写成find_library(TESTFUNC_LIB
libtestFunc.so …或者find_library(TESTFUNC_LIB libtestFunc.a …

ps：查看elf文件使用了哪些库，可以使用readelf -d ./xx来查看例：readelf -d ./main

六条件编译

有时编译程序时想添加一些编译选项，如-Wall，-std=c++11等，就可以使用add_compile_options来进行操作。
这里以一个简单程序来做演示。

6.1 简单程序

6.1.1 项目结构

6.1.2 示例代码

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)

6.1.3 运行查看

然后cd到build目录下，执行cmake … && make命令，就可以在bin目录下得到main的可执行文件

6.2 添加编译选项

有时希望在编译代码时只编译一些指定的源码，可以使用cmake的option命令，主要遇到的情况分为2种：

本来要生成多个bin或库文件，现在只想生成部分指定的bin或库文件
对于同一个bin文件，只想编译其中部分代码（使用宏来控制）

6.2.1 生成部分指定bin或库文件

6.2.1.1 项目结构

假设我们现在的工程会生成2个bin文件，main1和main2，项目结构如下：

6.2.1.2 示例源码

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，如下：

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

// main1.c
#include <stdio.h>

int main(void)

    printf("hello, this main1\\n");
    
    return 0;

main1.c

// main2.c
#include <stdio.h>

int main(void)

    printf("hello, this main2\\n");
    
    return 0;

6.2.1.3 运行查看

然后cd到build目录下输入cmake … && make就可以只编译出main1，如果想编译出main2，就把MYDEBUG设置为ON，再次输入cmake … && make重新编译。

每次想改变MYDEBUG时都需要去修改CMakeLists.txt，有点麻烦，其实可以通过cmake的命令行去操作，例如我们想把MYDEBUG设置为OFF，先cd到build目录，然后输入cmake … -DMYDEBUG=ON，这样就可以编译出main1和main2 （在bin目录下）

6.2.2 编译部分代码

假设我们有个main.c，其内容如下：

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值。

所以如果option有变化，要么删除上次执行cmake时产生的缓存文件，要么把所有的option都显式的指定其值。

总结

以上是自己学习CMake的一点学习记录，通过简单的例子让大家入门CMake，学习的同时也阅读了很多网友的博客。CMake的知识点还有很多，具体详情可以在网上搜索。总之，CMake可以让我们不用去编写复杂的Makefile，并且跨平台，是个非常强大并值得一学的工具。

如果有写的不对的地方，希望能留言指正，谢谢阅读。

初识Redis，看这一篇就够了

环境的搭建和安装网上有很多教程，在这里就不再重复了。

1. Redis是什么？

Redis（全称：Remote Dictionary Server 远程字典服务）是一个开源的使用ANSI C语言编写、支持网络、可基于内存亦可持久化的日志型、Key-Value数据库。

大家可能知道Redis是做缓存用的，它实际上也是一种数据库，可以对经常使用到的数据进行存储，也就是大家所说的缓存。

官方给出的数据是，Redis能达到10w+的QPS(每秒查询速度)。

为什么Redis的速度比Mysql等这种数据快呢？

因为Redis存储的是key-values格式的数据，时间复杂度是O(1)，即直接通过key查询对应的value。而如Mysql数据库，底层的实现是B+树，时间复杂度是O(logn)。

最重要的一点是，数据库的数据是存储在磁盘中的，而Redis是存储在内存当中的，它们的速度差距不言而喻。但Redis也支持持久化存储，这个后面的常见问题里会提到。

2. Redis数据类型

Redis支持5种数据类型：string（字符串）、hash（哈希）、list（列表，有序可重复）、set（集合，无序不可重复）、zset（有序集合，有序不可重复）。

Redis中所有数据都是字符串，key是区分大小写的。

1.string是最基本的类型，可以包含任何数据，但是string类型的值最大能存储512MB。

2.hash的value相当于一个map，value里面也有对应的key-value，特别适合存储对象。一个hash可以存储2^32-1个键值对，基本用不完。并且可以修改某一个属性值，所以一般用于存储用户或其他实体类的值。

3.list中的value按照插入顺序排序，可以在列表的头部和尾部添加新元素。一般用于最新消息的排行或消息队列。

4.set存放的是不重复值的集合，是无序的。并提供了求交集、并集、差集等操作，所以一般用于统计等功能。

5.与set不同的是，zset是通过分数（score）从小到达进行排序的，我们可以指定每个值的分数，分数可以重复。一般用于排行等功能。

3.Redis常用命令

基于对上面5种数据类型的了解，接着学习一下Redis常用命令。更多了命令学习，推荐大家看一看官方文档http://www.redis.cn/commands.html

1.对stirng的操作

redis命令不区分大小写。

下面命令中，str就是key，hello就是value，append为追加命令，如果原来没有str，就新建一个。

append str hello    //对key为str的键追加hello字符串
append str redis　　//str的value变为helloredis
set str1 1　  //set命令设置一个key的value值 str1是key，1是value
get str1　　 //get命令，获取一个key的值 
incr str1　 //incr命令，执行加1操作，比如str1的值会变成2，如果指定的key的value不能表示一个整数，就会返回一个错误
decr str1　 //减一操作

2.对hash的操作

上面说到过，hash的value相当于一个map，所以只设置值的时候myhash是key，h1是value里面的key，hello是h1的value

hset myhash h1 hello　　//设置一个key的value值
hget myhash h1　　//返回hello，myhash为key，h1是value里面的key，两个都需要指定
hlen myhash　　//获取myhash的字段数量，这里返回1
hkeys myhash　　//获取myhash所以字段，这里返回h1

3.对list的操作

mylst是key，a,b,c,d都是value，并且有顺序，所以实际存进去后是d,c,b,a

lpush mylist a b c d　　//lpush,从队列左边入队一个或多个元素
lrange mylist 0 -1　　//获取指定范围的值，从0开始，-1代表全部，注意这里返回d,c,b,a。
rpush mylist 1 2 3　　//从右边入队,再次lrange的话就是d,c,b,a,1,2,3
lpop mylist　　//从左边弹出一个元素，这里弹出d,此时的mylist就没有d了

4.对set的操作

如果我们添加了重复的元素，不会报错，但只会存一个。如a b b，只会存a b

两个集合之间不受影响，即key为myset和myset2两个集合里面都可以有a b

sadd myset a b c d　　//添加一个或多个元素到集合里面
smembers myset　　//获取集合里所有元素，输出是无序的，随机的。这里可能是b,d,c,a
srem myset a c　　//移除myset中的a和c元素，由于不可能重复也没顺序，所以可以直接指定元素值来移除

5.对zset的操作

myzset为key，a b c前面的数字就是score

zadd myzset 2 b 1 a 3 c　　//添加一个或多个元素
zrange myzset 0 -1　　//获取指定范围的值，0开始，-1代表全部。这里返回a,b,c

更多的命令可以看上面网站中的文档，写的非常详细，下面的常见问题中也会提及一些。

4.Redis常见问题

1.在大量的key中查询某一固定前缀的key

在实际的业务当中，key的命名是有规范的，比如缓存用户信息，key的前缀可能会是user。

现在有几千万条数据，查询user为前缀的key的话，第一下想到的可能会是keys命令

keys user*　　//user*为正则表达式

其时间复杂度为O(n)，虽然性能也算可以，但是在查询几千万条数据时明显太慢了，花上几分钟都不稀奇，而且在查询出来之前，可能会造成服务卡顿，占用大量内存，显然是不可取的。

那么这种情况就可以使用scan命令

下面的命令中，math count为可选项，可用可不用，所以需要显示的写出来。math意味后面会匹配一个正则表达式。count代表一次查询10条。

这个10条不是强制的，可能会比10条少。

scan 0 math user*  count 10　　//从0开始，查询user为前缀的key，一次查询10条并返回

执行上面一句话后，会返回两个东西，一个游标，代表执行到哪了，比如执行到了14325。返回的另一个就是user为前缀的key了。

下次再执行这条语句时，把0换成14325，接着上次的位置继续查询。但是游标不一定是递增的，也许下次的游标比这次还小，所以存在重复的隐患。

我们可以在业务代码处循环查询，记录每次返回的游标，并把查询的key存入到set当中，起到去重的效果。

scan，实际上就是分批查询，速度显然没有keys快，在查询大量数据时，不会对服务器造成压力。数据量不大时依旧推荐keys

2.利用Redis实现分布式锁

首先了解什么是分布式锁。即控制分布式系统访问共享资源的一种方式。

比如系统（或主机）A和B都需要访问资源DataA时，当A先访问到了DataA，这时候就需要分布式锁来把B挡住，防止A和B彼此干扰，保证数据的一致性。

额外提一点就是，Redis命令的操作是原子性的，原子性在数据库的事务中有体现，Redis的命令也是原子性的，要么执行要么不执行，不会出现一个命令执行到一半失败了，但还是改变了数据的问题。

实现分布式锁，需要解决一下几个问题：

1.互斥性，即任意时刻只能有一个客户端获取锁。

2.安全性，锁只能有持有它的客户端删除，不能由其他客户端删除。

3.死锁，即由于某些原因，一些客户端出现问题不能及时释放锁，导致其他客户端也不能获取锁。

4.容错，当某些Redis节点出现问题时，客户端也要能获取到锁。

我们可以用setnx实现锁的功能。语法：setnx key value

仅当key不存在时，才会设置成功。成功返回1，否则返回0。

1.在对应的访问资源的业务代码处，对指定的key设值，如果成功了，则代表没有其他线程执行过这段代码，也就是没有其他线程访问这个资源。

如果设值失败，就代表有其他线程占用该资源，就一直等待，直到setnx成功。

2.还有个问题就是，这个key是长期有效的，所以还需要用到expire命令，语法：expire key seconds,seconds单位为秒，用以设置对应key的过期时间。

上面两步似乎好像是实现了锁的功能，但是缺陷也非常明显，如果成功设值后，在我设置时间之前客户端就出现问题了怎么办？用两个命令实现一个功能有悖于Redis的原子性。

在Redis2.6.12版本开始，set有两个参数，就是实现了以上两个功能。虽然上面两步分开的做法是错的，但是思路是一样的。

具体语法：set key value ex 10 nx。ex代表过期时间，这里设置10秒过期，nx代表key是要唯一的，即一个命令实现了以上两个步骤。

最后还有一个小问题，如果不同资源同时设置了锁key，过期时间也是一样的，到期后Redis同时删除大量key时，难免会出现卡顿。

解决方法就是在设置过期值时加上随机值。

3.利用Redis实现消息队列

消息队列，简称MQ，即消息和队列两个单词的首字母缩写。常见的消息队列有RabbitMQ和RocketMQ等，利用Redis实现消息队列只是熟悉下其特点，实际当中一般会使用专门的消息队列中间件。

如果之前没了解过消息队列，建议搜索一下消息队列相关知识进行一下简单的学习。

简单地说，消息队列的作用就是接受客户端的请求，然后对这些请求依次处理，一般应用请求量特别大时，比如秒杀抢购等。上面介绍数据类型时就说到了list一般用于消息队列。

看一下list的常见操作，虽然叫做列表，但其特点和数据结构的队列基本一模一样。所以在用Redis实现消息队列时，首先肯定会想到list。

1.利用list的话，仿佛使用rpush生产消息，lpop消费消息就行了。但是有一个小问题，lpop不会等待rpush的，当rpush还没来得及生成数据时，这时lpop会直接返回null的。

2.既然要等待rpush生成数据，难免又会想到一个命令blpop,其语法为：blpop key seconds。和lpop功能一样，但是会等待指定的时间，这段时间内rpush如果生成数据的话，blpop会及时返回。

3.但是blpop的缺点也很明显，当然这个缺点也存在于lpop当中，就是blpop执行完后，代表出队，rpush生成的这条消息就没了，而消息队列中有的需求是需要多个消费者去接收的。

这时候就可以用上Redis的订阅者模式，Redis客户端可以订阅任意数量的频道(Topic)

在Redis当中用subscribe命令订阅一个频道，语法subscribe topic，topic就是自定义的频道名称，注意是topic不是key，不需要事先定义，直接订阅就行了。

然后用publish生产消息，语法publish topic value,topic就是你想发布到哪个频道，value就是数据内容，而订阅了这个频道的所有消费者都会接收到消息。注意是及时收到，不需要你再去手动用命令获取。

订阅者模式，的确解决了以上两种方法的缺点，但是其缺陷也很明显，就是只有处于订阅者模式，也就是监听状态下，消费者才会接受到生产者的消息，也就是及时发送及时接收的，一旦Redis客户端下线，就永远不会接收到这个消息了。

这就回到了前面说到的一句话，实际当中会使用专门的消息队列中间件来说实现这些功能，以上三种方法或多或少可以实现消息队列的功能，但是缺陷也非常明显。

4.Redis如何做持久化

Redis是基于内存当中的，那么肯定就会有疑问了，当我关闭主机或者关闭了Redis，那Redis的数据是不是就全没了。

持久化的作用就是，把Redis的数据存储到磁盘当中，以免Redis的数据丢失。

Redis有两种持久化机制，默认的一种是RDB,另一种是AOF。

1.RDB(快照)持久化会在某个时间点保存全量的数据，快照即针对内存进行的快速读取技术。而这个时间点可以由我们的实际业务进行时间策略配置。

RDB会按照时间周期策略对数据以快照的方式保存到磁盘里，并产生一个dump.rdb的二进制文件。我们可以在redis.conf配置文件中save参数查看和配置时间策略。

dump.rdb文件是如何创建的呢？rdb文件可以通过两个命令创建，一个是save,一个是bgsave。要注意这里的save是redis命令，上面提到的save是配置文件里面的参数。

save命令会阻塞Redis服务器进程，直到rdb文件创建完成，一般很少使用。

bgsave命令会fork出一个子进程来创建rdb文件，不会阻塞服务器进程。fork即创建一个与父进程几乎一样的子进程。

bgsave的基本原理：当我们使用bgsave命令时，首先会检查是否存在RDB/AOF子进程正在进行，有的话就返回错误，即当我们第一次执行了bgsave，在执行完之前其他的bgsave会被拒绝执行。

如果没有正在进行的子进程，就会调用redis源码里面的rdbSaveBackground这个方法，然后利用fork创建一个子进程。

RDB的缺点：

　　1.1.前面提到，在某个时间点会进行全量数据保存，数据量大的话由于I/O而严重影响到性能。

　　1.2.由于RDB是根据配置文件里面的时间策略进行保存的，如果发生意外情况，那么上次保存到当前时间段内的数据会发生丢失。

2.AOF(Append-Only-File)持久化会以追加的方式（append）保存除了查询指令以外所有变更的数据，其默认的文件名称为appendonly.aof。

AOF持久化默认是关闭的，我们可以在配置文件当中找到appendonly参数，把它的参数内容改为yes。

前面说到AOF文件会记录所有非查询的所有指令，最后肯定难以避免文件不断增大的问题，最主要的问题是记录的很多数据是不必要的。

比如循环更新一个数100次，AOF会记录这100个过程，而我们只需要最终结果就行了。

所以，Redis提供了一个日志重写的功能解决文件不断增大的问题，可以用BGREWRITEAOF命令手动执行。日志重写在服务不中断的情况下也能执行，其基本原理如下：

1.使用fork创建一个子进程。2.子进程把新的AOF写道一个临时文件里，并不会依赖现有的AOF文件，只需要读取内存中的数据。这里就优化了很多不必要的数据。

3.主进程这时候会依旧将新的变动写到内存里，也会写到现有的AOF文件里，即使子进程重写失败，数据也不会丢失。4.主进程获取到子进程AOF重写完成的信号后，会把新的变动追加到新的AOF文件里。

5.最后使用新的AOF文件替换掉原来的AOF文件。

如果启用了AOF持久化，Redis启动时会先检查AOF文件是否存在，如果存在就直接加载AOF文件，如果不存在就检查RDB文件是否存在，如果存在就加载，不存在就直接启动Redis。

在Redis4.0之后，推出了RDB-AOF混合持久化方式并作为默认方式，RDB全量保存，AOF增量保存，集成了它们各自的优点。

5.SpringBoot整合Redis

首先在依赖项里面添加redis启动器

spring-boot-starter-data-redis

然后在配置文件里面进行相关的配置，更多的配置可以看RedisProperties.java源码查看。

spring.redis.host=127.0.0.1    #redis地址
spring.redis.port=6379    #redis服务端口号

最后注入相关的类

//操作的是复杂类型，比如各种实体类
@Autowired
RedisTemplate redisTemplate

//操作的是字符串
@Autowired
StringRedisTemplate stringRedisTemplate

SpringBoot框架下对Redis的操作不像Jedis那样可以直接使用原生的Redis命令，具体的API大家可以自行搜索相关的文档。

不过推荐使用一些SpringBoot的Redis工具类，工具类会对RedisTemplate和StringRedisTemplate的方法进行封装，而封装后的方法名和Redis原生命令是一样的。

以上是关于C++Cmake使用教程（看这一篇就够了）的主要内容，如果未能解决你的问题，请参考以下文章

Visual Studio常用快捷键看这一篇就够了

C++Cmake使用教程（看这一篇就够了）

文章目录

引言

一 环境搭建

二 简单入门

2.1 项目结构

2.2 示例源码

2.3 运行查看

三 编译多个源文件

3.1 在同一个目录下有多个源文件

3.1.1 简单版本

3.1.1.1 项目结构

3.1.1.2 示例代码

3.1.1.3 运行查看

3.1.2 进阶版本

3.1.2.1 项目结构

3.1.2.2 示例源码

3.1.2.3 运行查看

3.2 在不同目录下有多个源文件

3.2.1 项目结构

3.2.2 示例源码

3.2.2 运行查看

四 项目级的组织结构

4.1 项目结构

4.2 示例源码

4.3 运行查看

五 动态库和静态库的编译控制

5.1 生成库文件

5.1.1 项目结构

5.1.2 示例源码

5.1.3 运行查看

5.2 链接库文件

5.2.1 项目结构

5.2.2 示例源码

5.2.3 运行查看

六 条件编译

6.1 简单程序

6.1.1 项目结构

6.1.2 示例代码

6.1.3 运行查看

6.2 添加编译选项

6.2.1 生成部分指定bin或库文件

6.2.1.1 项目结构

6.2.1.2 示例源码

6.2.1.3 运行查看

6.2.2 编译部分代码

总结

初识Redis，看这一篇就够了

1. Redis是什么？

2. Redis数据类型

3.Redis常用命令

1.对stirng的操作

2.对hash的操作

3.对list的操作

4.对set的操作

5.对zset的操作

4.Redis常见问题

1.在大量的key中查询某一固定前缀的key

2.利用Redis实现分布式锁

3.利用Redis实现消息队列

4.Redis如何做持久化

5.SpringBoot整合Redis

一环境搭建

二简单入门

三编译多个源文件

四项目级的组织结构

五动态库和静态库的编译控制

六条件编译