redis源码阅读理解，及相关语言细节---sds.c

淩亂°似流年 2022-05-25 10:50 116阅读 0赞

sds即动态字符串，这节的代码主要是自己构造的字符串，相当于优化了之前的c语言结构的字符串，因为redis对于数据的处理速度有着很高的要求，所以对于底层的规划势必要做一个完全的优化调整，所以也就有了这个文件的内容，c语言是不会记录字符串长度的，而对于redis这显然是无法接收的，前面在学习malloc的时候也提到了，redis在申请的时候不仅仅要求数据对齐，同时还对数据的大小有着更高的要求，申请的内存全部都是8的倍数，当然这只是要说的一小部分，接下来，还是按照我之前的习惯，首先放上sds.h的头文件定义相关代码：

typedef char *sds;
    
    // sdshdr 结构
    struct sdshdr {
        // buf 已占用长度
        int len;
        // buf 剩余可用长度
        int free;
        // 实际保存字符串数据的地方
        // 利用c99(C99 specification 6.7.2.1.16)中引入的 flexible array member,通过buf来引用sdshdr后面的地址，
        // 详情google "flexible array member"
        char buf[];
    };
    /*
     * 返回 sds buf 的已占用长度
     */
    static inline size_t sdslen(const sds s) {
        struct sdshdr *sh = (void*)(s-(sizeof(struct sdshdr)));
        return sh->len;
    }
    /*
     * 返回 sds buf 的可用长度
     */
    static inline size_t sdsavail(const sds s) {
        struct sdshdr *sh = (void*)(s-(sizeof(struct sdshdr)));
        return sh->free;
    }

首先是宏定义了一个char\*类型的变量，变量的名字是sds，

\-------------------------------------------跑题的分割线---------------------------------------------------------------------

说起char\*我认为这个简直就是c系语言里面最神奇的一种类型了，当然这并不是我们关注的重点，所以现在我们就不对这个进行讨论，如果对char\*有兴趣的同学可以去参考一下这篇文章[点击打开链接][Link 1]，但是我还是要说明一点char\*str="hello";这种写法是可以出结果的，但是会有警告，为什么会有警告呢，原因很简单"hello"的数据类型是const char\* 所以这样赋值就会出现问题，但是很关键的一点就是这种写法只是为了兼容之前的程序，所以这个写法最后是一定会被抛弃的，所以我特意说一下，希望之后能够避免这种写法

\---------------------------------------------------------------------------------------------------------------------------------------

然后定义了一个sdshdr 的结构体，这个结构在内存里面占8个字节char buf\[\]这个占0个字节。结构体包含的数据为len,free,以及一个char数组,这个数组是一个柔性数组，也就是我们常说的数组大小可以动态变化的，接下来，定义了两个内联函数，所谓内联函数的意思就是在编译的时候调用这个函数不需要跳到相应的代码片段，他是直接在编译的时候就被写到了调用他函数的部分，这样的好处是在执行的过程中，不需要调到单独的代码段去执行，可以提升整个程序的运行速度，坏处也是显而易见，这样写十分的耗费内存，但是相对来说，在内联函数不长的情况下，这样的方法还是十分有优势的，让我们来看看这两个内联函数的具体功能,一个是返回已占用长度，一个是返回空余的长度，但是这两个函数的实现确十分的有意思

struct sdshdr \*sh = (void\*)(s-(sizeof(struct sdshdr)));

通过这句话来找到一个sdshdr结构体，通过返回这个结构体的free以及len，但是问题的关键是为什么这样的写法就可以完成这个函数的功能，单独看这个函数是无法明白这个原理的，我们需要了解之后的函数才能透彻的明白这个底层的实现，接下来我们看一下后面的函数

sds sdsnewlen(const void *init, size_t initlen);
    sds sdsnew(const char *init);
    sds sdsempty();
    size_t sdslen(const sds s);
    sds sdsdup(const sds s);
    void sdsfree(sds s);
    size_t sdsavail(const sds s);
    sds sdscatlen(sds s, const void *t, size_t len);
    sds sdscpylen(sds s, const char *t, size_t len);
    sds sdscpy(sds s, const char *t);
    sds sdstrim(sds s, const char *cset);
    sds sdsrange(sds s, int start, int end);
    void sdsupdatelen(sds s);
    void sdsclear(sds s);
    int sdscmp(const sds s1, const sds s2);
    sds *sdssplitlen(const char *s, int len, const char *sep, int seplen, int *count);
    void sdsfreesplitres(sds *tokens, int count);
    void sdstolower(sds s);
    void sdstoupper(sds s);
    sds sdsmapchars(sds s, const char *from, const char *to, size_t setlen);

