您的位置:首页 > 教程资讯 > 皇冠体育的网址 > C++ > cJSON序列化工具解读一(结构剖析)

cJSON序列化工具解读一(结构剖析)

发布于:2016-05-24 14:34:42   分享到:

cJSON简介

JSON基本信息

JSON(JavaScript Object Notation)是一种轻量级的数据交换格式。易于人阅读和编写。同时易于机器解析和生成。是一种很好地数据交换语言。

JSON构建:基于两种结构

  “名称/值”对 的集合。

  值得有序列表。

JSON具体结构表示

  对象:一个”名称/值"对的集合 ?{名称:值,名称:值}

  数组:值得有序集合[值,值]

  值:str,num,true,false,null,object,array。可嵌套

  字符串:由双引号包围的任意数量Unicode字符的集合,反斜杠转义

  数值:类似C,java:没有8进制和具体的编码细节

cJSON源码解读

首先给出cJSON文件中头文件函数列表

我们将根据此进行模块化解读

①结构描述

关于具体的结构图解描述,请参考官方描述

    /* cJSON Types: */
#define cJSON_False 0
#define cJSON_True 1
#define cJSON_NULL 2
#define cJSON_Number 3
#define cJSON_String 4
#define cJSON_Array 5
#define cJSON_Object 6

#define cJSON_IsReference 256
#define cJSON_StringIsConst 512

以上是具体的类型区分描述,可以改进为使用enum实现更加安全

    /* The cJSON structure: */
    typedef struct cJSON {
        struct cJSON *next, *prev;    /* 如果是同一级别类型元素,使用双项链方式实现 */
        struct cJSON *child;        /* 如果是具体结构或者数组,第一个指针指向内部链 */

        int type;                    /*根据以上定义描述所保存对象类型*/

        char *valuestring;            /* The item's string, if type==cJSON_String */
        int valueint;                /* The item's number, if type==cJSON_Number */
        double valuedouble;            /* The item's number, if type==cJSON_Number */

        char *string;                /* 对于key-value映射结构,表示其key/名称 */
    }cJSON;

②关于内存管理

    typedef struct cJSON_Hooks {
        void *(*malloc_fn)(size_t sz);
        void(*free_fn)(void *ptr);
    } cJSON_Hooks;

注:cJSON的内存管理,提供了用户自主方式的接口。可以通过皇冠体育的网址|首页InitHooks来设置自己的内存管理,默认使用malloc,free

static void *(*cJSON_malloc)(size_t sz) = malloc;
static void(*cJSON_free)(void *ptr) = free;

void cJSON_InitHooks(cJSON_Hooks* hooks)
{
    if (!hooks) { /* Reset hooks */
        cJSON_malloc = malloc;
        cJSON_free = free;
        return;
    }

    cJSON_malloc = (hooks->malloc_fn) ? hooks->malloc_fn : malloc;
    cJSON_free = (hooks->free_fn) ? hooks->free_fn : free;
}

③结点创建,删除结点

/* Internal constructor. */
static cJSON *cJSON_New_Item(void)
{
    cJSON* node = (cJSON*)cJSON_malloc(sizeof(cJSON));
    if (node) memset(node, 0, sizeof(cJSON));
    return node;
}

/* Delete a cJSON structure. */

//删除节点很简单, 先删除儿子,然后清理内存即可。


//总结一下就是对于 object 和 array 需要先删除儿子,然后删除自己。
//对于 字符串, 需要先释放字符串的内存, 再释放自己这块内存。
//对于其他节点,直接释放自己这块内存。

void cJSON_Delete(cJSON *c)
{
    cJSON *next;
    while (c)
    {
        next = c->next;
        if (!(c->type&cJSON_IsReference) && c->child) cJSON_Delete(c->child);  //
        if (!(c->type&cJSON_IsReference) && c->valuestring) cJSON_free(c->valuestring);
        if (!(c->type&cJSON_StringIsConst) && c->string) cJSON_free(c->string);
        cJSON_free(c);
        c = next;
    }
}

有了结点设置,那么下面就是具体类型结点的实现了:设置类型,设置具体类型的值

    /* These calls create a cJSON item of the appropriate type. */
    extern cJSON *cJSON_CreateNull(void);
    extern cJSON *cJSON_CreateTrue(void);
    extern cJSON *cJSON_CreateFalse(void);
    extern cJSON *cJSON_CreateBool(int b);
    extern cJSON *cJSON_CreateNumber(double num);
    extern cJSON *cJSON_CreateString(const char *string);
    extern cJSON *cJSON_CreateArray(void);
    extern cJSON *cJSON_CreateObject(void);

    /* These utilities create an Array of count items. */
    extern cJSON *cJSON_CreateIntArray(const int *numbers, int count);
    extern cJSON *cJSON_CreateFloatArray(const float *numbers, int count);
    extern cJSON *cJSON_CreateDoubleArray(const double *numbers, int count);
    extern cJSON *cJSON_CreateStringArray(const char **strings, int count);
/* Create basic types: */
cJSON *cJSON_CreateNull(void) 
{ 
    cJSON *item = cJSON_New_Item();
    if (item)
        item->type = cJSON_NULL;
    return item; 
}

/* Create Arrays: */
cJSON *cJSON_CreateIntArray(const int *numbers, int count)
{
    int i; cJSON *n = 0, *p = 0,
        *a = cJSON_CreateArray();

    for (i = 0; a && i < count; i++)
    {
        n = cJSON_CreateNumber(numbers[i]); //申请N个几点
        if (!i)
            a->child = n;//第一个结点链接使用child
        else 
            suffix_object(p, n);//其他结点 :连接prev next
        p = n;
    }return a;
}

