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

cJSON序列化工具解读一(结构剖析),第1张

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

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, , 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 = , *p = ,
*a = cJSON_CreateArray(); for (i = ; 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>)
c = c->next, which--;
if (!c)
return ;
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 = ;
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 ;
memcpy(ref, item, sizeof(cJSON)); //浅拷贝所有值-->最终保存了结点的value部分
ref->string = ; //k-v中的值清空,以便于重新设置
ref->type |= cJSON_IsReference; //结点类性是具体item类型的同时也是reference
ref->next = ref->prev = ; //只是当前节点的引用,去除引用的链接
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>)
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 = ;//释放被代替的结点
cJSON_Delete(c);
}

⑤查找相关

/* Get Array size/item / object item. */
int cJSON_GetArraySize(cJSON *array)
{
cJSON *c = array->child;
int i = ;
while (c)
i++, c = c->next;
return i;
}
cJSON *cJSON_GetArrayItem(cJSON *array, int item)
{
cJSON *c = array->child;
while (c && item>)
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数据解析部分,请参考博客《cJONS序列化工具解读②(数据解析)》

欢迎分享,转载请注明来源:内存溢出

原文地址: http://outofmemory.cn/zaji/586727.html

(0)
打赏 微信扫一扫 微信扫一扫 支付宝扫一扫 支付宝扫一扫
上一篇 2022-04-12
下一篇 2022-04-12

发表评论

登录后才能评论

评论列表(0条)

保存