# Redis-cplus-cplus-Parser

**Repository Path**: yingke-software-association/redis-cplus-cplus-parse

## Basic Information

- **Project Name**: Redis-cplus-cplus-Parser
- **Description**: 帮助C++开发者快速入门redis-cplus-cplus
- **Primary Language**: Unknown
- **License**: Not specified
- **Default Branch**: master
- **Homepage**: None
- **GVP Project**: No

## Statistics

- **Stars**: 0
- **Forks**: 1
- **Created**: 2025-04-15
- **Last Updated**: 2025-05-04

## Categories & Tags

**Categories**: Uncategorized

**Tags**: None

## README

# Redis-cplus-cplus库使用指南

## 项目宗旨
本项目旨在帮助C++开发者快速掌握Redis-cplus-cplus库的基本使用。

## 安装步骤

### 安装redis-cplus-cplus库（Linux环境）
```bash
git clone https://github.com/sewenew/redis-plus-plus.git
```

### 安装依赖库（Linux环境）
#### Ubuntu系统
```bash
apt install libhiredis-dev
```
#### CentOS系统
```bash
yum install hiredis-devel.x86_64
```

### 编译安装redis-cplus-cplus
```bash
cd redis-plus-plus
mkdir build
cd build
cmake ..
make
sudo make install
```

### 安装结果查询
若完成上述操作，可查询当前系统存放redis++各种库的路径：
```bash
find /usr -name 'redis++*'
```
查询hiredis库路径：
```bash
find /usr -name 'libhiredis*'
```

## 编译技巧
编译使用了redis相关接口的程序时，需要指定链接的静态库redis和libhiredis。

以Ubuntu 22.04为例，redis的静态库路径为：`/usr/local/lib/libredis++.a`，libhiredis的路径为：`/usr/lib/x86_64-linux-gnu/libhiredis.a` ，当然你也可以使用`find`命令查找路径。

### 建立软链接
在项目目录中，建立redis静态库的软链接：
```bash
ln -s /usr/local/lib/libredis++.a libredis.a
```
建立hiredis静态库的软链接：
```bash
ln -s /usr/lib/x86_64-linux-gnu/libhiredis.a libhiredis.a
```
编译Makefile时可以缩短`-l`路径。

### 删除软链接
```bash
unlink 软连接名称
```

### 引入redis++头文件
路径：`/usr/local/include/sw/redis++/redis++.h`

## Redis基本操作

### set和get
#### 函数原型
```cpp
// set函数原型
QueuedRedis& set(const StringView &key, const StringView &val, ...);
// get函数原型
OptionalString get(const sw::redis::StringView &key);
```
无需关注`...`代表的参数，可以缺省，暂时不关注。

#### 参数介绍
`key` 是redis的命令`set`后跟的键，`val` 同理，用于设置键值对，类型为`string`。

#### 示例代码
```cpp
#include <iostream>
#include <sw/redis++/redis++.h>

int main() {
    sw::redis::Redis redis("tcp://127.0.0.1:6379");
    std::string result = redis.ping();
    std::cout << result << std::endl;
    redis.flushall();
    {
        printf("开始执行get、set命令了\n");
        if (!redis.set("user", "12345678")) {
            std::cerr << "set失败!" << std::endl;
            return -1;
        }
        auto val1 = redis.get("user");
        if (val1) {
            std::cout << *val1 << std::endl;
        }
    }
    return 0;
}
```

### exists和del
#### 函数原型
```cpp
// exists函数原型
long long exists(const StringView &key);
// del函数原型
long long del(const StringView &key);
template <typename T>
long long del(std::initializer_list<T> il);
```

#### 参数介绍
`key` 是redis的命令`exists`和`del`后跟的键，用于判断键是否存在和删除键。

#### 测试示例
```cpp
#include <iostream>
#include <sw/redis++/redis++.h>

int main() {
    sw::redis::Redis redis("tcp://127.0.0.1:6379");
    {
        printf("开始执行exists命令了\n");
        long long ret = redis.exists({"user", "pass", "data"});
        std::cout << "exists command result: " << ret << std::endl;
        printf("--------------------------------\n");
    }
    {
        printf("开始执行del命令了\n");
        // 删除单个
        printf("删除单个key\n");
        long long ret = redis.del("pass");
        std::cout << "del command result: " << ret << std::endl;
        printf("删除多个key\n");
        ret = redis.del({"user", "data"});
        std::cout << "del command result: " << ret << std::endl;
        printf("--------------------------------\n");
    }
    return 0;
}
```