④结点操作

    /* Append item to the specified array/object. */
    extern void cJSON_AddItemToArray(cJSON *array, cJSON *item);
    extern void cJSON_AddItemToObject(cJSON *object, const char *string, cJSON *item);
    extern void cJSON_AddItemToObjectCS(cJSON *object, const char *string, cJSON *item);    /* Use this when string is definitely const (i.e. a literal, or as good as), and will definitely survive the cJSON object */
                                                                                            

/* Append reference to item to the specified array/object. Use this when you want to add an existing cJSON to a new cJSON, 
but don't want to corrupt your existing cJSON. */
    extern void cJSON_AddItemReferenceToArray(cJSON *array, cJSON *item);
    extern void cJSON_AddItemReferenceToObject(cJSON *object, const char *string, cJSON *item);

    /* Remove/Detatch items from Arrays/Objects. */
  //Detatch脱离,使item从arr链中脱离,便于delete

    extern cJSON *cJSON_DetachItemFromArray(cJSON *array, int which);
    extern void   cJSON_DeleteItemFromArray(cJSON *array, int which);
    extern cJSON *cJSON_DetachItemFromObject(cJSON *object, const char *string);
    extern void   cJSON_DeleteItemFromObject(cJSON *object, const char *string);

    /* Update array items. */
    extern void cJSON_InsertItemInArray(cJSON *array, int which, cJSON *newitem);    /* Shifts pre-existing items to the right. */
    extern void cJSON_ReplaceItemInArray(cJSON *array, int which, cJSON *newitem);
    extern void cJSON_ReplaceItemInObject(cJSON *object, const char *string, cJSON *newitem);

注:①

Detach 是什么东西呢?
我们把一个节点从 json 树中删除, 但是不释放内存,而是先保留这个节点的指针, 这样储存在这个节点的信息都保留了下来。
接下来我们就可以做很多事了, 合适的时候添加到其他对象中, 合适的时候释放内存。
比如上面的 delete 函数, 就需要真实的删除了, 这个时候我们删除即可。
而 detach 实现也比较简单, 只是少了一步删除操作。

//将结点从结构中脱离
cJSON *cJSON_DetachItemFromArray(cJSON *array, int which) 
{
    cJSON *c = array->child;
    while (c && which>0)
        c = c->next, which--; 
    if (!c) 
        return 0;
    if (c->prev) 
        c->prev->next = c->next; 
    if (c->next)
        c->next->prev = c->prev;
    if (c == array->child)
        array->child = c->next;
    c->prev = c->next = 0;
    return c;
}
void   cJSON_DeleteItemFromArray(cJSON *array, int which) 
{ 
    cJSON_Delete(cJSON_DetachItemFromArray(array, which));
}

  ②关于以上相关皇冠体育的网址|首页,简单的增加结点就是个链表操作了,然后对于

cJSON_AddItemReferenceToArray这个皇冠体育的网址|首页说明
cJSON除了实现简单的增加结点到结构之外,还有简单考虑效率问题。
比如同时增加一个结点到两棵树中,那么如果有深浅拷贝问题时,cJSON做法是,增加一个结点为Reference类型,在另一棵树中。这里的做法可以是引用计数,写实拷贝等
我们来看看cJSON实现吧
/* Utility for handling references. */
static cJSON *create_reference(cJSON *item)
{ 
    cJSON *ref = cJSON_New_Item(); 
    if (!ref) 
        return 0; 
    memcpy(ref, item, sizeof(cJSON)); //浅拷贝所有值-->最终保存了结点的value部分
    ref->string = 0; //k-v中的值清空,以便于重新设置
    ref->type |= cJSON_IsReference;  //结点类性是具体item类型的同时也是reference
    ref->next = ref->prev = 0;  //只是当前节点的引用,去除引用的链接
    return ref; 
}

void    cJSON_AddItemReferenceToArray(cJSON *array, cJSON *item)
{ 
    cJSON_AddItemToArray(array, create_reference(item)); //创建应用结点之后加入目的数组
}
void   cJSON_ReplaceItemInArray(cJSON *array, int which, cJSON *newitem)
{
    cJSON *c = array->child;
    while (c && which>0) 
        c = c->next, which--;   //找到具体位置
    if (!c) 
        return;
    newitem->next = c->next; 
    newitem->prev = c->prev; //连入结构中
    if (newitem->next)
        newitem->next->prev = newitem;//修改后指针

    if (c == array->child)  //如果是个孩子,
        array->child = newitem;
    else 
        newitem->prev->next = newitem;  //修改后指针
    c->next = c->prev = 0;//释放被代替的结点 
    cJSON_Delete(c);    
}

⑤查找相关

/* Get Array size/item / object item. */
int    cJSON_GetArraySize(cJSON *array) 
{
    cJSON *c = array->child; 
    int i = 0; 
    while (c)
        i++, c = c->next;
    return i; 
}
cJSON *cJSON_GetArrayItem(cJSON *array, int item)
{ 
    cJSON *c = array->child; 
    while (c && item>0) 
        item--, c = c->next; 
    return c; 
}
//结构中结点的设置,需要通过变量名来查找
cJSON *cJSON_GetObjectItem(cJSON *object, const char *string) 
{ 
    cJSON *c = object->child; 
    while (c && cJSON_strcasecmp(c->string, string))
        c = c->next;
    return c; 
}

⑥总结部分:

通过以上对于cJSON结构的简单学习和剖析,我们不难联想到广义表。其实这个结构的实现就是类似广义表实现:由child递归为广义结构

标签:

cJSON

关于我们  加入我们  版权声明  商务合作  友情链接  网站地图  站长统计

脚本大全-脚本语言之家-版权所有 

Copyright (C) 2016 jiaoben.net, All Rights Reserved