hiredis+vs2019+c++redis各种数据类型演示

已于 2023-03-26 18:51:36 修改
阅读量279 收藏 5
点赞数
分类专栏： C++ 文章标签： c++ redis 开发语言 Powered by 金山文档
于 2023-03-22 21:57:57 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_45434544/article/details/129720224
版权

1.Github下载hiredis源码

源码地址：https://github.com/redis/hiredis

下载后在文件夹下新建build目录cd 进入

然后打开cmd进入build目录下，执行代码：

cmake .. -G "Visual Studio 16 2019"  -DCMAKE_INSTALL_PREFIX=G:\TIANSHENG\研究生\C++学习\学习ing\六个C++项目打包送给你\redis\hiredis-master\build  -DYAML_BUILD_SHARED_LIBS=ON ..

打开.sln文件，生成库文件

2.新建vs2019空项目

在项目->属性->包含目录下加入头文件目录

在项目->链接器->输入填入：hiredisd.lib

  1. redis_test.cpp

#include <iostream>
#include <cstring>
#include "hiredis.h"
#include "head.h"
using namespace std;
Redis* redis = new Redis();
redisContext* c = nullptr;
int test() {
    if (!redis->connect("127.0.0.1", 6379))
    {
        printf("connect error!\n");
        return 0;
    }
    redis->set("name", "tiansheng");
    cout << "Get the name is " << redis->get("name") << endl;
    redis->append("name", "12345");
    cout << "Get the name is " << redis->get("name") << endl;
    int len = redis->getlen("name");
    std::cout << "STRLEN: " << len << std::endl;

    delete redis;
    return 0;
}
int connect_() {
    c = redisConnect("127.0.0.1", 6379); // 连接Redis
    if (c == nullptr || c->err) {
        if (c) {
            std::cout << "Error: " << c->errstr << std::endl;
            redisFree(c);
        }
        else {
            std::cout << "Error: can't allocate redis context" << std::endl;
        }
        return 1;
    }
    std::cout << "Connected to Redis" << std::endl;

}
int list() {
    // LPUSH key element1 element2 ...
    const char* key = "list";
    const char* elements[] = { "apple", "banana", "orange" };
    size_t elementCount = sizeof(elements) / sizeof(elements[0]);
    for (size_t i = 0; i < elementCount; i++) {
        redisReply* reply = (redisReply*)redisCommand(c, "LPUSH %s %s", key, elements[i]); // 左插入元素
        if (reply == nullptr) {
            std::cout << "Error: can't execute Redis command" << std::endl;
            redisFree(c);
            return 1;
        }
        else {
            std::cout << "LPUSH: " << reply->integer << std::endl;
            freeReplyObject(reply);
        }
    }
    // LLEN key
    redisReply* reply = (redisReply*)redisCommand(c, "LLEN %s", key); // 获取列表长度
    if (reply == nullptr) {
        std::cout << "Error: can't execute Redis command" << std::endl;
        redisFree(c);
        return 1;
    }
    else {
        std::cout << "LLEN: " << reply->integer << std::endl;
        freeReplyObject(reply);
    }
    // LRANGE key start stop
    reply = (redisReply*)redisCommand(c, "LRANGE %s %d %d", key, 0, elementCount - 1); // 获取列表中的所有元素
    if (reply == nullptr) {
        std::cout << "Error: can't execute Redis command" << std::endl;
        redisFree(c);
        return 1;
    }
    else if (reply->type == REDIS_REPLY_NIL) {
        std::cout << "Key not found" << std::endl;
        freeReplyObject(reply);
    }
    else if (reply->type == REDIS_REPLY_ARRAY) {
        std::cout << "LRANGE: ";
        for (size_t i = 0; i < reply->elements; i++) {
            std::cout << reply->element[i]->str << " ";
        }
        std::cout << std::endl;
        freeReplyObject(reply);
    }
    // LINDEX key index
    reply = (redisReply*)redisCommand(c, "LINDEX %s %d", key, 1); // 获取列表中指定位置的元素
    if (reply == nullptr) {
        std::cout << "Error: can't execute Redis command" << std::endl;
        redisFree(c);
        return 1;
    }
    else if (reply->type == REDIS_REPLY_NIL) {
        std::cout << "Key not found" << std::endl;
        freeReplyObject(reply);
    }
    else if (reply->type == REDIS_REPLY_STRING) {
        std::cout << "LINDEX: " << reply->str << std::endl;
        freeReplyObject(reply);
    }
    // LREM key count element
    reply = (redisReply*)redisCommand(c, "LREM %s %d %s", key, 1, "apple"); // 从列表中移除指定元素
    if (reply == nullptr) {
        std::cout << "Error: can't execute Redis command" << std::endl;
        redisFree(c);
        return 1;
    }
    else {
        std::cout << "LREM: " << reply->integer << std::endl;
        freeReplyObject(reply);
    }
    // RPOP key
    reply = (redisReply*)redisCommand(c, "RPOP %s", key); // 右弹出元素
    if (reply == nullptr) {
        std::cout << "Error: can't execute Redis command" << std::endl;
        redisFree(c);
        return 1;
    }
    else if (reply->type == REDIS_REPLY_NIL) {
        std::cout << "Key not found" << std::endl;
        freeReplyObject(reply);
    }
    else if (reply->type == REDIS_REPLY_STRING) {
        std::cout << "RPOP: " << reply->str << std::endl;
        freeReplyObject(reply);
    }
    return 0;
}
int stringg() {
    // SET key value
    const char* key = "name";
    const char* value = "Tom";
    redisReply* reply = (redisReply*)redisCommand(c, "SET %s %s", key, value); // 存储键值对
    if (reply == nullptr) {
        std::cout << "Error: can't execute Redis command" << std::endl;
        redisFree(c);
        return 1;
    }
    else {
        std::cout << "SET: " << reply->str << std::endl;
        freeReplyObject(reply);
    }
    reply = (redisReply*)redisCommand(c, "PERSIST %s", key); // 将键的过期时间设置为永久
    freeReplyObject(reply); // 释放 reply 对象
    // GET key
    reply = (redisReply*)redisCommand(c, "GET %s", key); // 获取键值对
    if (reply == nullptr) {
        std::cout << "Error: can't execute Redis command" << std::endl;
        redisFree(c);
        return 1;
    }
    else if (reply->type == REDIS_REPLY_NIL) {
        std::cout << "Key not found" << std::endl;
        freeReplyObject(reply);
    }
    else if (reply->type == REDIS_REPLY_STRING) {
        std::cout << "GET: " << reply->str << std::endl;
        freeReplyObject(reply);
    }
    // APPEND key value
    const char* appendValue = " Smith";
    reply = (redisReply*)redisCommand(c, "APPEND %s %s", key, appendValue); // 追加值

    if (reply == nullptr) {
        std::cout << "Error: can't execute Redis command" << std::endl;
        redisFree(c);
        return 1;
    }
    else {
        std::cout << "APPEND: " << reply->integer << std::endl;
        freeReplyObject(reply);
    }
    // STRLEN key
    reply = (redisReply*)redisCommand(c, "STRLEN %s", key); // 获取字符串长度
    if (reply == nullptr) {
        std::cout << "Error: can't execute Redis command" << std::endl;
        redisFree(c);
        return 1;
    }
    else {
        std::cout << "STRLEN: " << reply->integer << std::endl;
        freeReplyObject(reply);
    }
    // INCR key
    reply = (redisReply*)redisCommand(c, "INCR %s", "age"); // 自增1
    if (reply == nullptr) {
        std::cout << "Error: can't execute Redis command" << std::endl;
        redisFree(c);
        return 1;
    }
    else {
        std::cout << "INCR: " << reply->integer << std::endl;
        freeReplyObject(reply);
    }
    // DECRBY key decrement
    reply = (redisReply*)redisCommand(c, "DECRBY %s %d", "age", 2); // 自减2
    if (reply == nullptr) {
        std::cout << "Error: can't execute Redis command" << std::endl;
        redisFree(c);
        return 1;
    }
    else {
        std::cout << "DECRBY: " << reply->integer << std::endl;
        freeReplyObject(reply);
    }
    return 0;
}
int set() {
    // SADD key member1 member2 ...
    const char* key = "set";
    const char* members[] = { "apple", "banana", "orange" };
    size_t memberCount = sizeof(members) / sizeof(members[0]);
    for (size_t i = 0; i < memberCount; i++) {
        redisReply* reply = (redisReply*)redisCommand(c, "SADD %s %s", key, members[i]); // 添加元素
        if (reply == nullptr) {
            std::cout << "Error: can't execute Redis command" << std::endl;
            redisFree(c);
            return 1;
        }
        else {
            std::cout << "SADD: " << reply->integer << std::endl;
            freeReplyObject(reply);
        }
    }
    // SCARD key
    redisReply* reply = (redisReply*)redisCommand(c, "SCARD %s", key); // 获取集合元素个数
    if (reply == nullptr) {
        std::cout << "Error: can't execute Redis command" << std::endl;
        redisFree(c);
        return 1;
    }
    else {
        std::cout << "SCARD: " << reply->integer << std::endl;
        freeReplyObject(reply);
    }
    // SMEMBERS key
    reply = (redisReply*)redisCommand(c, "SMEMBERS %s", key); // 获取集合中的所有元素
    if (reply == nullptr) {
        std::cout << "Error: can't execute Redis command" << std::endl;
        redisFree(c);
        return 1;
    }
    else if (reply->type == REDIS_REPLY_NIL) {
        std::cout << "Key not found" << std::endl;
        freeReplyObject(reply);
    }
    else if (reply->type == REDIS_REPLY_ARRAY) {
        std::cout << "SMEMBERS: ";
        for (size_t i = 0; i < reply->elements; i++) {
            std::cout << reply->element[i]->str << " ";
        }
        std::cout << std::endl;
        freeReplyObject(reply);
    }
    // SISMEMBER key member
    reply = (redisReply*)redisCommand(c, "SISMEMBER %s %s", key, "apple"); // 判断元素是否在集合中
    if (reply == nullptr) {
        std::cout << "Error: can't execute Redis command" << std::endl;
        redisFree(c);
        return 1;
    }
    else {
        std::cout << "SISMEMBER: " << reply->integer << std::endl;
        freeReplyObject(reply);
    }
    // SREM key member1 member2 ...
    reply = (redisReply*)redisCommand(c, "SREM %s %s %s", key, "apple", "banana"); // 从集合中移除指定元素
    if (reply == nullptr) {
        std::cout << "Error: can't execute Redis command" << std::endl;
        redisFree(c);
        return 1;
    }
    else {
        std::cout << "SREM: " << reply->integer << std::endl;
        freeReplyObject(reply);
    }
    return 0;
}
int hash_() {
    // HSET key field value
    const char* key = "hash";
    const char* field = "name";
    const char* value = "John";
    redisReply* reply = (redisReply*)redisCommand(c, "HSET %s %s %s", key, field, value); // 设置Hash键值对
    if (reply == nullptr) {
        std::cout << "Error: can't execute Redis command" << std::endl;
        redisFree(c);
        return 1;
    }
    else {
        std::cout << "HSET: " << reply->integer << std::endl;
        freeReplyObject(reply);
    }
    // HMSET key field1 value1 field2 value2 ...
    const char* fields[] = { "age", "gender" };
    const char* values[] = { "25", "male" };
    size_t fieldCount = sizeof(fields) / sizeof(fields[0]);
    for (size_t i = 0; i < fieldCount; i++) {
        redisAppendCommand(c, "HMSET %s %s %s", key, fields[i], values[i]); // 批量设置Hash键值对
    }
    for (size_t i = 0; i < fieldCount; i++) {
        redisGetReply(c, (void**)&reply);
        if (reply == nullptr) {
            std::cout << "Error: can't execute Redis command" << std::endl;
            redisFree(c);
            return 1;
        }
        else {
            std::cout << "HMSET: " << reply->str << std::endl;
            freeReplyObject(reply);
        }
    }
    // HGET key field
    reply = (redisReply*)redisCommand(c, "HGET %s %s", key, field); // 获取Hash键值对的值
    if (reply == nullptr) {
        std::cout << "Error: can't execute Redis command" << std::endl;
        redisFree(c);
        return 1;
    }
    else if (reply->type == REDIS_REPLY_NIL) {
        std::cout << "Key or field not found" << std::endl;
        freeReplyObject(reply);
    }
    else {
        std::cout << "HGET: " << reply->str << std::endl;
        freeReplyObject(reply);
    }
    // HMGET key field1 field2 ...
    const char* queryFields[] = { "name", "age", "gender" };
    size_t queryFieldCount = sizeof(queryFields) / sizeof(queryFields[0]);
    reply = (redisReply*)redisCommand(c, "HMGET %s %s %s %s", key, queryFields[0], queryFields[1], queryFields[2]); // 批量获取Hash键值对的值
    if (reply == nullptr) {
        std::cout << "Error: can't execute Redis command" << std::endl;
        redisFree(c);
        return 1;
    }
    else if (reply->type == REDIS_REPLY_NIL) {
        std::cout << "Key not found" << std::endl;
        freeReplyObject(reply);
    }
    else if (reply->type == REDIS_REPLY_ARRAY) {
        std::cout << "HMGET:";
        for (size_t i = 0; i < queryFieldCount; i++) {
            if (reply->element[i]->type == REDIS_REPLY_NIL) {
                std::cout << " NULL";
            }
            else {
                std::cout << " " << reply->element[i]->str;
            }
        }
        std::cout << std::endl;
        freeReplyObject(reply);
    }
    // HGETALL key
    reply = (redisReply*)redisCommand(c, "HGETALL %s", key); // 获取Hash键值对的所有字段和值
    if (reply == nullptr) {
        std::cout << "Error: can't execute Redis command" << std::endl;
        redisFree(c);
        return 1;
    }
    else if (reply->type == REDIS_REPLY_NIL) {
        std::cout << "Key not found" << std::endl;
        freeReplyObject(reply);
    }
    else if (reply->type == REDIS_REPLY_ARRAY) {
        std::cout << "HGETALL:";
        for (size_t i = 0; i < reply->elements; i += 2) {
            std::cout << " " << reply->element[i]->str << "=" << reply->element[i + 1]->str;
        }
        std::cout << std::endl;
        freeReplyObject(reply);
    }
    // HDEL key field1 field2 ...
    reply = (redisReply*)redisCommand(c, "HDEL %s %s %s", key, fields[0], fields[1]); // 删除Hash键值对的指定字段
    if (reply == nullptr) {
        std::cout << "Error: can't execute Redis command" << std::endl;
        redisFree(c);
        return 1;
    }
    else {
        std::cout << "HDEL: " << reply->integer << std::endl;
        freeReplyObject(reply);
    }
    return 0;
}
int zset() {
    // ZADD key score1 member1 score2 member2 ...
    const char* key = "zset";
    const char* members[] = { "John", "Tom", "Mary" };
    double scores[] = { 1.0, 2.0, 3.0 };
    size_t memberCount = sizeof(members) / sizeof(members[0]);
    redisReply* reply = nullptr;
    for (size_t i = 0; i < memberCount; i++) {
        redisAppendCommand(c, "ZADD %s %f %s", key, scores[i], members[i]); // 添加zSet成员
    }
    for (size_t i = 0; i < memberCount; i++) {
        redisGetReply(c, (void**)&reply);
        if (reply == nullptr) {
            std::cout << "Error: can't execute Redis command" << std::endl;
            redisFree(c);
            return 1;
        }
        else {
            std::cout << "ZADD: " << reply->integer << std::endl;
            freeReplyObject(reply);
        }
    }
    // ZRANGE key start stop [WITHSCORES]
    reply = (redisReply*)redisCommand(c, "ZRANGE %s 0 -1 WITHSCORES", key); // 获取zSet成员列表
    if (reply == nullptr) {
        std::cout << "Error: can't execute Redis command" << std::endl;
        redisFree(c);
        return 1;
    }
    else if (reply->type == REDIS_REPLY_NIL) {
        std::cout << "Key not found" << std::endl;
        freeReplyObject(reply);
    }
    else if (reply->type == REDIS_REPLY_ARRAY) {
        std::cout << "ZRANGE:";
        for (size_t i = 0; i < reply->elements; i++) {
            std::cout << " " << reply->element[i]->str;
            if (i % 2 == 1) {
                std::cout << "(" << reply->element[i - 1]->str << ")";
            }
        }
        std::cout << std::endl;
        freeReplyObject(reply);
    }
    // ZSCORE key member
    const char* member = "John";
    reply = (redisReply*)redisCommand(c, "ZSCORE %s %s", key, member); // 获取zSet成员的分值
    if (reply == nullptr) {
        std::cout << "Error: can't execute Redis command" << std::endl;
        redisFree(c);
        return 1;
    }
    else if (reply->type == REDIS_REPLY_NIL) {
        std::cout << "Key or member not found" << std::endl;
        freeReplyObject(reply);
    }
    else {
        std::cout << "ZSCORE: " << reply->str << std::endl;
        freeReplyObject(reply);
    }
    // ZINCRBY key increment member
    reply = (redisReply*)redisCommand(c, "ZINCRBY %s 2.5 %s", key, member); // 对zSet成员的分值进行增量操作
    if (reply == nullptr) {
        std::cout << "Error: can't execute Redis command" << std::endl;
        redisFree(c);
        return 1;
    }
    else {
        std::cout << "ZINCRBY: " << reply->str << std::endl;
        freeReplyObject(reply);
    }
    // ZRANK key member
    reply = (redisReply*)redisCommand(c, "ZRANK %s %s", key, member); // 获取zSet成员的排名
    if (reply == nullptr) {
        std::cout << "Error: can't execute Redis command" << std::endl;
        redisFree(c);
        return 1;
    }
    else if (reply->type == REDIS_REPLY_NIL) {
        std::cout << "Key or member not found" << std::endl;
        freeReplyObject(reply);
    }
    else {
        std::cout << "ZRANK: " << reply->integer << std::endl;
        freeReplyObject(reply);
    }
    // ZREM key member1 member2 ...
    reply = (redisReply*)redisCommand(c, "ZREM %s %s %s", key, members[0], members[1]); // 删除zSet成员
    if (reply == nullptr) {
        std::cout << "Error: can't execute Redis command" << std::endl;
        redisFree(c);
        return 1;
    }
    else {
        std::cout << "ZREM: " << reply->integer << std::endl;
        freeReplyObject(reply);
    }
    redisFree(c); // 关闭Redis连接
    return 0;
}