### keys
#### 函数原型
```cpp
template <typename Output>
void Redis::keys(const StringView &pattern, Output output);
```

#### 参数介绍
- `pattern`：表示键的匹配规则。
- `output`：本质是 C++ STL 中的插入迭代器 `std::back_insert_iterator`，可通过 `std::back_inserter(container)` 函数构造，用于将查询结果插入到指定容器（需支持 `push_back` 操作）。

#### 测试示例
```cpp
#include <iostream>
#include <vector>
#include <sw/redis++/redis++.h>
#include <iterator>

int main() {
    sw::redis::Redis redis("tcp://127.0.0.1:6379");
    {
        printf("开始执行keys了\n");
        redis.flushall();
        redis.set("k1", "111");
        redis.set("k2", "222");
        redis.set("k3", "333");
        redis.set("k4", "444");
        std::vector<std::string> rets;
        auto it = std::back_inserter(rets);
        redis.keys("*", it);

        for (auto x : rets) {
            std::cout << x << std::endl;
        }
        printf("--------------------------------\n");
    }
    return 0;
}
```

### expires和ttl
#### 函数原型
```cpp
// expires函数原型
bool Redis::expire(const StringView &key, const std::chrono::seconds &timeout);
// ttl函数原型
long long ttl(const StringView &key);
```

#### 参数介绍
- `key`：是要设置的键。
- `timeout`：是要设置的键的过期时间，单位为秒。

#### 示例代码
```cpp
#include <iostream>
#include <sw/redis++/redis++.h>
#include <chrono>
#include <unistd.h>

int main() {
    sw::redis::Redis redis("tcp://127.0.0.1:6379");
    {
        // 设置5秒后过期
        redis.expire("k1", std::chrono::seconds(5));
        // 获取指定key剩余过期时间
        long long sec = redis.ttl("k1");
        while (sec--) {
            std::cout << "k1剩余过期时间: " << sec << std::endl;
            sleep(1);
        }
        auto ret = redis.get("k1");
        if (ret) {
            std::cout << "val: " << *ret << std::endl;
        } else {
            printf("k1已过期!\n");
        }
        printf("--------------------------------\n");
    }
    return 0;
}
```
## string类型
### 备注：基本指令中出现过的不再赘述

### mset和mget
#### 函数原型
```cpp
// mset函数原型
void Redis::mset(Input first, Input last);
// mget函数原型
void mget(std::initializer_list<T> il, Output output)
```
#### 参数介绍
- `mset`：Input表示的输入迭代器类型，可以传递容器的迭代器begin-end
- `mget`：il可以传入std::make_pair(string,stirng)类型的参数，output是输出迭代器，可以使用back_inserter()函数构造的返回值

#### 示例代码
```cpp
void unity1(Redis &redis)
{
    printf("开始测试string类型了\n");
    printf("开始测试mset\n");

    redis.flushall();
    std::vector<std::pair<std::string, std::string>> kvs = {{"u1", "张三"}, {"u2", "李四"}};
    redis.mset(kvs.begin(), kvs.end());
    std::vector<OptionalString> vals;
    auto it = std::back_inserter(vals);
    redis.mget({"u1", "u2"}, it);
    for (auto &str : vals)
    {
        if (str.has_value())
            std::cout << str.value() << std::endl;
    }
    printf("---------------------\n");
}
```

### setnx
#### 函数原型 
```cpp
bool setnx(const StringView &key, const StringView &val);
```
#### 参数介绍
- `key`：设置的key，等同于set的key
- `val`：设置的val，等同于set的val

#### 示例代码
```cpp
void unity2(Redis& redis)
{
    printf("开始执行setnx命令\n");
    //u1已存在
    bool ret = redis.setnx("u1", "王五");
    if (ret == false)
    {
        std::cerr << "设置key:u1失败,redis中已存在该key" << std::endl;
    }
    else
    {
         std::cerr << "设置u1 :王五 成功!" << std::endl;
    }
    ret = redis.setnx("u3", "王五");
    if (ret == false)
    {
        std::cerr << "设置key:u3失败,redis中已存在该key" << std::endl;
        return;
    }
    else
    {
         std::cerr << "设置u3 :王五 成功!" << std::endl;
    }

}
```


### append和strlen
#### 函数原型 
```cpp
long long append(const StringView &key, const StringView &str);
long long strlen(const StringView &key);
```
#### 参数介绍
- `append`：设置的key，等同于set的key,str表示要向key对应的val追加的字符串，函数返回追加成功后的字符串长度
- `strlen`：设置的key，等同于set的key,返回key对应的val字符串的实际长度

