【转】 cJSON 源码解析

关于cjson的介绍和使用方法就不在这里介绍了，详情请查看上一篇博客cjson使用方法。

JSON的内存结构像广义表，可以认为是有层次的双向链表。

cJSON程序中的细节点如下：

大量宏替换
大量静态函数
错误处理机制
字符串处理时存在utf16转utf9，编码转换
用函数指针封装malloc，free，方便用于处理，比如在申请后初始化，或者释放前进行一些处理等。

cJSON中的重要接口函数如下：

解析函数

cJSON * cJSON_Parse(const char *value);

打印函数

char * cJSON_Print(cJSON * item);

删除函数

void  cJSON_Delete(cJSON * c);

构造函数

create系列和add系列

解析字符串

char *parse_string(cJSON*item,const char *str)

解析数字

char *parse_number(cJSON *item,const char *num)

解析数组

char *parse_array(cJSON *item,const char *value)

解析对象

char *parse_object(cJSON *item,const char *value)

......

cjosn有两个相关的文件，一个cJSON.c和cJSON.h。我们先从头文件开始分析。

首先，我们会看到头文件的开头和结尾这样的语句：

#ifndef cJSON__h
#define cJSON__h
#ifdef __cplusplus
extern "C"
{
#endif

...

#ifdef __cplusplus
}
#endif
#endif

#ifndef cJSON_h,#define cJSON_h,#endif . 这是为了防止头文件被重复引用。

extern
"C"的主要作用就是为了能够正确实现C++代码调用其他C语言代码。加上extern
"C"后，会指示编译器这部分代码按C语言的进行编译，而不是C++的。由于C++支持函数重载，因此编译器编译函数的过程中会将函数的参数类型也加到编译后的代码中，而不仅仅是函数名；而C语言并不支持函数重载，因此编译C语言代码的函数时不会带上函数的参数类型，一般之包括函数名。

接着往下看，就会看到cjson的结构体的定义，cjson对象存储结构实际是一个结构体。

// JSON的一个value的结构体
typedef struct cJSON
{
struct cJSON *next,*prev; // 同一级的元素使用双向列表存储
struct cJSON *child; // 如果是一个object或array的话，child为第一个儿子的指针
int type; // value的类型
char *valuestring; // 如果这个value是字符串类型，则此处为字符串值
int valueint; // 如果是数字的话，整数值
double valuedouble; // 如果是数字的话，读点数值
char *string; // json对象的名称
} cJSON;

前面提到过，cjson的存储结构像一个广义表，其实也可以说是一个树，不过兄弟结点之间都通过prev和next两个指针连接起来。

prev和next分别是cjson对象的前驱和后继，属于同一级别的对象。chid则指向孩子结点，并且是第一个孩子的指针。

示例图如下：

cjson的类型宏定义：

/* cJSON Types: */
#define cJSON_False (1 << 0)
#define cJSON_True (1 << 1)
#define cJSON_NULL (1 << 2)
#define cJSON_Number (1 << 3)
#define cJSON_String (1 << 4)
#define cJSON_Array (1 << 5)
#define cJSON_Object (1 << 6)
#define cJSON_IsReference 256
#define cJSON_StringIsConst 512

这些宏定义是对结构体type的值定义，处理时只需要将type的值&255进行位运算，即可得到json里储存的数据类型。

cjson的创建：

cjson的创建的过程就是创建一个cjson结构体，再通过add一系列函数将其他孩子结点数据或同等级结点加入，将相关结点通过指针链起来。

cjson_create一系列函数:cJSON_CreateArray(),cJSON_CreateObject(),cJSON_CreateString()等函数，都是调用cJSON_New_Item()函数创建对应节点信息。函数返回一个json结构体指针。

相关代码如下:

