C++编写Redis客户端

目录

安装redis-plus-plus库

​编辑

编译C++redis客户端

redis的通用命令使用 

get/set

exists

del

keys

expire /ttl

type

string类型核心操作 

set和get

set带有超时时间

set带有NX

string带有XX

mset

mget

getrange和setrange

incr和decr 

list类型核心操作

lpush和lrange

 lpop和rpop

brpop

llen

set类型核心操作

sadd和smembers

sismember

 scard

spop

sinter

sinterstore

hash类型核心操作

hset和hget

 hexists和hdel和hlen

hmset和hmget

hkeys hvals

zset类型核心操作

zadd和zrange

zscore 

zrank

---

安装redis-plus-plus库

C++操作redis的库有很多，这里使用redis-plus-plus，我们需要在githb上下载。

github地址：GitHub - sewenew/redis-plus-plus: Redis client written in C++

github在国内的时候有时候会抽风，网不好，怎么呢？fq当然可以打开github，但fq是违法行为。

那有没有合法的方式打开呢？我们可以下载Watt Toolkit软件，这玩意其实就是一个游戏加速器。

 打开之后点击网络加速，这里面可以对github进行加速。

打开github后往下面翻，可以看到下载，要下载redis-plus-plus要先安装hiredis。

 安装hiredis

ubuntu

apt install libhiredis-dev

 

 安装redis-plus-plus

下载redis-plus-plus源

git clone https://github.com/sewenew/redis-plus-plus.git

安装好源之后，按照下面的命令执行即可 

cd redis-plus-plus

mkdir build  // 创建一个 build、 目录是习惯用法，让编译临时生成的文件放在改目录下

cd build

cmake ..      // 生成makefile

make           // 进行编译

make install // 把库考到系统目录

cd ..

安装完毕后，头文件会装到 /usr/local/include/sw/的redis++。

编译C++redis客户端

要写redis代码需要包含一下头文件<sw/redis++/redis++.h>。

当我们创建好Redis对象之后，执行的各种命令，其实就是该类中调用各种方法即可。

#include <iostream>
#include <string>
#include <vector>
#include <unordered_map>
#include <sw/redis++/redis++.h>

using  namespace std;


int main()
{
    // 创建redis对象的时候需要再构造函数中指定 redis 服务器的地址和端口 由于我们redis客户端和服务器在同一个主机，写本地回环即可
    sw::redis::Redis redis("tcp://127.0.0.1:6379"); // 如果是不同主机，就写对应主机的ip即可，6379是端口号
    // 测试是否连接成功 让客户端给服务器发送一个 ping 服务器会返回一个 PONG，通过返回值获取到
    string result = redis.ping();
    cout << result << endl;
    return 0;

}

使用makefile编译文件

编译程序的时候，需要引入库文件。

1. redis++自己的静态库  

我们可以使用find命令查找。

/usr/local/lib/libredis++.a

2.hiredis的静态库

/usr/lib/x86_64-linux-gnu/libhiredis.a 

3.线程库 

-pthread直接写就可以

hello:01.hello.cc
	g++ -o $@ $^ -std=c++17 /usr/local/lib/libredis++.a  /usr/lib/x86_64-linux-gnu/libhiredis.a -pthread

.PHONY:clean
clean:
	rm -f hello

redis的通用命令使用 

如果会使用redis的命令，那么使用C++编写redis客户端是非常简单的，很多都是接口都是一样的设计，命令的参数怎么写的的函数的参数就怎么传递就行。下面我并不会介绍每个函数的作用是啥，因为默认各位都是对命令了然于胸的，如果看到哪一个命令想不起来它的作用，随便上网查一下即可，或者是看下代码应该就能想起来，并且我不会把所有的命令都写出来，因为有些命令是非常简单的。

get/set