#### 示例代码
```cpp
void unity3(Redis &redis)
{
    printf("开始执行append和strlen命令\n");
    redis.set("k1", "hello");
    OptionalString val = redis.get("k1");
    long long len = redis.strlen("k1");
    if (val.has_value()) std::cout << "val : " << val.value() << std::endl;
    std::cout << "append前的长度: " << len << std::endl;
    len = redis.append("k1", "word");
    std::cout << "append后的长度: " << len << std::endl;
    printf("--------------------------\n");
}
```
#### 测试结果
```cpp
    开始执行append和strlen命令
    val : hello
    append前的长度: 5
    append后的长度: 9
```


### getrange和setrange
#### 函数原型 
```cpp
std::string getrange(const StringView &key, long long start, long long end);
long long setrange(const StringView &key, long long offset, const StringView &val);
```
#### 参数介绍
- `append`：设置的key，等同于set的key,start表示要截取的起始位置,end表示要截取的结束位置
- `strlen`：设置的key，等同于set的key,offset表示从哪里开始覆盖？val表示覆盖的值，返回设置完成后key对应的val字符串的实际长度

#### 示例代码
```cpp
void unity4(Redis& redis)
{

    printf("开始执行setrange和getrange命令\n");

    redis.flushall();

    redis.set("k1", "今天天气真好!");

    std::string s = redis.getrange("k1", 0, 2);
    std::cout << "截取后的字串为: " << s << std::endl;

    long long ret = redis.setrange("k1", 0, "明天见!");

    std::cout << "setrange ret = " << ret << std::endl;

    OptionalString val = redis.get("k1");
    if (val.has_value()) std::cout << "val : " << val.value() << std::endl;
    printf("--------------------------\n");
}

```

## Hash类型
### 备注：基本指令中出现过的不再赘述

### hset && hget
#### 函数原型 
```cpp
long long hset(const StringView &key, const std::pair<StringView, StringView> &item);
OptionalString hget(const StringView &key, const StringView &field);
```

#### 参数介绍
- `hset`：key类似于设置的哈希表的变量名，item中的pair的第一个参数是这个哈希表中的key值，另外一个就是val值
- `hget`：key类似于设置的哈希表的变量名,filed就是这个哈希表中的key值，返回对应的val值(如果有)

#### 示例代码
```cpp
void unity1(Redis &redis)
{
    printf("开始执行hset和hget了\n");
    redis.flushall();
    StringView table_name = "user";
    long long n = redis.hset(table_name, std::make_pair("id", "{name: 张三\r\nage: 18\r\n}"));
    std::cout << "hset command res : " << n << std::endl;

    OptionalString res = redis.hget(table_name,"id");
    
    if(res.has_value()) std::cout<<"hget command res : "<<res.value()<<std::endl;
}
```

### hkeys && hvals && hlen && hgetall
#### 函数原型
```cpp
inline void Redis::hkeys(const StringView &key, Output output);
inline void Redis::hvals(const StringView &key, Output output);
long long hlen(const StringView &key);
inline void Redis::hgetall(const StringView &key, Output output)
```

#### 参数介绍
- `提示`：上文都已提到过


#### 示例代码
```cpp

void unity3(Redis &redis)
{
    printf("开始执行hkeys和hvals、Hlen、hgetall了\n");

    redis.hset("user", std::make_pair("statu", "OK"));

    std::vector<std::string> res;
    auto it = std::back_inserter(res);
    redis.hkeys("user", it);

    if (!res.empty())
    {
        for (auto &x : res)
        {
            std::cout << "key-->" << x << std::endl;
        }
        std::cout << "\n";
    }
    else std::cout << "user中没有key" << std::endl;

    printf("---------------------------\n");
    res.clear();
    it = std::back_inserter(res);
    redis.hvals("user", it);
    if (!res.empty())
    {
        for (auto &x : res)
        {
            std::cout << x << std::endl;
        }
        std::cout << "\n";
    }
    else  std::cout << "user中没有val" << std::endl;

    printf("---------------------------\n");

    int n = redis.hlen("user");
    std::cout << "hlen command res : " << n << std::endl;

    res.clear();
    it = std::back_inserter(res);
    redis.hgetall("user", it);

    if (!res.empty())
    {
        for (auto &x : res)
        {
            std::cout << x << std::endl;
        }
        std::cout << "\n";
    }
    else  std::cout << "user中没有key--val键值对" << std::endl;
    printf("---------------------------\n");
}
```