// 将字符串添加进对象
void cJSON_AddItemToObject(cJSON *object,const char *string,cJSON *item)
{
if (!item)
return;
if (item->string)
cJSON_free(item->string); // 这个儿子之前有key，先清理
item->string=cJSON_strdup(string); // 设置key值
cJSON_AddItemToArray(object,item); // 添加儿子
}
// 将传入的字符串复制一副本并返回新的字符串指针
static char* cJSON_strdup(const char* str)
{
size_t len;
char* copy;
len = strlen(str) + 1;
// 分配空间
if (!(copy = (char*)cJSON_malloc(len)))
return 0;
// 执行复制操作
memcpy(copy,str,len);
// 返回复制的副本
return copy;
}
// 添加节点到object或array中
void cJSON_AddItemToArray(cJSON *array, cJSON *item)
{
cJSON *c=array->child;
if (!item)
return;
if (!c)
{
array->child=item; // 之前不存在儿子节点，直接添加
}
else
{
while (c && c->next) // 先找到最后一个儿子
c=c->next;
suffix_object(c,item); // 添加儿子，c是item的兄弟节点
}
}
// array的处理
static void suffix_object(cJSON *prev,cJSON *item)
{
// 两个兄弟的指针互相指向对方
prev->next=item;
item->prev=prev;
}

cjson打印：

cjson打印就是从根对象的结构体开始遍历，得到每个item结点的名称和数据，并经过处理成特定的cjson字符串的输出形式。

cJSON_Print(root)和cJSON_PrintUnformatted(root)
函数都是打印成json字符串的函数，两者的区别就是

cJSON_PrintUnformatted(root)
处理成的字符串里没有\t\n这类的格式，我们在这里以分析cJSON_Print(root)函数

为例，进行分析。

相关函数结构图如下：

相关函数如下：