void test1(sw::redis::Redis &redis)
{
    cout << "get 和 set 的使用" << endl;

    // 1.清空一下数据库，以免影响我们使用
    redis.flushall();

    // 使用 set 设置 key
    redis.set("key1", "111");
    redis.set("key2", "222");
    redis.set("key3", "333");

    // 使用 get 获取 key
    // get的返回值是sw::redis::OptionalString类型
    auto value1 = redis.get("key1");
    // optional 可以隐式转换成 bool 类型，可以直接在 if中判断，如果是无效元素，就返回false
    // 使用之前判断是否存在
    if (value1)
    {
        // get的返回值是sw::redis::OptionalString类型，cout不支持该类型的运算符重载
        // 此处把sw::redis::OptionalString里面包含的值取出来就行，OptionalString只包含一个元素的容器
        // 可以使用value()方法取出来
        cout << "key1: " << value1.value() << endl;
    }

    auto value2 = redis.get("key2");
    if (value2)
    {
        cout << "key2: " << value2.value() << endl;
    }

    auto value3 = redis.get("key3");
    if (value3)
    {
        cout << "key3: " << value3.value() << endl;
    }

    // redis中并不存在key4
    auto value4 = redis.get("key4");
    if (value4)
    {
        cout << "key4: " << value4.value() << endl;
    }
}

 

exists

// exists
void test2(sw::redis::Redis &redis)
{
    cout << "exists" << endl;
    // 1.清空一下数据库，以免影响我们使用
    redis.flushall();

    // 使用 set 设置 key
    redis.set("key1", "111");

    // 存在的key
    // 返回值是一个long long类型，表示有几个key存在
    auto ret = redis.exists("key1");
    cout << ret << endl;
    // 不存在的key
    ret = redis.exists("key2");
    cout << ret << endl;
    // 判定多个 key
    redis.set("key3", "333");
    ret = redis.exists({"key1", "key2", "key3"});
    cout << ret << endl;
}

del

void test3(sw::redis::Redis &redis)
{
    cout << "del" << endl;
    // 1.清空一下数据库，以免影响我们使用
    redis.flushall();
    // 使用 set 设置 key
    redis.set("key1", "111");
    redis.set("key2", "222");

    // 删除一个key
    // 返回值是成功删除的个数
    auto ret = redis.del("key1");
    cout << ret << endl; // key1 存在返回值为1 表示删除1个
    // 删除多个key
    ret = redis.del({"key2", "key3"});
    cout << ret << endl; // key2 存在 key3 不存在 返回值2 表示删除2个

    // 判定被删除的key是否存在
    ret = redis.exists({"key1", "key2"}); // key1 key2都被删除了，因此存在个数0
    cout << ret << endl;
}

keys

void test4(sw::redis::Redis &redis)
{
    cout << "keys" << endl;
    // 1.清空一下数据库，以免影响我们使用
    redis.flushall();
    // 使用 set 设置 key
    redis.set("key1", "111");
    redis.set("key2", "222");
    redis.set("key3", "333");
    redis.set("key4", "444");
    redis.set("key5", "555");
    redis.set("key6", "666");
    // keys第一个参数匹配规则
    // keys第二个参数是一个"插入迭代器"，需要先准备好一个保存结果的容器
    // 接下来在创建一个插入迭代器指向容器的位置，就可以吧keys获取到的结果依次通过刚才的插入迭代器插入到容器指定位置中
    vector<string> v;
    // 这个auto的类型是 back_inserter<std::vector<std::string>>
    // 此处的it就指向v的起始地址
    auto it = back_inserter(v);
    // 这个地方是把keys查询的所有结果插入到v这个容器中
    redis.keys("*", it);
    // keys查询的key都放到v这个容器中
    // 遍历vector，查看结果
    for (auto &elem : v)
    {
        cout << elem << endl;
    }
}

expire /ttl

void test5(sw::redis::Redis &redis)
{
    cout << "expire and ttl" << endl;
    // 1.清空一下数据库，以免影响我们使用
    redis.flushall();
    // 使用 set 设置 key
    redis.set("key1", "111");
    // 设置key的过期时间
    redis.expire("key1", 10);                  // 这里可以直接跟字面值表示10s
    redis.expire("key1", chrono::seconds(10)); // 建议使用chrono的库函数，更加直观

    // 先休眠一会再查看过期时间
    this_thread::sleep_for(chrono::seconds(5)); // 休眠5s

    // 获取key的过期时间
    long long time = redis.ttl("key1");
    cout << time << endl; // 5s后，key1的过期时间还剩5s
}

type