首先我们先看前两个函数的源代码，看懂了这两个函数，就能对整个前面的内联函数有一个比较深入的认识，废话不说，先来贴代码

sds sdsnewlen(const void *init, size_t initlen) {
        struct sdshdr *sh;
        // 有 init ？
        // O(N)
        if (init) {
            sh = zmalloc(sizeof(struct sdshdr)+initlen+1);
        } else {
            sh = zcalloc(sizeof(struct sdshdr)+initlen+1);
        }
        // 内存不足，分配失败
        if (sh == NULL) return NULL;
        sh->len = initlen;
        sh->free = 0;
        // 如果给定了 init 且 initlen 不为 0 的话
        // 那么将 init 的内容复制至 sds buf
        // O(N)
        if (initlen && init)
            memcpy(sh->buf, init, initlen);
        // 加上终结符
        sh->buf[initlen] = '\0';
        // 返回 buf 而不是整个 sdshdr
        return (char*)sh->buf;
    }
    /*
     * 根据给定初始化值 init ，创建 sds
     * 如果 init 为 NULL ，那么创建一个 buf 内只包含 \0 终结符的 sds
     *
     * T = O(N)
     */
    sds sdsnew(const char *init) {
        size_t initlen = (init == NULL) ? 0 : strlen(init);
        return sdsnewlen(init, initlen);
    }

可以看出redis提供了一种返回sds的数据类型的函数，也就是我们可以这样写

sds temp = sdsnew("redis")

当执行完这一句之后，首先会计算一下字符串长度，如果为空那么认为字符串长度为0，接下来调用sdsnewlen函数，sdsnewlen函数，首先可以看到新建了一个sdshdr的结构体，之后是一些基本的操作，都是对结构体进行赋值，之后返回的也是是结构体的buf\[\],那么回到最开始的问题，这句话

struct sdshdr \*sh = (void\*)(s-(sizeof(struct sdshdr)));

究竟是如何工作的，其实通过最开始的初始化，我们已经可以看出，当运行sdsnew函数的时候，首先会申请一块完整的内存出来内存按照顺序分别包括len,free,buf\[\],而我们的sds数据存储的位置是buf\[\],所以我们可以把这句话这么理解，我们每建立一个字符串类型都会新建一个struct sdshdr，然后我们返回sdshdr->buf,但是这是一块完整的内存，buf的前面紧跟着free和len所以，当我们执行只一句的时候s-(sizeof(struct sdshdr))，实际上是将指针向前移动，将指针指向了结构体，针对与结构体，我们当然可以取其中的数据，无论是free,还是len，当我分析到这里，我觉得这个redis的作者简直是神，作者对于内存管理以及c++的实现机制简直就是了若指掌,这样的写法如果我没见过，恐怕一辈子也写不出来，哎差距还很大啊。

接下来看一下clear()函数

void sdsclear(sds s) {
    
        struct sdshdr *sh = (void*) (s-(sizeof(struct sdshdr)));
    
        sh->free += sh->len;
        sh->len = 0;
        sh->buf[0] = '\0';
    }

首先是清空数组，可以看出，之后的所有操作都是按照这样的模式，首先将指针指向结构体，然后更新结构体里面的数据，其余的部分都是很基础的赋值语句，可以看出很多部分的操作都是对数据的结构来执行，也就是说这个结构体是管理动态字符的关键，这样的思想真的是十分的先进，后面还有一些函数，大体上的结构变化不大，我也贴上几个典型的，有兴趣的可以自己看一下~

/* Helper function for sdssplitargs() that returns non zero if 'c'
     * is a valid hex digit. */
    int is_hex_digit(char c) {
        return (c >= '0' && c <= '9') || (c >= 'a' && c <= 'f') ||
               (c >= 'A' && c <= 'F');
    }
    sds sdsfromlonglong(long long value) {
        char buf[32], *p;
        unsigned long long v;
    
        v = (value < 0) ? -value : value;
        p = buf+31; /* point to the last character */
        do {
            *p-- = '0'+(v%10);
            v /= 10;
        } while(v);
        if (value < 0) *p-- = '-';
        p++;
        return sdsnewlen(p,32-(p-buf));
    }
    void sdstoupper(sds s) {
        int len = sdslen(s), j;
    
        for (j = 0; j < len; j++) s[j] = toupper(s[j]);
    }
    
    int sdscmp(const sds s1, const sds s2) {
        size_t l1, l2, minlen;
        int cmp;
    
        l1 = sdslen(s1);
        l2 = sdslen(s2);
        minlen = (l1 < l2) ? l1 : l2;
        cmp = memcmp(s1,s2,minlen);
        if (cmp == 0) return l1-l2;
        return cmp;
    }

[Link 1]: https://blog.csdn.net/u011068702/article/details/52588649