typedef struct {
char *buffer;
int length;
int offset;
} printbuffer;
static int pow2gt(int x) /*返回一个比x的n(其中n是2的幂),并且是最小的幂，说白了就是将一个数后边所有的位都置1然后再+1*/
{
--x;
x |= x >> 1;
x |= x >> 2;
x |= x >> 4;
x |= x >> 8;
x |= x >> 16;
return x + 1;
}
/* ensure 函数是一个协助 printbuffer 分配内存的一个函数
* len 表示当前字符串的字符串起始偏移量即 newbuffer+p->offset 起始的
*/
static char* ensure(printbuffer *p,int needed)
{
char *newbuffer;int newsize;
if (!p || !p->buffer) return 0;//传入参数合法性检测
needed+=p->offset;//需要额外分配的内存也就是偏移量
if (needed<=p->length) return p->buffer+p->offset;//内存够用直接返回
newsize=pow2gt(needed);
newbuffer=(char*)cJSON_malloc(newsize);//malloc出新内存放buffer里面的内容
if (!newbuffer) {cJSON_free(p->buffer);p->length=0,p->buffer=0;return 0;}
if (newbuffer) memcpy(newbuffer,p->buffer,p->length);//
cJSON_free(p->buffer);//
p->length=newsize;
p->buffer=newbuffer;
return newbuffer+p->offset;//
}
char *cJSON_Print(cJSON * item)
{
return print_value(item, 0, 1, 0);
}
static char *print_value(cJSON * item, int depth, int fmt, printbuffer * p)
{
char *out = 0;
if (!item)
return 0;
if (p) {
switch ((item->type) & 255) {
case cJSON_NULL:{
out = ensure(p, 5);
if (out)
strcpy(out, "null");
break;
}
case cJSON_False:{
out = ensure(p, 6);
if (out)
strcpy(out, "false");
break;
}
case cJSON_True:{
out = ensure(p, 5);
if (out)
strcpy(out, "true");
break;
}
case cJSON_Number:
out = print_number(item, p); //打印数字函数
break;
case cJSON_String:
out = print_string(item, p); //打印字符串函数
break;
case cJSON_Array:
out = print_array(item, depth, fmt, p); //打印数组函数
break;
case cJSON_Object:
out = print_object(item, depth, fmt, p); //打印object对象类型的函数
break;
}
} else {
switch ((item->type) & 255) {
case cJSON_NULL:
out = cJSON_strdup("null");
break;
case cJSON_False:
out = cJSON_strdup("false");
break;
case cJSON_True:
out = cJSON_strdup("true");
break;
case cJSON_Number:
out = print_number(item, 0);
break;
case cJSON_String:
out = print_string(item, 0);
break;
case cJSON_Array:
out = print_array(item, depth, fmt, 0);
break;
case cJSON_Object:
out = print_object(item, depth, fmt, 0);
break;
}
}
return out;
}
static char *print_number(cJSON * item, printbuffer * p) //打印数字函数
{
char *str = 0;
double d = item->valuedouble;
if (d == 0) {
if (p)
str = ensure(p, 2);
else
str = (char *) cJSON_malloc(2); /* special case for 0. */
if (str)
strcpy(str, "0");
} else if (fabs(((double) item->valueint) - d) <= DBL_EPSILON
&& d <= INT_MAX && d >= INT_MIN) {
if (p)
str = ensure(p, 21);
else
str = (char *) cJSON_malloc(21); /* 2 ^ 64 + 1可以用21个字符表示 */
if (str)
sprintf(str, "%d", item->valueint);
} else {
if (p)
str = ensure(p, 64);
else
str = (char *) cJSON_malloc(64); /* This is a nice tradeoff. */
if (str) {
if (fpclassify(d) != FP_ZERO && !isnormal(d)) //非正常浮点数
sprintf(str, "null");
else if (fabs(floor(d) - d) <= DBL_EPSILON
&& fabs(d) < 1.0e60)
sprintf(str, "%.0f", d);
else if (fabs(d) < 1.0e-6 || fabs(d) > 1.0e9)
sprintf(str, "%e", d);
else
sprintf(str, "%f", d);
}
}
return str;
}
static char *print_string(cJSON * item, printbuffer * p) //打印字符串类型的结点
{
return print_string_ptr(item->valuestring, p);
}
static char *print_string_ptr(const char *str, printbuffer * p) //打印字符串类型的结点
{
const char *ptr;
char *ptr2, *out;
int len = 0, flag = 0;
unsigned char token;
if (!str) {
if (p)
out = ensure(p, 3);
else
out = (char *) cJSON_malloc(3);
if (!out)
return 0;
strcpy(out, "\"\""); //字符串为空
return out;
}
for (ptr = str; *ptr; ptr++)
flag |= ((*ptr > 0 && *ptr < 32) || (*ptr == '\"')
|| (*ptr == '\\')) ? 1 : 0;
if (!flag) { //对字符串中不含'\','/'，空格等字符的字符处理
len = ptr - str;
if (p)
out = ensure(p, len + 3);
else
out = (char *) cJSON_malloc(len + 3);
if (!out)
return 0;
ptr2 = out;
*ptr2++ = '\"';
strcpy(ptr2, str);
ptr2[len] = '\"';
ptr2[len + 1] = 0;
return out;
}
ptr = str;
while ((token = *ptr) && ++len) {
if (strchr("\"\\\b\f\n\r\t", token))
len++;
else if (token < 32)
len += 5;
ptr++;
}
if (p)
out = ensure(p, len + 3);
else
out = (char *) cJSON_malloc(len + 3);
if (!out)
return 0;
ptr2 = out;
ptr = str;
*ptr2++ = '\"';
while (*ptr) {
if ((unsigned char) *ptr > 31 && *ptr != '\"'
&& *ptr != '\\')
*ptr2++ = *ptr++;
else {
*ptr2++ = '\\';
switch (token = *ptr++) {
case '\\':
*ptr2++ = '\\';
break;
case '\"':
*ptr2++ = '\"';
break;
case '\b':
*ptr2++ = 'b';
break;
case '\f':
*ptr2++ = 'f';
break;
case '\n':
*ptr2++ = 'n';
break;
case '\r':
*ptr2++ = 'r';
break;
case '\t':
*ptr2++ = 't';
break;
default:
sprintf(ptr2, "u%04x", token);
ptr2 += 5;
break; /* escape and print */
}
}
}
*ptr2++ = '\"';
*ptr2++ = 0;
return out;
}
static char *print_array(cJSON * item, int depth, int fmt, printbuffer * p) //打印数组类型结点函数
{
char **entries;
char *out = 0, *ptr, *ret;
int len = 5;
cJSON *child = item->child;
int numentries = 0, i = 0, fail = 0;
size_t tmplen = 0;
/* 数组里有多少个元素 */
while (child)
numentries++, child = child->next;
/* 明确处理numentries = = 0 */ //处理空数组
if (!numentries) {
if (p)
out = ensure(p, 3);
else
out = (char *) cJSON_malloc(3);
if (out)
strcpy(out, "[]");
return out;
}
if (p) {
/* 组成数组的输出形式 */
i = p->offset;
ptr = ensure(p, 1);
if (!ptr)
return 0;
*ptr = '[';
p->offset++;
child = item->child;
while (child && !fail) {
print_value(child, depth + 1, fmt, p);
p->offset = update(p);
if (child->next) {
len = fmt ? 2 : 1;
ptr = ensure(p, len + 1);
if (!ptr)
return 0;
*ptr++ = ',';
if (fmt)
*ptr++ = ' ';
*ptr = 0;
p->offset += len;
}
child = child->next;
}
ptr = ensure(p, 2);
if (!ptr)
return 0;
*ptr++ = ']';
*ptr = 0;
out = (p->buffer) + i;
} else {
/* 分配一个指针数组存储数组里的每一个元素的打印结果 */
entries =
(char **) cJSON_malloc(numentries * sizeof(char *));
if (!entries)
return 0;
memset(entries, 0, numentries * sizeof(char *));
/* 检索所有结果: */
child = item->child;
while (child && !fail) {
ret = print_value(child, depth + 1, fmt, 0);
entries[i++] = ret;
if (ret)
len += strlen(ret) + 2 + (fmt ? 1 : 0);
else
fail = 1;
child = child->next;
}
if (!fail)
out = (char *) cJSON_malloc(len);
if (!out)
fail = 1;
if (fail) {
for (i = 0; i < numentries; i++)
if (entries[i])
cJSON_free(entries[i]);
cJSON_free(entries);
return 0;
}
/* 组成数组的输出形式. */
*out = '[';
ptr = out + 1;
*ptr = 0;
for (i = 0; i < numentries; i++) {
tmplen = strlen(entries[i]);
memcpy(ptr, entries[i], tmplen);
ptr += tmplen;
if (i != numentries - 1) {
*ptr++ = ',';
if (fmt)
*ptr++ = ' ';
*ptr = 0;
}
cJSON_free(entries[i]);
}
cJSON_free(entries);
*ptr++ = ']';
*ptr++ = 0;
}
return out;
}
/* 打印object类型结点. */
static char *print_object(cJSON * item, int depth, int fmt, printbuffer * p)
{
char **entries = 0, **names = 0;
char *out = 0, *ptr, *ret, *str;
int len = 7, i = 0, j;
cJSON *child = item->child;
int numentries = 0, fail = 0;
size_t tmplen = 0;
/* 统计有多少个子结点. */
while (child)
numentries++, child = child->next;
/* 明确处理空对象的情况*/
if (!numentries) {
if (p)
out = ensure(p, fmt ? depth + 4 : 3);
else
out = (char *) cJSON_malloc(fmt ? depth + 4 : 3);
if (!out)
return 0;
ptr = out;
*ptr++ = '{';
if (fmt) {
*ptr++ = '\n';
for (i = 0; i < depth; i++)
*ptr++ = '\t';
}
*ptr++ = '}';
*ptr++ = 0;
return out;
}
if (p) {
/* 组成输出形式: */
i = p->offset;
len = fmt ? 2 : 1;
ptr = ensure(p, len + 1);
if (!ptr)
return 0;
*ptr++ = '{';
if (fmt)
*ptr++ = '\n';
*ptr = 0;
p->offset += len;
child = item->child;
depth++;
while (child) {
if (fmt) {
ptr = ensure(p, depth);
if (!ptr)
return 0;
for (j = 0; j < depth; j++)
*ptr++ = '\t';
p->offset += depth;
}
print_string_ptr(child->string, p);
p->offset = update(p);
len = fmt ? 2 : 1;
ptr = ensure(p, len);
if (!ptr)
return 0;
*ptr++ = ':';
if (fmt)
*ptr++ = '\t';
p->offset += len;
print_value(child, depth, fmt, p);
p->offset = update(p);
len = (fmt ? 1 : 0) + (child->next ? 1 : 0);
ptr = ensure(p, len + 1);
if (!ptr)
return 0;
if (child->next)
*ptr++ = ',';
if (fmt)
*ptr++ = '\n';
*ptr = 0;
p->offset += len;
child = child->next;
}
ptr = ensure(p, fmt ? (depth + 1) : 2);
if (!ptr)
return 0;
if (fmt)
for (i = 0; i < depth - 1; i++)
*ptr++ = '\t';
*ptr++ = '}';
*ptr = 0;
out = (p->buffer) + i;
} else {
/*为对象和名称分配空间 */
entries =
(char **) cJSON_malloc(numentries * sizeof(char *));
if (!entries)
return 0;
names =
(char **) cJSON_malloc(numentries * sizeof(char *));
if (!names) {
cJSON_free(entries);
return 0;
}
memset(entries, 0, sizeof(char *) * numentries);
memset(names, 0, sizeof(char *) * numentries);
/* 将所有结果收集到数组: */
child = item->child;
depth++;
if (fmt)
len += depth;
while (child && !fail) {
names[i] = str =
print_string_ptr(child->string, 0);
entries[i++] = ret =
print_value(child, depth, fmt, 0);
if (str && ret)
len +=
strlen(ret) + strlen(str) + 2 +
(fmt ? 2 + depth : 0);
else
fail = 1;
child = child->next;
}
if (!fail)
out = (char *) cJSON_malloc(len);
if (!out)
fail = 1;
if (fail) {
for (i = 0; i < numentries; i++) {
if (names[i])
cJSON_free(names[i]);
if (entries[i])
cJSON_free(entries[i]);
}
cJSON_free(names);
cJSON_free(entries);
return 0;
}
/* 组成输出形式: */
*out = '{';
ptr = out + 1;
if (fmt)
*ptr++ = '\n';
*ptr = 0;
for (i = 0; i < numentries; i++) {
if (fmt)
for (j = 0; j < depth; j++)
*ptr++ = '\t';
tmplen = strlen(names[i]);
memcpy(ptr, names[i], tmplen);
ptr += tmplen;
*ptr++ = ':';
if (fmt)
*ptr++ = '\t';
strcpy(ptr, entries[i]);
ptr += strlen(entries[i]);
if (i != numentries - 1)
*ptr++ = ',';
if (fmt)
*ptr++ = '\n';
*ptr = 0;
cJSON_free(names[i]);
cJSON_free(entries[i]);
}
cJSON_free(names);
cJSON_free(entries);
if (fmt)
for (i = 0; i < depth - 1; i++)
*ptr++ = '\t';
*ptr++ = '}';
*ptr++ = 0;
}
return out;
}