int main() {
    connect_();
    stringg();
    set();
    hash_();
    zset();
    return 0;
}

  1. 运行前先运行redis-server

  1. 执行结果：

天生_13
关注
  • 0
    点赞
  • 踩
  • 5
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
HiRedis Redis 数据库 C++ 操作，支持 Windows
04-03
网际风 http://www.nezip.net 崇尚简洁实用。示例将Hiredis的操作封装为两个导出函数 Set 与 Get， 支持 Unicode 编码方式，支持二进制读写，有断线重连功能，可以使用静态库或动态库。 唯一实时Hiredis.dll 动态库方式。示例在 Win 10 VS2015 环境下编译通过。
vs2019c++使用hiredis下载安装
weixin_39910452的博客
08-20 1253
1.下载源码https://github.com/microsoftarchive/redis 第一次打开的时候VS2019会检测解决方案工具集，提示升级，点击确定即可，将工具集升级到最新或者下载对于的v120工具集 hiredis的编译配置 只需要右键hiredis工程和Win32_Interop工程，分别点击生成,生成hiredis.lib和Win32_Interop.lib即可。 在\redis-win-3.2.100\msvs\x64\Debug目录中可以看到两个静态链接库文件：hiredis.l
vs2003-hiredis-vc++客户端连接池，线程安全
02-21
vs2003-hiredis-vc++客户端连接池，线程安全
redis使用c++ API 的hiredis连接详解
yuchunhai321的博客
05-27 880
Redis是一个NoSQL数据库，本文将实现一个用c++ API接口连接的例子，来实现对Redis数据库的写入和读出功能，具体将从Redis的安装，Redis的c++接口hiredis安装，代码演示三部分组成。 一、Redis的安装和配置 由于源中已有Redis的相关组件，这里就不进行源码编译而直接使用apt-get （ubuntu环境）下载和安装 1.redis的安装和配置 sudo apt-cache search redis //根据结果列表找到需要安装的软件包：redis-s...
win10+visual studio2017，利用C++连接redis，进行JSON文件解析，自定义封装
xiaoshan0609的博客
12-17 1996
小山最近在疯狂搬砖，老板的项目快结题了TAT。这个项目是基于redis数据库，开发一套面向工业现场的信号采集与数据分析软件。工厂中的机器在实时运行状态下的信号（电流、温度等等），会以JSON文件的形式传输至redis数据库中，我们要做的就是读取这些数据，然后采取多元信息融合算法得到健康指标，监测指标的变化并进行简单的信号分析（FFT或者包络之类的）。 首先，第一步，C++与red...
windows环境下通过c++使用redis
qq_44929357的博客
04-17 1130
windows环境下通过c++使用redis
基于SpringBoot2+MybatisPlus+SpringSecurity+jwt+redis+Vue的前后端商城系统源码
05-13
yshop基于当前流行技术组合的前后端分离商城系统： SpringBoot2+MybatisPlus+SpringSecurity+jwt+redis+Vue的前后端分离的商城系统， 包含分类、sku、运费模板、素材库、小程序直播、拼团、砍价、商户管理、 秒杀、...
SpringBoot2+MybatisPlus+SpringSecurity+jwt+redis+Vue的前后端分离的商城系统
04-30
基于当前流行技术组合的前后端分离商城系统：SpringBoot2+MybatisPlus+SpringSecurity+jwt+redis+Vue的前后端分离的商城系统， 包含商城、sku、运费模板、素材库、小程序直播、拼团、砍价、商户管理、 秒杀、优惠券...
c++ hiredis redis-3.0 vs2013 src
10-09
c++ hiredis redis-3.0 vs2013 src 压缩包内包含hiredis.lib等编译完成的lib文件. 更多教程 https://blog.csdn.net/wangningyu ​  Redis是一个key-value存储系统。和Memcached类似，它支持存储的value类型相对更多...
redis++使用说明,windows下编译redis-plus-plus
06-13
redis++使用说明,windows下编译redis-plus-plus
初识C语言——第二十一天
硬件菜鸟的成长之路
05-15 620
1.rand()函数是只能生成伪随机数，并且无返回值，使用前需调用srand()伪随机数生成器作为起点2.time（）函数是结构体函数，返回值是64为整数类型，可以通过time函数生成时间戳时间戳-函数调用的时间点和计算机的初始时间点之间的时间间隔3.void（）函数-无返回值类型函数4.while(1)-一直循环，直到break跳出。
C语言.动态内存管理
Joseit的博客
05-16 590
栈区（stack）：在执行函数时，函数内局部变量的存储单元都可以在栈上创建，函数执行结束时这些存储单元自动被释放。栈内存分配运算内置于处理器的指令集中，效率很高，但是分配的内存容量有限。栈区主要存放运行函数而分配的局部变量、函数参数、返回数据、返回地址等。堆区（heap）：一般由程序员分配释放， 若程序员不释放，程序结束时可能由OS(操作系统)回收。分配方式类似于链表。数据段（静态区）：（static）存放全局变量、静态数据。程序结束后由系统释放。
【CCF-CSP】202312-4 宝藏
whaoe_m的博客
05-14 408
对于所有类型为 2的事件，输出一行四个非负整数 C1,1​,C1,2​,C2,1​,C2,2​，表示该时刻的密码 C。西西艾弗岛上埋藏着一份宝藏，小 C 根据藏宝图找到了宝藏的位置。由于小 C 并不会这个问题，他向你发起了求助。你需要帮助小 C 求出所有类型为 22 的事件所对应的密码。小 C 将所有的时刻发生的事件均记录了下来。输入的第一行包含两个正整数n,m。从标准输入读入数据。
C++ 11
qq_65112813的博客
05-17 658
对于类类型，如果定义了接受。
【C++】＜知识点＞ 类的大小计算
最新发布
致力于Linux的博客
05-18 117
C++中使用sizeof计算类大小的内在说明。
c语言之文件打开模式
2301_81968528的博客
05-15 322
fp=fopen("D://cyy//bbb.txt","w")中的w改为a，变成写入。这段代码和上段代码类似，这里要说明一下，这段代码是上一段代码执行后，已经建立了bbb.txt这个文件。a模式是追加模式，允许向文件末尾写入信息，如果文件名不存在，则会报错。rb+,wb+,ab+属于允许对文件读取和写入信息，打开二进制文件。允许向文件写入信息，若文件不存在，则创建一个文件。"rb","wb"，“ab”是打开二进制文件。允许对文件读取信息。
C++初阶学习第七弹——探索STL奥秘（二）——string的模拟实现
2301_80220607的博客
05-13 2093
探索STL奥秘（二）之——string类的模拟实现，具详细，适合小白直接上手学习！！！
redis各种数据类型
08-24
Redis支持多种数据类型，包括： 1. 字符串（String）：最基本的数据类型，可以存储字符串、整数或浮点数。 2. 列表（List）：有序的字符串集合，可以进行插入、删除和更新操作。可以使用列表实现栈和队列等数据...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

天生_13

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值