分享web开发知识

注册/登录|最近发布|今日推荐

主页 IT知识网页技术软件开发前端开发代码编程运营维护技术分享教程案例
当前位置：首页 > 教程案例

【转】 cJSON 源码解析

发布时间：2023-09-06 01:33责任编辑：苏小强关键词：暂无标签

关于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。我们先从头文件开始分析。

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

  1. #ifndefcJSON__h
  2. #definecJSON__h
  4. #ifdef__cplusplus
  5. extern"C"
  6. {
  7. #endif

...

...

  1. #ifdef__cplusplus
  2. }
  3. #endif
  5. #endif




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

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


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

  1. //JSON的一个value的结构体
  2. typedefstructcJSON
  3. {
  4. structcJSON*next,*prev;//同一级的元素使用双向列表存储
  5. structcJSON*child;//如果是一个object或array的话，child为第一个儿子的指针
  7. inttype;//value的类型
  9. char*valuestring;//如果这个value是字符串类型，则此处为字符串值
  10. intvalueint;//如果是数字的话，整数值
  11. doublevaluedouble;//如果是数字的话，读点数值
  13. char*string;//json对象的名称
  14. }cJSON;






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

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


示例图如下：



cjson的类型宏定义：

  1. /*cJSONTypes:*/
  2. #definecJSON_False(1<<0)
  3. #definecJSON_True(1<<1)
  4. #definecJSON_NULL(1<<2)
  5. #definecJSON_Number(1<<3)
  6. #definecJSON_String(1<<4)
  7. #definecJSON_Array(1<<5)
  8. #definecJSON_Object(1<<6)
  10. #definecJSON_IsReference256
  11. #definecJSON_StringIsConst512


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


cjson的创建：

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

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

相关函数如下:

  1. staticcJSON*cJSON_New_Item(void)//创建json结构体
  2. {
  3. cJSON*node=(cJSON*)cJSON_malloc(sizeof(cJSON));
  5. if(node)
  6. memset(node,0,sizeof(cJSON));//初始化结构体
  7. returnnode;
  8. }
  9. cJSON*cJSON_CreateNull(void)
  10. {
  11. cJSON*item=cJSON_New_Item();
  13. if(item)
  14. item->type=cJSON_NULL;
  15. returnitem;
  16. }
  18. cJSON*cJSON_CreateTrue(void)
  19. {
  20. cJSON*item=cJSON_New_Item();
  22. if(item)
  23. item->type=cJSON_True;
  24. returnitem;
  25. }
  27. cJSON*cJSON_CreateFalse(void)
  28. {
  29. cJSON*item=cJSON_New_Item();
  31. if(item)
  32. item->type=cJSON_False;
  33. returnitem;
  34. }
  36. cJSON*cJSON_CreateBool(intb)
  37. {
  38. cJSON*item=cJSON_New_Item();
  40. if(item)
  41. item->type=b?cJSON_True:cJSON_False;
  42. returnitem;
  43. }
  45. cJSON*cJSON_CreateNumber(doublenum)
  46. {
  47. cJSON*item=cJSON_New_Item();
  49. if(item){
  50. item->type=cJSON_Number;
  51. item->valuedouble=num;
  52. item->valueint=(int)num;
  53. }
  54. returnitem;
  55. }
  57. cJSON*cJSON_CreateString(constchar*string)
  58. {
  59. cJSON*item=cJSON_New_Item();
  61. if(item){
  62. item->type=cJSON_String;
  63. item->valuestring=cJSON_strdup(string);
  64. }
  65. returnitem;
  66. }
  68. cJSON*cJSON_CreateArray(void)
  69. {
  70. cJSON*item=cJSON_New_Item();
  72. if(item)
  73. item->type=cJSON_Array;
  74. returnitem;
  75. }
  77. cJSON*cJSON_CreateObject(void)
  78. {
  79. cJSON*item=cJSON_New_Item();
  81. if(item)
  82. item->type=cJSON_Object;
  83. returnitem;
  84. }


创建完一个根结点结构体后，接下来就是向根结点中加入元素。