void test6(sw::redis::Redis &redis)
{
    cout << "type" << endl;
    // 1.清空一下数据库
    redis.flushall();
    // 2. string 类型
    redis.set("key1", "111");
    string type = redis.type("key1");
    cout << "key1: " << type << endl;
    // 3. list 类型
    redis.lpush("key2", "111");
    type = redis.type("key2");
    cout << "key2: " << type << endl;
    // 4. hash 类型
    redis.hset("key3", "field1", "111");
    type = redis.type("key3");
    cout << "key3: " << type << endl;
    // 5. set 类型
    redis.sadd("key4", "111");
    type = redis.type("key4");
    cout << "key4: " << type << endl;
    // 6. zset 类型
    redis.zadd("key5", "吕布", 99);
    type = redis.type("key5");
    cout << "key5: " << type << endl;
}

string类型核心操作 

set和get

void test1(sw::redis::Redis &redis)
{
    cout << "get 和 set 的使用" << endl;
    // 1.清空一下数据库，以免影响我们使用
    redis.flushall();

    redis.set("key", "111");
    // value是optionalString类型，需要使用value()方法取出来
    auto value = redis.get("key");
    if (value)
    {
        std::cout << "value: " << value.value() << std::endl;
    }

    // 修改key的value
    redis.set("key", "222");
    value = redis.get("key");
    if (value)
    {
        std::cout << "value: " << value.value() << std::endl;
    }

}

set带有超时时间

void test2(sw::redis::Redis &redis)
{
    cout << "set 带有超时时间" << endl;
    // 1.清空一下数据库，以免影响我们使用
    redis.flushall();

    // 给key设置超时时间为9s
    redis.set("key", "111", chrono::seconds(9));
    // 休息6s
    this_thread::sleep_for(chrono::seconds(6));
    // 获取超时时间
    auto time = redis.ttl("key");
    cout << "time: " << time << endl;
}

 

set带有NX

void test3(sw::redis::Redis &redis)
{
    cout << "set NX 和 XX" << endl;
    // 1.清空一下数据库，以免影响我们使用
    redis.flushall();

    // 包含该命名空间可以直接使用 0s 这样的字面值常量
    using namespace std::chrono_literals;

    // set的重载版本中，没有单独提供 NX 和 XX版本，必须搭配过期时间使用，不需要过期时间就设置为0s
    // 不存在就设定
    redis.set("key", "111", 0s, sw::redis::UpdateType::NOT_EXIST);

    auto value = redis.get("key");
    if (value)
    {
        cout << "value: " << value.value() << endl;
    }
    else
    {
        cout << "key 不存在!" << endl;
    }
}

void test3(sw::redis::Redis &redis)
{
    cout << "set NX 和 XX" << endl;
    // 1.清空一下数据库，以免影响我们使用
    redis.flushall();

    // 包含该命名空间可以直接使用 0s 这样的字面值常量
    using namespace std::chrono_literals;

    redis.set("key", "111");
    // set的重载版本中，没有单独提供 NX 和 XX版本，必须搭配过期时间使用，不需要过期时间就设置为0s
    // 上面已经设置了key，所有下面set不会设置成功
    redis.set("key", "222", 0s, sw::redis::UpdateType::NOT_EXIST);

    auto value = redis.get("key");
    if (value)
    {
        // 打印的结果是111
        cout << "value: " << value.value() << endl;
    }
    else
    {
        cout << "key 不存在!" << endl;
    }
}

string带有XX

void test3(sw::redis::Redis &redis)
{
    cout << "set NX 和 XX" << endl;
    // 1.清空一下数据库，以免影响我们使用
    redis.flushall();

    // 包含该命名空间可以直接使用 0s 这样的字面值常量
    using namespace std::chrono_literals;

    redis.set("key", "111");
    // set的重载版本中，没有单独提供 NX 和 XX版本，必须搭配过期时间使用，不需要过期时间就设置为0s
    // 已经存在才能设置成功，上面存在，因此可以设置成功
    redis.set("key", "222", 0s, sw::redis::UpdateType::EXIST);

    auto value = redis.get("key");
    if (value)
    {
        // 打印的结果是222
        cout << "value: " << value.value() << endl;
    }
    else
    {
        cout << "key 不存在!" << endl;
    }
}

mset

void test4(sw::redis::Redis &redis)
{
    cout << "mset" << endl;

    redis.flushall();

    // 第一种写法，使用初始化列表描述多个键值对
    redis.mset({make_pair("key1", "111"),
                make_pair("key2", "222")});
    // 第二种写法，把多个键值对提前放到容器中，以迭代器的形式告诉mset
    vector<pair<string, string>> keys;
    keys.push_back(make_pair("key3", "333"));
    keys.push_back(make_pair("key4", "444"));

    redis.mset(keys.begin(), keys.end());

    auto value = redis.get("key1");
    if (value)
    {
        cout << "value: " << value.value() << endl;
    }

    value = redis.get("key2");
    if (value)
    {
        cout << "value: " << value.value() << endl;
    }

    value = redis.get("key3");
    if (value)
    {
        cout << "value: " << value.value() << endl;
    }

    value = redis.get("key4");
    if (value)
    {
        cout << "value: " << value.value() << endl;
    }
}

