安装使用redisplusplus库

装好cmake

下载cplusplus库

下载hiredis

1.使用cmake编译hiredis

 2.打开项目 编译hiredis库

3.把hiredis根目录的头文件自己整理出来 使用hiredis文件夹保存

 

4.使用编译redisplusplus 需要填写之前生成在hiredis静态库包 及头文件 还有hiredis.dir文件夹

填写头文件地址 

 填写之前生成的hiredis库位置

 填写hiredis.dir地址

这里可以选择c++标准 C++11 C++14 C++17

我这里选择的C++14 看你项目选择 测试案例可以去掉

 生成

 打开项目  这里如果你要多生成其他版本的 需要修改lib地址

 生成动态库 下面static是生成静态库

成功 

5.拷贝redisplusplus的头文件 这里注意要把你选择的C++语言的文件拷出来  

整个拷贝到你项目头文件目录  cxx11 no_tls 如果有用ssl 需要拷贝tls胡拷贝里面到redis++头文件目录

 然后自己新建个项目 把头文件 静态库包 动态库都拷贝过去 配置好头文件及库位置 使用官方测试案例 测试

 

 

// testRedisplus.cpp : 此文件包含 "main" 函数。程序执行将在此处开始并结束。
//
#include <chrono>
#include <tuple>
#include <iostream>
#include <vector>
#include <map>
#include <unordered_set>
#include "sw/redis++/command.h"
#include "sw/redis++/connection.h"
#include "sw/redis++/command_options.h"
#include "sw/redis++/command_args.h"
#include "sw/redis++/utils.h"
#include <sw/redis++/redis++.h>
#include <sw/redis++/sentinel.h>
#include <sw/redis++/connection.h>
#include <sw/redis++/connection_pool.h>