从头文件我们发现，

  • //创建一个string值为name的cJSON_Null节点，并添加到object
  • #definecJSON_AddNullToObject(object,name)cJSON_AddItemToObject(object,name,cJSON_CreateNull())
  • //创建一个string值为name的cJSON_True节点，并添加到object
  • #definecJSON_AddTrueToObject(object,name)cJSON_AddItemToObject(object,name,cJSON_CreateTrue())
  • //创建一个string值为name的cJSON_False节点，并添加到object
  • #definecJSON_AddFalseToObject(object,name)cJSON_AddItemToObject(object,name,cJSON_CreateFalse())
  • //创建一个string值为name的cJSON_CreateBool节点，并添加到object。b非0为cJSON_True，0为cJSON_False。
  • #definecJSON_AddBoolToObject(object,name,b)cJSON_AddItemToObject(object,name,cJSON_CreateBool(b))
  • //创建一个string值为name，valuedouble为n，valueint为（int）n的cJSON_Number节点，并添加到object。
  • #definecJSON_AddNumberToObject(object,name,n)cJSON_AddItemToObject(object,name,cJSON_CreateNumber(n))
  • //创建一个string值为name，valuestring为s的cJSON_String节点，并添加到object。
  • #definecJSON_AddStringToObject(object,name,s)cJSON_AddItemToObject(object,name,cJSON_CreateString(s))


过程是调用cJSON_AddItemToObject()并结合不同的对象类型增加节点名称和子节点。然后在其中调用cJSON_AddItemToArray()函数来添加信息，此函数中判断对象孩子结点是否为NULL，如果是NULL，则直接插入，否则找到最后一个孩子，调用suffix_object()函数添加到双向链表的尾部。

示例图如下:



相关代码如下:

  1. //将字符串添加进对象
  2. voidcJSON_AddItemToObject(cJSON*object,constchar*string,cJSON*item)
  3. {
  4. if(!item)
  5. return;
  6. if(item->string)
  7. cJSON_free(item->string);//这个儿子之前有key，先清理
  8. item->string=cJSON_strdup(string);//设置key值
  9. cJSON_AddItemToArray(object,item);//添加儿子
  10. }
  12. //将传入的字符串复制一副本并返回新的字符串指针
  13. staticchar*cJSON_strdup(constchar*str)
  14. {
  15. size_tlen;
  16. char*copy;
  18. len=strlen(str)+1;
  19. //分配空间
  20. if(!(copy=(char*)cJSON_malloc(len)))
  21. return0;
  22. //执行复制操作
  23. memcpy(copy,str,len);
  24. //返回复制的副本
  25. returncopy;
  26. }
  28. //添加节点到object或array中
  29. voidcJSON_AddItemToArray(cJSON*array,cJSON*item)
  30. {
  31. cJSON*c=array->child;
  32. if(!item)
  33. return;
  34. if(!c)
  35. {
  36. array->child=item;//之前不存在儿子节点，直接添加
  37. }
  38. else
  39. {
  40. while(c&&c->next)//先找到最后一个儿子
  41. c=c->next;
  42. suffix_object(c,item);//添加儿子，c是item的兄弟节点
  43. }
  44. }
  46. //array的处理
  47. staticvoidsuffix_object(cJSON*prev,cJSON*item)
  48. {
  49. //两个兄弟的指针互相指向对方
  50. prev->next=item;
  51. item->prev=prev;
  52. }

cjson打印：

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

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

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

为例，进行分析。


相关函数结构图如下：