mget

void test5(sw::redis::Redis &redis)
{
    cout << "mget" << endl;
    redis.flushall();

    vector<pair<string, string>> keys;
    keys.push_back(make_pair("key1", "111"));
    keys.push_back(make_pair("key2", "222"));
    keys.push_back(make_pair("key3", "333"));

    redis.mset(keys.begin(), keys.end());

    vector<sw::redis::OptionalString> values;
    auto it = std::back_inserter(values);


    redis.mget({"key1", "key2", "key3", "key4"}, it);

    for (auto &elem : values)
    {
        if (elem)
            cout << elem.value() << endl;
        else
            cout << "元素无效" << endl;
    }
}

getrange和setrange

void test6(sw::redis::Redis &redis)
{
    cout << "getrange and setrange " << endl;
    redis.flushall();

    redis.set("key", "hello world");
    // 获取到下标2-5的字符
    string ret = redis.getrange("key", 2, 5);
    cout << "ret: " << ret << endl;

    // 将下标2后面的字符修改为music
    redis.setrange("key", 2, "music");

    auto value = redis.get("key");
    if (value)
        cout << "value: " << value.value() << endl;
}

incr和decr 

void test7(sw::redis::Redis &redis)
{
    cout << "incr end decr" << endl;
    redis.flushall();

    redis.set("key", "100");

    // 自增
    long long ret = redis.incr("key");
    auto value = redis.get("key");
    if (value)
        cout << "value: " << value.value() << endl;

    // 自减
    ret = redis.decr("key");
    value = redis.get("key");
    if (value)
        cout << "value: " << value.value() << endl;
}

list类型核心操作

lpush和lrange

void test1(Redis &redis)
{
    cout << "lpush 和 lrange" << endl;
    redis.flushall();

    //  插入单个元素
    redis.lpush("key", "111");
    // 插入一组元素，基于初始化列表
    redis.lpush("key", {"222", "333", "444"});
    // 插入一组元素，基于迭代器
    vector<string> values = {"555", "666", "777"};
    redis.lpush("key", values.begin(), values.end());

    // lrange 获取到列表中的元素
    vector<string> results;
    auto it = std::back_inserter(results);
    redis.lrange("key", 0, -1, it);

    for (auto &elem : results)
    {
        cout << elem << endl;
    }
}

lpush是头插，因此越后面的元素在前面。 rpush和lpush的用法是一模一样的，这里就不介绍了。

 lpop和rpop

void test3(Redis &redis)
{
    cout << "lpop 和 rpop" << endl;
    redis.flushall();
    // 构造一个 list
    redis.rpush("key", {"111", "222", "333", "444", "555"});

    // lpop 从左边弹出一个元素
    auto value = redis.lpop("key");
    if (value)
        cout << value.value() << endl;
    // rpop 从右边弹出一个元素
    value = redis.rpop("key");
    if (value)
        cout << value.value() << endl;
}

brpop

阻塞删除一个key

void test4(Redis &redis)
{
    cout << "blpop" << endl;
    redis.flushall();

    // key不存在一定会阻塞
    // 返回值是 OptionalStringPair 是一个pair
    // pair的first是来自哪一个key
    // pair的second是哪个元素被删了
    auto result = redis.blpop("key");
    if (result)
    {
        cout << "key:" << result.value().first << endl;
        cout << "elem:" << result.value().second << endl;
    }
    else
    {
        cout << "result 无效!" << endl;
    }
}

阻塞删除多个key 并设置超时时间

void test4(Redis &redis)
{
    using namespace std::chrono_literals;
    cout << "blpop" << endl;
    redis.flushall();

    // key不存在一定会阻塞
    // 返回值是 OptionalStringPair 是一个pair
    // pair的first是来自哪一个key
    // pair的second是哪个元素被删了
    auto result = redis.blpop({"key", "key1", "key2"}, 10s);
    if (result)
    {
        cout << "key:" << result.value().first << endl;
        cout << "elem:" << result.value().second << endl;
    }
    else
    {
        cout << "result 无效!" << endl;
    }
}