cJSON解析：

首先，调用cJSON_Parse()函数，此函数是一个二次封装函数，其内部为cJSON_ParseWithOpts()函数，该函数用于提取更多的解析选项，如果需要，最后返回解析结束的位置。而在上面的函数中，调用parse_value()函数进行解析，而该函数首先创建cJSON_NewItem()创建节点，用于存放解析的JSON结构数据，然后根据不同的选项，调用解析函数，其为parse_string()，parse_number()，parse_array()，parse_objec()等。

结构图如下：

【转】 cJSON 源码解析的更多相关文章

cJSON源码分析
JSON (JavaScript Object Notation) 是一种常见使用的轻量级的数据交换格式,既有利于人工读写,也方便于机器的解析和生成. 关于JSON格式的定义,参看网站[1].在该网站 ...
【转】cJSON 源码分析
cJSON源码分析简介由于C语言汇总,没有直接的字典,字符串数组等数据结构,所以要借助结构体定义,处理json. JSON是一种轻量级的数据交换格式.JSON采用完全独立与语言的文本格式,易于人阅 ...
【原】Android热更新开源项目Tinker源码解析系列之三：so热更新
本系列将从以下三个方面对Tinker进行源码解析: Android热更新开源项目Tinker源码解析系列之一:Dex热更新 Android热更新开源项目Tinker源码解析系列之二:资源文件热更新 A ...
【原】Android热更新开源项目Tinker源码解析系列之一：Dex热更新
[原]Android热更新开源项目Tinker源码解析系列之一:Dex热更新 Tinker是微信的第一个开源项目,主要用于安卓应用bug的热修复和功能的迭代. Tinker github地址:http ...
【原】Android热更新开源项目Tinker源码解析系列之二:资源文件热更新
上一篇文章介绍了Dex文件的热更新流程,本文将会分析Tinker中对资源文件的热更新流程. 同Dex,资源文件的热更新同样包括三个部分:资源补丁生成,资源补丁合成及资源补丁加载. 本系列将从以下三个方 ...
多线程爬坑之路-Thread和Runable源码解析之基本方法的运用实例
前面的文章:多线程爬坑之路-学习多线程需要来了解哪些东西?(concurrent并发包的数据结构和线程池,Locks锁,Atomic原子类) 多线程爬坑之路-Thread和Runable源码解析前面 ...
jQuery2.x源码解析(缓存篇)
jQuery2.x源码解析(构建篇) jQuery2.x源码解析(设计篇) jQuery2.x源码解析(回调篇) jQuery2.x源码解析(缓存篇) 缓存是jQuery中的又一核心设计,jQuery ...
Spring IoC源码解析——Bean的创建和初始化
Spring介绍 Spring(http://spring.io/)是一个轻量级的Java 开发框架,同时也是轻量级的IoC和AOP的容器框架,主要是针对JavaBean的生命周期进行管理的轻量级容器 ...
jQuery2.x源码解析(构建篇)
jQuery2.x源码解析(构建篇) jQuery2.x源码解析(设计篇) jQuery2.x源码解析(回调篇) jQuery2.x源码解析(缓存篇) 笔者阅读了园友艾伦 Aaron的系列博客< ...

随机推荐

js 稍微判断下浏览器 pc 还是手机
function isMobile() { var a=navigator.userAgent; var ref=/.*(Android|iPhone|SymbianOS|iPad| ...
【转】JS中，中国标准时间转化为yyyy-MM-dd
'Thu May 12 2016 08:00:00 GMT+0800 (中国标准时间)'--此格式日期无法传到java后台,须格式化,方法如下 var d = new Date('Thu May 12 ...
React + js-xlsx构建Excel文件上传预览功能
首先要准备react开发环境以及js-xlsx插件 1. 此处省略安装react安装步骤 2.下载js-xlsx插件 yarn add xlsx 或者 npm install xlsx 在项目中引入 ...
Linux性能评测工具之一：gprof篇
这些天自己试着对项目作一些压力测试和性能优化,也对用过的测试工具作一些总结,并把相关的资料作一个汇总,以便以后信手拈来! 1 简介改进应用程序的性能是一项非常耗时耗力的工作,但是究竟程序中是哪些函数 ...
Flutter - 自动生成Android & iOS图标
对于要发布的app来说,做图标是一个麻烦的事,你需要知道N个图标的分辨率,然后用PhotoShop一个个修改导出. PS好图标之后,按照各自的位置放进去. ********************** ...
YY：2018互联网创业公司应看清的事情
潮流,技术,生活方式,盈利模式,消费人群几乎每年都在改变,2018,你看到的是怎样的一盘棋. 2018年是个很好的数字,很多互联网公司寄予希望在这个幸运数字年头奋起一搏,拿到一份可观的酬金.特别是一些 ...
第七组团队项目——专业课程资源共享平台——需求分析&原型设计
一.项目目标.定位需求: (1)目标:在教师.学生之间建立一个综合的.全面的.快捷的.高效的免费课程和学习资源共享.交流与推荐的开放性平台,实现多维和动态的推荐与分类检索服务. (2)定位:学生与教师 ...
理解java的三大特性之继承
学习来源:http://www.cnblogs.com/chenssy/p/3354884.html default 默认权限(包权限-同一个包可以访问) private 私有(类内部可以使用,继承的 ...
hadoop伪分布式安装之Linux环境准备
Hadoop伪分布式安装之Linux环境准备一.软件版本 VMare Workstation Pro 14 CentOS 7 32/64位二.实现Linux服务器联网功能网络适配器双击选择VMn ...
业务-----修改Service常用逻辑
注意:修改时唯一属性不能重复 //num==null 时,没有修改Num,不用考虑重复问题.//num!=null 时,修改了num.考虑重复问题 if(!StringUtils.isEmpty(re ...

【转】 cJSON 源码解析

【转】 cJSON 源码解析的更多相关文章

随机推荐

热门专题