相关函数如下：

  1. typedefstruct{
  2. char*buffer;
  3. intlength;
  4. intoffset;
  5. }printbuffer;
  9. staticintpow2gt(intx)/*返回一个比x的n(其中n是2的幂),并且是最小的幂，说白了就是将一个数后边所有的位都置1然后再+1*/
  10. {
  11. --x;
  12. x|=x>>1;
  13. x|=x>>2;
  14. x|=x>>4;
  15. x|=x>>8;
  16. x|=x>>16;
  17. returnx+1;
  18. }
  20. /*ensure函数是一个协助printbuffer分配内存的一个函数
  21. *len表示当前字符串的字符串起始偏移量即newbuffer+p->offset起始的
  22. */
  24. staticchar*ensure(printbuffer*p,intneeded)
  25. {
  26. char*newbuffer;intnewsize;
  27. if(!p||!p->buffer)return0;//传入参数合法性检测
  28. needed+=p->offset;//需要额外分配的内存也就是偏移量
  29. if(needed<=p->length)returnp->buffer+p->offset;//内存够用直接返回
  30. newsize=pow2gt(needed);
  31. newbuffer=(char*)cJSON_malloc(newsize);//malloc出新内存放buffer里面的内容
  32. if(!newbuffer){cJSON_free(p->buffer);p->length=0,p->buffer=0;return0;}
  33. if(newbuffer)memcpy(newbuffer,p->buffer,p->length);//
  34. cJSON_free(p->buffer);//
  35. p->length=newsize;
  36. p->buffer=newbuffer;
  37. returnnewbuffer+p->offset;//
  38. }
  40. char*cJSON_Print(cJSON*item)
  41. {
  42. returnprint_value(item,0,1,0);
  43. }
  45. staticchar*print_value(cJSON*item,intdepth,intfmt,printbuffer*p)
  46. {
  47. char*out=0;
  49. if(!item)
  50. return0;
  51. if(p){
  52. switch((item->type)&255){
  53. casecJSON_NULL:{
  54. out=ensure(p,5);
  55. if(out)
  56. strcpy(out,"null");
  57. break;
  58. }
  59. casecJSON_False:{
  60. out=ensure(p,6);
  61. if(out)
  62. strcpy(out,"false");
  63. break;
  64. }
  65. casecJSON_True:{
  66. out=ensure(p,5);
  67. if(out)
  68. strcpy(out,"true");
  69. break;
  70. }
  71. casecJSON_Number:
  72. out=print_number(item,p);//打印数字函数
  73. break;
  74. casecJSON_String:
  75. out=print_string(item,p);//打印字符串函数
  76. break;
  77. casecJSON_Array:
  78. out=print_array(item,depth,fmt,p);//打印数组函数
  79. break;
  80. casecJSON_Object:
  81. out=print_object(item,depth,fmt,p);//打印object对象类型的函数
  82. break;
  83. }
  84. }else{
  85. switch((item->type)&255){
  86. casecJSON_NULL:
  87. out=cJSON_strdup("null");
  88. break;
  89. casecJSON_False:
  90. out=cJSON_strdup("false");
  91. break;
  92. casecJSON_True:
  93. out=cJSON_strdup("true");
  94. break;
  95. casecJSON_Number:
  96. out=print_number(item,0);
  97. break;
  98. casecJSON_String:
  99. out=print_string(item,0);
  100. break;
  101. casecJSON_Array:
  102. out=print_array(item,depth,fmt,0);
  103. break;
  104. casecJSON_Object:
  105. out=print_object(item,depth,fmt,0);
  106. break;
  107. }
  108. }
  109. returnout;
  110. }
  113. staticchar*print_number(cJSON*item,printbuffer*p)//打印数字函数
  114. {
  115. char*str=0;
  116. doubled=item->valuedouble;
  118. if(d==0){
  119. if(p)
  120. str=ensure(p,2);
  121. else
  122. str=(char*)cJSON_malloc(2);/*specialcasefor0.*/
  123. if(str)
  124. strcpy(str,"0");
  125. }elseif(fabs(((double)item->valueint)-d)<=DBL_EPSILON
  126. &&d<=INT_MAX&&d>=INT_MIN){
  127. if(p)
  128. str=ensure(p,21);
  129. else
  130. str=(char*)cJSON_malloc(21);/*2^64+1可以用21个字符表示*/
  131. if(str)
  132. sprintf(str,"%d",item->valueint);
  133. }else{
  134. if(p)
  135. str=ensure(p,64);
  136. else
  137. str=(char*)cJSON_malloc(64);/*Thisisanicetradeoff.*/
  138. if(str){
  139. if(fpclassify(d)!=FP_ZERO&&!isnormal(d))//非正常浮点数
  140. sprintf(str,"null");
  141. elseif(fabs(floor(d)-d)<=DBL_EPSILON
  142. &&fabs(d)<1.0e60)
  143. sprintf(str,"%.0f",d);
  144. elseif(fabs(d)<1.0e-6||fabs(d)>1.0e9)
  145. sprintf(str,"%e",d);
  146. else
  147. sprintf(str,"%f",d);
  148. }
  149. }
  150. returnstr;
  151. }
  154. staticchar*print_string(cJSON*item,printbuffer*p)//打印字符串类型的结点&nbs

知识推荐

我的编程学习网——分享web前端后端开发技术知识。 垃圾信息处理邮箱 tousu563@163.com 网站地图
icp备案号 闽ICP备2023006418号-8 不良信息举报平台 互联网安全管理备案 Copyright 2023 www.wodecom.cn All Rights Reserved