llen

void test5(Redis &redis)
{
    cout << "llen" << endl;
    redis.flushall();

    redis.lpush("key", {"111", "222", "333", "444", "555"});
    long long len = redis.llen("key");
    cout << "len: " << len << endl;
}

redis-plus-plus这个库，接口风格设计是非常统一的。

当一个函数，参数需要传递多个值的时候，往往都是支持初始化列表或者是一对迭代器的方式来进行实现。

当一个函数，返回值需要表示多个数据的时候，往往也会借助插入迭代器，来实现往一个容器中添加元素的效果。

当某些场景涉及到无效值的时候，往往会搭配std::optional来进行使用。

set类型核心操作

sadd和smembers

void test1(Redis &redis)
{
    cout << "sadd 和 smembers" << endl;
    redis.flushall();

    // 一次添加一个元素
    redis.sadd("key", "111");
    // 一次添加多个元素 使用初始化列表
    redis.sadd("key", {"222", "333", "444"});

    // 一次添加多个元素 使用迭代器
    // 使用什么容器都可以，set、vector、list...
    set<string> elems = {"555", "666", "777"};
    redis.sadd("key", elems.begin(), elems.end());

    // 获取集合中的所有元素
    vector<string> result;
    auto it = std::back_inserter(result);
    redis.smembers("key", it);

    for (auto &e : result)
    {
        cout << e << endl;
    }
}

sismember

void test2(Redis &redis)
{
    cout << "sismember" << endl;
    redis.flushall();
    redis.sadd("key", {"111", "222", "333"});

    // 判断元素是否存在
    bool ret1 = redis.sismember("key", "111");
    bool ret2 = redis.sismember("key", "444");
    cout << "ret1: " << ret1 << endl;
    cout << "ret2: " << ret2 << endl;
}

 scard

void test3(Redis &redis)
{
    cout << "scard" << endl;
    redis.flushall();
    redis.sadd("key", {"111", "222", "333"});
    // 获取集合中元素的个数
    int ret = redis.scard("key");
    cout << "ret: " << ret << endl;
}

spop

void test4(Redis &redis)
{
    cout << "spop" << endl;
    redis.flushall();
    redis.sadd("key", {"111", "222", "333"});

    // 随机删除元素
    auto result = redis.spop("key");
    if (result)
    {
        cout << "result: " << result.value() << endl;
    }
    else
    {
        cout << "result 无效 !" << endl;
    }
}

sinter

void test5(Redis &redis)
{
    cout << "sinter" << endl;
    redis.flushall();

    redis.sadd("key1", {"111", "222", "333"});
    redis.sadd("key2", {"111", "222", "444"});

    set<string> result;
    auto it = std::inserter(result, result.end());
    redis.sinter({"key1", "key2"}, it);
    for (auto &e : result)
    {
        cout << e << endl;
    }
}

 

sinterstore

void test6(Redis &redis)
{
    cout << "sinterstore" << endl;
    redis.flushall();

    redis.sadd("key1", {"111", "222", "333"});
    redis.sadd("key2", {"111", "222", "444"});

    long long len = redis.sinterstore("key3", {"key1", "key2"});
    cout << "len: " << len << endl;
    set<string> result;
    auto it = std::inserter(result, result.end());
    redis.smembers("key3", it);

    for (auto &e : result)
    {
        cout << e << endl;
    }
}

求并集和求交集基本一致，不多赘述。

hash类型核心操作

hset和hget

void test1(Redis &redis)
{
    cout << "hset 和 hget" << endl;
    redis.flushall();

    // 一次添加一个元素
    redis.hset("key", "f1", "111");
    redis.hset("key", make_pair("f2", "222"));
    // 一次添加多个元素(初始化列表)
    redis.hset("key", {make_pair("f3", "333"), make_pair("f4", "444")});
    // 一次添加多个元素(迭代器)
    vector<pair<string, string>> fileds = {make_pair("f5", "555"), make_pair("f6", "666")};
    redis.hset("key", fileds.begin(), fileds.end());


    auto value = redis.hget("key", "f1");
    if (value)
    {
        cout << value.value() << endl;
    }
}

 hexists和hdel和hlen

