cJSON源码分析（三）

本文主要是介绍cJSON源码分析（三），对大家解决编程问题具有一定的参考价值，需要的程序猿们随着小编来一起学习吧！

在构建好一个JSON对象之后，如何访问呢？

首先试着将json字符串序列化，并全部打印出来看下结构再说：

char * string = "{\"name\":\"xxx\", \"name2\":\"xxx2\"}";cJSON * root = cJSON_Parse(string);//json字符串序列化printf("%s\n", cJSON_Print(root));//json格式化输出

看源码了解一下cJSON_Print函数大致实现过程吧（cJSON_Parse函数实现的源码可翻阅前面文章）

/*
    printbuffer结构体主要用作格式化或非格式化打印json数据结构的缓冲区
*/typedef struct{
    unsigned char *buffer; //内容
    size_t length; //长度
    size_t offset; //偏移量
    size_t depth; /* current nesting depth (for formatted printing) 当前嵌套深度（用于格式化打印）*/
    cJSON_bool noalloc; //bool类型
    cJSON_bool format; /*bool类型， is this print a formatted print 这是是否格式化输出，用true,false控制*/
    internal_hooks hooks; //通过hook对内存进行操作} printbuffer;#define cjson_min(a, b) (((a) < (b)) ? (a) : (b)) //判断大小，全部用括号括起来，否则如果a,b是表达式且含有比<符号级别更低的运算符就会出现不可预料的错误/* Render a cJSON item/entity/structure to text. 
将项目/实体/结构呈现为文本*/CJSON_PUBLIC(char *) cJSON_Print(const cJSON *item){
    return (char*)print(item, true, &global_hooks);//global_hooks作为全局变量负责分配内存缓冲区}static unsigned char *print(const cJSON * const item, cJSON_bool format, const internal_hooks * const hooks){
    static const size_t default_buffer_size = 256;
    printbuffer buffer[1];
    unsigned char *printed = NULL;

    memset(buffer, 0, sizeof(buffer));

    /* create buffer 创建缓冲区读取字符*/
    buffer->buffer = (unsigned char*) hooks->allocate(default_buffer_size);
    buffer->length = default_buffer_size;
    buffer->format = format;
    buffer->hooks = *hooks;
    if (buffer->buffer == NULL)
    {
        goto fail;
    }

    /* print the value */
    if (!print_value(item, buffer))
    {
        goto fail;
    }
    update_offset(buffer);//更新偏移量

    /* check if reallocate is available */
    if (hooks->reallocate != NULL)//检查开辟的空间是否满足
    {
        printed = (unsigned char*) hooks->reallocate(buffer->buffer, buffer->offset + 1);//动态增加或减少空间
        if (printed == NULL) {
            goto fail;
        }
        buffer->buffer = NULL;
    }
    else /* otherwise copy the JSON over to a new buffer 
    否则，将JSON复制到新的缓冲区*/
    {
        printed = (unsigned char*) hooks->allocate(buffer->offset + 1);
        if (printed == NULL)
        {
            goto fail;
        }
        memcpy(printed, buffer->buffer, cjson_min(buffer->length, buffer->offset + 1));
        printed[buffer->offset] = '\0'; /* just to be sure 只是想确定一下，应该是保证字符串有正确的结束符号*/

        /* free the buffer */
        hooks->deallocate(buffer->buffer);//释放缓冲区内存
    }

    return printed;fail:
    if (buffer->buffer != NULL)
    {
        hooks->deallocate(buffer->buffer);
    }

    if (printed != NULL)
    {
        hooks->deallocate(printed);
    }

    return NULL;}/* Render a value to text. 
将值呈现为文本。*/static cJSON_bool print_value(const cJSON * const item, printbuffer * const output_buffer){
    unsigned char *output = NULL;

    if ((item == NULL) || (output_buffer == NULL))
    {
        return false;
    }

    switch ((item->type) & 0xFF)//0xFF, 表示item->type取低8位的值作为参数，更高位的数据不参考
    {
        case cJSON_NULL:
            output = ensure(output_buffer, 5);//确保偏移量足够容纳内容
            if (output == NULL)
            {
                return false;
            }
            strcpy((char*)output, "null");
            return true;

        case cJSON_False:
            output = ensure(output_buffer, 6);
            if (output == NULL)
            {
                return false;
            }
            strcpy((char*)output, "false");
            return true;

        case cJSON_True:
            output = ensure(output_buffer, 5);
            if (output == NULL)
            {
                return false;
            }
            strcpy((char*)output, "true");
            return true;

        case cJSON_Number:
            return print_number(item, output_buffer);

        case cJSON_Raw:
        {
            size_t raw_length = 0;
            if (item->valuestring == NULL)
            {
                return false;
            }

            raw_length = strlen(item->valuestring) + sizeof("");
            output = ensure(output_buffer, raw_length);
            if (output == NULL)
            {
                return false;
            }
            memcpy(output, item->valuestring, raw_length);
            return true;
        }

        case cJSON_String:
            return print_string(item, output_buffer);

        case cJSON_Array:
            return print_array(item, output_buffer);

        case cJSON_Object:
            return print_object(item, output_buffer);

        default:
            return false;
    }}/* calculate the new length of the string in a printbuffer and update the offset 
计算打印缓冲区中字符串的新长度并更新偏移量*/static void update_offset(printbuffer * const buffer){
    const unsigned char *buffer_pointer = NULL;
    if ((buffer == NULL) || (buffer->buffer == NULL))
    {
        return;
    }
    buffer_pointer = buffer->buffer + buffer->offset;

    buffer->offset += strlen((const char*)buffer_pointer);}/* realloc printbuffer if necessary to have at least "needed" bytes more 
重新分配printbuffer（如果需要的话）至少“需要”更多的字节*/static unsigned char* ensure(printbuffer * const p, size_t needed){
    unsigned char *newbuffer = NULL;
    size_t newsize = 0;

    if ((p == NULL) || (p->buffer == NULL))
    {
        return NULL;
    }

    if ((p->length > 0) && (p->offset >= p->length))
    {
        /* make sure that offset is valid 
        确保偏移量有效*/
        return NULL;
    }

    if (needed > INT_MAX)
    {
        /* sizes bigger than INT_MAX are currently not supported 
        当前不支持大于INT_MAX的大小*/
        return NULL;
    }

    needed += p->offset + 1;
    if (needed <= p->length)
    {
        return p->buffer + p->offset;
    }

    if (p->noalloc) {
        return NULL;
    }

    /* calculate new buffer size 
    计算新缓冲区大小*/
    if (needed > (INT_MAX / 2))
    {
        /* overflow of int, use INT_MAX if possible 
        int会溢出，溢出原因我认为是当int数是负数的时候，符号位为1，运算之后可能会超出size_t的大小
        如果可能，请使用 INT_MAX*/
        if (needed <= INT_MAX)
        {
            newsize = INT_MAX;
        }
        else
        {
            return NULL;
        }
    }
    else
    {
        newsize = needed * 2;
    }

    if (p->hooks.reallocate != NULL)
    {
        /* reallocate with realloc if available 
        重新分配与重新分配（如果可用）*/
        newbuffer = (unsigned char*)p->hooks.reallocate(p->buffer, newsize);
        if (newbuffer == NULL)
        {
            p->hooks.deallocate(p->buffer);
            p->length = 0;
            p->buffer = NULL;

            return NULL;
        }
    }
    else
    {
        /* otherwise reallocate manually 
        否则手动重新分配*/
        newbuffer = (unsigned char*)p->hooks.allocate(newsize);
        if (!newbuffer)
        {
            p->hooks.deallocate(p->buffer);
            p->length = 0;
            p->buffer = NULL;

            return NULL;
        }
        
        memcpy(newbuffer, p->buffer, p->offset + 1);
        p->hooks.deallocate(p->buffer);
    }
    p->length = newsize;
    p->buffer = newbuffer;

    return newbuffer + p->offset;}

序列化json字符串确实繁琐，其主要花费时间在缓冲区边界界定，内容复制，内存分配处理上。
大致了解一下工作流程，函数调用顺序大致如下（主要功能）：

cJSON_Print  ==>    print  ==>   print_value ==>ensure和print_string和print_array等

这篇关于cJSON源码分析（三）的文章就介绍到这儿，希望我们推荐的文章对大家有所帮助，也希望大家多多支持为之网！