using namespace sw::redis;
using namespace std::chrono;
int main()
{

    try {
        // Create an Redis object, which is movable but NOT copyable.
        auto redis = Redis("tcp://127.0.0.1:6379");
        redis.auth("123456");
        // ***** STRING commands *****

        redis.set("key", "val");
        auto val = redis.get("key");    // val is of type OptionalString. See 'API Reference' section for details.
        if (val) {
            // Dereference val to get the returned value of std::string type.
            std::cout << *val << std::endl;
        }   // else key doesn't exist.

        // ***** LIST commands *****

        // std::vector<std::string> to Redis LIST.
        std::vector<std::string> vec = { "a", "b", "c" };
        redis.rpush("list", vec.begin(), vec.end());

        // std::initializer_list to Redis LIST.
        redis.rpush("list", { "a", "b", "c" });

        // Redis LIST to std::vector<std::string>.
        vec.clear();
        redis.lrange("list", 0, -1, std::back_inserter(vec));

        // ***** HASH commands *****

        redis.hset("hash", "field", "val");

        // Another way to do the same job.
        redis.hset("hash", std::make_pair("field", "val"));

        // std::unordered_map<std::string, std::string> to Redis HASH.
        std::unordered_map<std::string, std::string> m = {
            {"field1", "val1"},
            {"field2", "val2"}
        };
        redis.hmset("hash", m.begin(), m.end());

        // Redis HASH to std::unordered_map<std::string, std::string>.
        m.clear();
        redis.hgetall("hash", std::inserter(m, m.begin()));

        // Get value only.
        // NOTE: since field might NOT exist, so we need to parse it to OptionalString.
        std::vector<OptionalString> vals;
        redis.hmget("hash", { "field1", "field2" }, std::back_inserter(vals));

        // ***** SET commands *****

        redis.sadd("set", "m1");

        // std::unordered_set<std::string> to Redis SET.
        std::unordered_set<std::string> set = { "m2", "m3" };
        redis.sadd("set", set.begin(), set.end());

        // std::initializer_list to Redis SET.
        redis.sadd("set", { "m2", "m3" });

        // Redis SET to std::unordered_set<std::string>.
        set.clear();
        redis.smembers("set", std::inserter(set, set.begin()));

        if (redis.sismember("set", "m1")) {
            std::cout << "m1 exists" << std::endl;
        }   // else NOT exist.

        // ***** SORTED SET commands *****

        redis.zadd("sorted_set", "m1", 1.3);

        // std::unordered_map<std::string, double> to Redis SORTED SET.
        std::unordered_map<std::string, double> scores = {
            {"m2", 2.3},
            {"m3", 4.5}
        };
        redis.zadd("sorted_set", scores.begin(), scores.end());

        // Redis SORTED SET to std::vector<std::pair<std::string, double>>.
        // NOTE: The return results of zrangebyscore are ordered, if you save the results
        // in to `std::unordered_map<std::string, double>`, you'll lose the order.
        std::vector<std::pair<std::string, double>> zset_result;
        redis.zrangebyscore("sorted_set",
            UnboundedInterval<double>{},            // (-inf, +inf)
            std::back_inserter(zset_result));

        // Only get member names:
        // pass an inserter of std::vector<std::string> type as output parameter.
        std::vector<std::string> without_score;
        redis.zrangebyscore("sorted_set",
            BoundedInterval<double>(1.5, 3.4, BoundType::CLOSED),   // [1.5, 3.4]
            std::back_inserter(without_score));

        // Get both member names and scores:
        // pass an back_inserter of std::vector<std::pair<std::string, double>> as output parameter.
        std::vector<std::pair<std::string, double>> with_score;
        redis.zrangebyscore("sorted_set",
            BoundedInterval<double>(1.5, 3.4, BoundType::LEFT_OPEN),    // (1.5, 3.4]
            std::back_inserter(with_score));

        // ***** SCRIPTING commands *****

        // Script returns a single element.
        auto num = redis.eval<long long>("return 1", {}, {});

        // Script returns an array of elements.
        std::vector<std::string> nums;
        redis.eval("return {ARGV[1], ARGV[2]}", {}, { "1", "2" }, std::back_inserter(nums));

        // mset with TTL
        auto mset_with_ttl_script = R"(
        local len = #KEYS
        if (len == 0 or len + 1 ~= #ARGV) then return 0 end
        local ttl = tonumber(ARGV[len + 1])
        if (not ttl or ttl <= 0) then return 0 end
        for i = 1, len do redis.call("SET", KEYS[i], ARGV[i], "EX", ttl) end
        return 1
    )";

        // Set multiple key-value pairs with TTL of 60 seconds.
        auto keys = { "key1", "key2", "key3" };
        std::vector<std::string> args = { "val1", "val2", "val3", "60" };
        redis.eval<long long>(mset_with_ttl_script, keys.begin(), keys.end(), args.begin(), args.end());

        // ***** Pipeline *****

        // Create a pipeline.
        auto pipe = redis.pipeline();

        // Send mulitple commands and get all replies.
        auto pipe_replies = pipe.set("key", "value")
            .get("key")
            .rename("key", "new-key")
            .rpush("list", { "a", "b", "c" })
            .lrange("list", 0, -1)
            .exec();

        // Parse reply with reply type and index.
        auto set_cmd_result = pipe_replies.get<bool>(0);

        auto get_cmd_result = pipe_replies.get<OptionalString>(1);

        // rename command result
        pipe_replies.get<void>(2);

        auto rpush_cmd_result = pipe_replies.get<long long>(3);

        std::vector<std::string> lrange_cmd_result;
        pipe_replies.get(4, back_inserter(lrange_cmd_result));

        // ***** Transaction *****

        // Create a transaction.
        auto tx = redis.transaction();

        // Run multiple commands in a transaction, and get all replies.
        auto tx_replies = tx.incr("num0")
            .incr("num1")
            .mget({ "num0", "num1" })
            .exec();

        // Parse reply with reply type and index.
        auto incr_result0 = tx_replies.get<long long>(0);

        auto incr_result1 = tx_replies.get<long long>(1);

        std::vector<OptionalString> mget_cmd_result;
        tx_replies.get(2, back_inserter(mget_cmd_result));

        // ***** Generic Command Interface *****

        // There's no *Redis::client_getname* interface.
        // But you can use *Redis::command* to get the client name.
        val = redis.command<OptionalString>("client", "getname");
        if (val) {
            std::cout << *val << std::endl;
        }

        // Same as above.
        auto getname_cmd_str = { "client", "getname" };
        val = redis.command<OptionalString>(getname_cmd_str.begin(), getname_cmd_str.end());

        // There's no *Redis::sort* interface.
        // But you can use *Redis::command* to send sort the list.
        std::vector<std::string> sorted_list;
        redis.command("sort", "list", "ALPHA", std::back_inserter(sorted_list));

        // Another *Redis::command* to do the same work.
        auto sort_cmd_str = { "sort", "list", "ALPHA" };
        redis.command(sort_cmd_str.begin(), sort_cmd_str.end(), std::back_inserter(sorted_list));

        // ***** Redis Cluster *****

        // Create a RedisCluster object, which is movable but NOT copyable.
        auto redis_cluster = RedisCluster("tcp://127.0.0.1:7000");

        // RedisCluster has similar interfaces as Redis.
        redis_cluster.set("key", "value");
        val = redis_cluster.get("key");
        if (val) {
            std::cout << *val << std::endl;
        }   // else key doesn't exist.

        // Keys with hash-tag.
        redis_cluster.set("key{tag}1", "val1");
        redis_cluster.set("key{tag}2", "val2");
        redis_cluster.set("key{tag}3", "val3");

        std::vector<OptionalString> hash_tag_res;
        redis_cluster.mget({ "key{tag}1", "key{tag}2", "key{tag}3" },
            std::back_inserter(hash_tag_res));

    }
    catch (const Error& e) {
        // Error handling.
    }
}

 

成功