void test2(Redis &redis)
{
    cout << "hexists hdel hlen" << endl;
    redis.flushall();

    redis.hset("key", "f1", "111");
    redis.hset("key", "f2", "222");
    redis.hset("key", "f3", "333");

    bool ret1 = redis.hexists("key", "f1");
    bool ret2 = redis.hexists("key", "f3");
    cout << "ret1: " << ret1 << endl;
    cout << "ret2: " << ret2 << endl;

    // 一次删除一个filed
    long long r = redis.hdel("key", "f1");
    cout << "删除了" << r << "个" << endl;
    // 一次删除多个filed
    r = redis.hdel("key", {"f2", "f3"});
    cout << "删除了" << r << "个" << endl;

    long long len = redis.hlen("key");
    cout << "len: " << len << endl;
}

hmset和hmget

void test4(Redis &redis)
{
    cout << "hmset hmget" << endl;
    redis.flushall();

    // 初始化列表
    redis.hmset("key", {make_pair("f1", "111"), make_pair("f2", "222")});
    // 迭代器
    vector<pair<string, string>> filed = {make_pair("f3", "333"), make_pair("f4", "444")};
    redis.hmset("key", filed.begin(), filed.end());

    vector<string> result;
    auto it = std::back_inserter(result);
    redis.hmget("key", {"f1", "f2", "f3"}, it);
    for (auto &e : result)
        cout << e << endl;
}

hkeys hvals

void test3(Redis &redis)
{
    cout << "heys 和 hvals" << endl;
    redis.flushall();

    redis.hset("key", "f1", "111");
    redis.hset("key", "f2", "222");
    redis.hset("key", "f3", "333");

    vector<string> fileds;
    auto itfileds = std::back_inserter(fileds);
    redis.hkeys("key", itfileds);
    for (auto &e : fileds)
        cout << e << endl;

    vector<string> values;
    auto itvalues = std::back_inserter(values);
    redis.hvals("key", itvalues);
    for (auto &e : values)
        cout << e << endl;
}

zset类型核心操作

zadd和zrange

oid test1(Redis &redis)
{
    cout << "zadd 和 zrange" << endl;
    redis.flushall();

    redis.zadd("key", "吕布", 99);
    redis.zadd("key", {make_pair("赵云", 98),
                       make_pair("关羽", 97)});
    vector<pair<string, double>> members;
    members.push_back(make_pair("张飞", 96));
    members.push_back(make_pair("马超", 95));
    redis.zadd("key", members.begin(), members.end());
    // zrange支持两种风格的查询:
    // 1.只查询member，不带score
    // 2.查询member 带 score
    // 关键在于迭代器指向的是只包含一个string，就只包含memeber
    // 迭代器指向的是一个 pair，里面包含了 string double 就查询member和score
    vector<string> memberResults;
    auto it = std::back_inserter(memberResults);
    redis.zrange("key", 0, -1, it);
    for (auto &m : memberResults)
        cout << m << endl;

    vector<pair<string, double>> membersWithScore;
    auto it2 = std::back_inserter(membersWithScore);
    redis.zrange("key", 0, -1, it2);
    for (auto &m : membersWithScore)
        cout << m.first << " " << m.second << endl;
}

zcar和zrem

void test2(Redis &redis)
{
    cout << "zcard 和 zrem" << endl;
    redis.flushall();

    redis.zadd("key", "music", 99);
    redis.zadd("key", "english", 69);
    redis.zadd("key", "math", 98);

    redis.zrem("key", "english");

    long long len = redis.zcard("key");
    cout << "len: " << len << endl;
}

zscore 

void test3(Redis &redis)
{
    cout << "zscore" << endl;
    redis.flushall();

    redis.zadd("key", "music", 99);
    redis.zadd("key", "english", 69);
    redis.zadd("key", "math", 98);

    auto score = redis.zscore("key", "music");
    if (score)
    {
        cout << "score: " << score.value() << endl;
    }
    else
    {
        cout << "score 无效！" << endl;
    }
}

zrank

void test4(Redis &redis)
{
    cout << "zrank" << endl;
    redis.flushall();

    redis.zadd("key", "music", 99);
    redis.zadd("key", "english", 69);
    redis.zadd("key", "math", 98);

    auto rank = redis.zrank("key", "music");
    if (rank)
    {
        cout << "rank: " << rank.value() << endl;
    }
    else
    {
        cout << "rank 无效！" << endl;
    }
}