Chinaunix首页 | 论坛 | 博客

aaron20127的ChinaUnix博客

首页　| 　博文目录　| 　关于我

aaron20127

  • 博客访问： 313503
  • 博文数量： 82
  • 博客积分： 0
  • 博客等级： 民兵
  • 技术积分： 490
  • 用 户 组： 普通用户
  • 注册时间： 2016-06-13 10:58
文章分类

全部博文（82）

文章存档

2018年（2）

2017年（9）

2016年（71）

我的朋友
最近访客
推荐博文
相关博文
cJSON使用简介

分类： C/C++

2017-01-09 21:36:17

 cJSON使用简介

1.1 下载

下载地址：

解压后，将cJSON.h和cJSON.c单独拿出来使用。
 

1.2 实现简述

  typedef struct cJSON

  {

    struct cJSON *next;

    struct cJSON *prev;

    struct cJSON *child;

    int type;

    char *valuestring;

    int valueint;

    double valuedouble;

    char *string;

  } cJSON;

 

cJSON对象的实现采用了树形结构，每个对象是树的一个节点，每个节点由cJSON这个结构体组成，对象中的元素也由cJSON这个结构体组成。同一层的对象和元素是双向链表结构，由next和prev指针链接。不同层的对象或元素由child指针链接起来。type表示对象或元素类型，string表示对象或节点的名称。元素的值存储在valuestring,  valueint和valuedouble中。cJSON.h中有详细的注释，可参考。

其它详细可参考：

  

1.3 编译注意

编译时有可能报下边这个错误

  1. [root@192 cJSON]# make
  2. cc -std=c99 -lm -c -o cJSON.o cJSON.c
  3. cJSON.c: In function ‘cJSON_AddItemToObjectCS’:
  4. cJSON.c:1760: error: #pragma GCC diagnostic not allowed inside functions
  5. cJSON.c:1761: error: #pragma GCC diagnostic not allowed inside functions
  6. cJSON.c:1763: error: #pragma GCC diagnostic not allowed inside functions
  7. make: *** [cJSON.o] Error 1

貌似是编译器版本太低了，所以我直接将cJSON_AddItemToObjectCS函数中的#pragma GCC注释掉了，没有任何影响。


  1. void cJSON_AddItemToObjectCS(cJSON *object, const char *string, cJSON *item)
  2. {
  3.     if (!item)
  4.     {
  5.         return;
  6.     }
  7.     if (!(item->type & cJSON_StringIsConst) && item->string)
  8.     {
  9.         cJSON_free(item->string);
  10.     }
  11. //#pragma GCC diagnostic push
  12. //#pragma GCC diagnostic ignored "-Wcast-qual"
  13.     item->string = (char*)string;
  14. //#pragma GCC diagnostic pop
  15.     item->type |= cJSON_StringIsConst;
  16.     cJSON_AddItemToArray(object, item);
  17. }

  

1.4 接口使用注意

1. 打印到字符串最好使用下边的函数，直接打印到缓冲上，不需要自己释放内存。
 int cJSON_PrintPreallocated(cJSON *item,char *buf, const int len, const cjbool fmt) 
2.解析字符串最好使用下边的函数，cJSON *cJSON_Parse(const char *value)有bug，看了下边的例子就知道了。
 cJSON *cJSON_ParseWithOpts(const char *value, const char **return_parse_end, cjbool require_null_terminated)

  

1.5 测试

将cJSON.h, cJSON.c和main.c一起编译，main.c是我用来测试的代码，这个代码几乎测试了cjson的所有接口函数以备后用。也可以参考源目录中的test.c，main.c代码如下：


  1. #include <math.h>
  2. #include <stdio.h>
  3. #include <string.h>
  4. #include <stdlib.h>
  5. #include "cJSON.h"


  8. static void print_cjson_obj_value(const cJSON * obj)
  9. {
  10.     if (!obj) {
  11.         printf("NULL object!\n");
  12.     }

  14.     switch (obj->type) {
  15.         case cJSON_False:
  16.             printf("%s: false\n", obj->string);
  17.             break;
  18.         case cJSON_True:
  19.             printf("%s: true\n", obj->string);
  20.             break;
  21.         case cJSON_NULL:
  22.             printf("%s: cJSON_NULL\n", obj->string);
  23.             break;
  24.         case cJSON_Number:
  25.             printf("%s: %d, %f\n",
  26.                     obj->string, obj->valueint, obj->valuedouble);
  27.             break;
  28.         case cJSON_String:
  29.             printf("%s: %s\n",
  30.                     obj->string, obj->valuestring);
  31.             break;
  32.         case cJSON_Array:
  33.             printf("%s: cJSON_Array\n", obj->string);
  34.             break;
  35.         case cJSON_Object:
  36.             printf("%s: cJSON_Object\n", obj->string);
  37.             break;
  38.         default:
  39.             printf("unknown type\n");
  40.     }
  41. }

  43. /* *
  44.  * 字符串转换成json对象
  45.  */
  46. int test_parse_json_string_to_object()
  47. {
  48. #define MY_JSON_STRING    \
  49.     "{\"name\": \"Jack (\\\"Bee\\\") Nimble\", \
  50.         \"format\": {                     \
  51.             \"type\":      \"rect\", \
  52.             \"width\":     1920,     \
  53.             \"interlace\": true, \
  54.             \"height\": 123.1 \
  55.         },                                 \
  56.         \"brother\": [ \
  57.             \"Lea\",                     \
  58.             \"Boo\"                         \
  59.         ]                                 \
  60.     }"

  62.     /* 1. 解析，打印
  63.      (1) cJSON_Parse解析字符串为json对象
  64.      (2) cJSON_Print将json对象打包成字符串，使用之后需要释放字符串空间
  65.     */
  66.     printf("(1) parse, print\n");
  67.     cJSON * cj_root = cJSON_Parse(MY_JSON_STRING);
  68.     const char * cj_str = cJSON_Print(cj_root);
  69.     printf("%s\n\n", cj_str);
  70.     free(cj_str);

  72.     /* 2. 获取对象
  73.           (1) 如果获取的对象不存在，cJSON_GetObjectItem返回为空
  74.           (2) cJSON_GetObjectItem只能获得当前对象的元素，不能获取前对象的元素中的对象
  75.               例如
  76.                    cJSON_GetObjectItem(cj_root,"format");不为空
  77.                    cJSON_GetObjectItem(cj_root,"type");为空
  78.           (3) 判断对象是否存在不使用cJSON_HasObjectItem()，直接判断cJSON_GetObjectItem()返回的指针是否为空
  79.     */
  80.     printf("(2) get object\n");
  81.     cJSON * format = cJSON_GetObjectItem(cj_root, "format");
  82.     cJSON * brother = cJSON_GetObjectItem(cj_root, "brother");
  83.     cJSON * type = cJSON_GetObjectItem(cj_root, "type");
  84.     printf("format [%p]\n", format);
  85.     printf("brother [%p]\n", brother);
  86.     printf("type [%p]\n", type);
  87.     
  88.     /* 3. 获取对象的值
  89.           (1) 每个对象是由cJSON结构体组成
  90.      (2) cJSON_Number包括整形和浮点型
  91.      (3) 打印数组对象的值先判断数组长度，再打印。或者使用cJSON_ArrayForEach宏，后一个遍历速度更快
  92.      (4) json使用完之后需要释放其空间
  93.     */

  95.     printf("\n(3) get object value\n");
  96.     print_cjson_obj_value(cJSON_GetObjectItem(cj_root, "name"));
  97.     print_cjson_obj_value(cJSON_GetObjectItem(format, "type"));
  98.     print_cjson_obj_value(cJSON_GetObjectItem(format, "width"));
  99.     print_cjson_obj_value(cJSON_GetObjectItem(format, "interlace"));
  100.     print_cjson_obj_value(cJSON_GetObjectItem(format, "height"));

  102. #if 0
  103.     int size = cJSON_GetArraySize(brother);
  104.     for (int i = 0; i < size; i++) {
  105.         print_cjson_obj_value(cJSON_GetArrayItem(brother, i));
  106.     }
  107. #else
  108.     cJSON * pos = NULL;
  109.     cJSON_ArrayForEach(pos, brother) {
  110.         print_cjson_obj_value(pos);
  111.     }
  112. #endif

  114.     /* *
  115.      * cjson使用完成之后需要释放空间
  116.      */
  117.     cJSON_Delete(cj_root);
  118.     
  119. #undef MY_JSON_STRING
  120. }

  122. /* *
  123.  * json对象转化成字符串
  124.  */
  125. int test_pack_json_object_to_string()
  126. {

  128.     /*
  129.      (1) 创建json对像，要先使用cJSON_CreateObject()创建一个根对象
  130.      (2) 在使用cJSON_AddItemToObject()添加各种对象到根对象中。也可以直接使用头文件提供的宏来添加对象和值，如下
  131.          cJSON_AddNullToObject(object,name)
  132.         cJSON_AddTrueToObject(object,name)
  133.         cJSON_AddFalseToObject(object,name)
  134.         cJSON_AddBoolToObject(object,name,b)
  135.         cJSON_AddNumberToObject(object,name,n)
  136.         cJSON_AddStringToObject(object,name,s)
  137.     */

  139.     cJSON * root = NULL;
  140.     cJSON * format = NULL;
  141.     cJSON * brother = NULL;
  142.     root = cJSON_CreateObject();
  143.     cJSON_AddStringToObject(root, "name", "Jack (\"Bee\") Nimble");
  144.     cJSON_AddItemToObject(root, "format", format=cJSON_CreateObject());
  145.     cJSON_AddItemToObject(root, "brother", brother=cJSON_CreateArray());

  147.     /* 普通对象中插入对象和值 */
  148.     {
  149.         cJSON_AddStringToObject(format, "type", "rect");
  150.         cJSON_AddFalseToObject(format, "interlace");
  151.         cJSON_AddNumberToObject(format, "width", 1920);    
  152.         cJSON_AddNumberToObject(format, "height", 1920.11);
  153.         cJSON_AddBoolToObject(format, "flag", 1);
  154.     }

  156.     /* 数组中插入对象和值 */
  157.     {    
  158.         cJSON_AddItemToArray(brother,cJSON_CreateString("Lea"));
  159.         cJSON_AddItemToArray(brother,cJSON_CreateString("Boo"));
  160.     }

  162.     const char * cj_str = cJSON_Print(root);
  163.     printf("%s\n\n", cj_str);
  164.     free(cj_str);

  166.     /* *
  167.      * cjson使用完成之后需要释放空间
  168.      */
  169.     cJSON_Delete(root);
  170. }

  172. void print_cjson_string(const char * describe, const char *cj_str)
  173. {
  174.     printf("%s\n%s\n\n", describe, cj_str);
  175.     free(cj_str);
  176. }

  178. /* *
  179.  * 使用cjson提供的其它接口操作，都在cJSON.h中
  180.  */
  181. int test_cjson_operation()
  182. {
  183. #define MY_JSON_STRING    \
  184.         "{\"name\": \"Lee\"}"

  186.     /* *
  187.      (1) cJSON_PrintUnformatted打印出的json字符串是紧凑的不用换行，适合传输json字符串时使用
  188.      (2) cJSON_PrintBuffered可以事先指定分配一个缓冲区，如果足够大，则可以节省不断重新分配空间的时间；
  189.          如果指定缓冲区过小，则与cJSON_Print和cJSON_PrintUnformatted性能能相同。
  190.      (3) cJSON_PrintPreallocated可以将json字符串填入给定的缓冲区，并指定缓冲区大小。
  191.          成功返回1，失败返回0。除了这个打印json字符串的函数，以上的函数在生成json字符串时若空间不足，
  192.          都会重新分配一次空间。     
  193.      */
  194.     cJSON * root = cJSON_Parse(MY_JSON_STRING);
  195.     print_cjson_string("(1) cJSON_PrintUnformatted",
  196.                  cJSON_PrintUnformatted(root));
  197.     print_cjson_string("(2) cJSON_PrintBuffered",
  198.                  cJSON_PrintBuffered(root, 1, 1));
  199.     print_cjson_string("(3) cJSON_PrintBuffered",
  200.                  cJSON_PrintBuffered(root, 1, 0));
  201. #define BUF_LEN 1024
  202.     char buf[BUF_LEN] = {0};
  203.     if (0 == cJSON_PrintPreallocated(root, buf, BUF_LEN, 0)) {
  204.         printf("(4) cJSON_PrintPreallocated\nfail\n\n");
  205.     } else {
  206.         printf("(4) cJSON_PrintPreallocated\n%s\n\n", buf);
  207.     }
  208. #undef BUF_LEN

  210.     /* *
  211.      (4) cJSON_GetErrorPtr可以获取字符串解析函数cJSON_Parse出错时的字符位置。
  212.      如果解析没有错误，则返回NULL。
  213.      */

  215.     printf("(5) cJSON_GetErrorPtr\n");
  216.     const cJSON * cj_tmp = cJSON_Parse("{\"haha\":12,, \"xixi\":34}");
  217.     printf("[%s]\n\n", cJSON_GetErrorPtr());

  219.     /* *
  220.      (5) cJSON_CreateIntArray, cJSON_CreateFloatArray, cJSON_CreateDoubleArray和cJSON_CreateStringArray
  221.      这4个函数可以直接将数组转换成json数组对象
  222.      */
  223.     int intarray[4] = {0, 1, 2, 3};
  224.     cJSON_AddItemToObject(root, "intarray",cJSON_CreateIntArray(intarray, 4));
  225.     print_cjson_string("(6) cJSON_CreateIntArray",cJSON_Print(root));

  227.     /* *
  228.      (6) cJSON_AddItemToObjectCS中的string参数是一个字符串常量，不需要为string分配空间。
  229.          感觉没什么用。
  230.      */
  231.     const char * con_str = "haha";
  232.     cJSON_AddItemToObjectCS(root, con_str, cJSON_CreateString("go"));
  233.     print_cjson_string("(7) cJSON_AddItemToObjectCS",cJSON_Print(root));

  235.     /* *
  236.      (7) cJSON_AddItemReferenceToObject和cJSON_AddItemReferenceToArray
  237.          将一个json对象引用到另一个json对象上，只拷贝了被引用对象的根节点,并不是复制所有节点到另一个json对象。
  238.      */
  239.     
  240.     cJSON * n_root = cJSON_CreateObject();
  241.     cJSON_AddItemReferenceToObject(n_root, "n_intarray",
  242.                                  cJSON_GetObjectItem(root,"intarray"));
  243.     print_cjson_string("(8) cJSON_AddItemReferenceToObject",cJSON_Print(n_root));

  245.     /* *
  246.      (8) cJSON_DetachItemFromArray, cJSON_DeleteItemFromArray, cJSON_DetachItemFromObject, cJSON_DeleteItemFromObject
  247.          cJSON_DetachItemFromArray是从json数组对象中分离出来第n个节点，cJSON_DeleteItemFromArray是删除json数组对象的第n个节点
  248.          cJSON_DetachItemFromObject是分离任意节点，cJSON_DeleteItemFromObject是删除任意节点
  249.      */
  250.     cJSON_DeleteItemFromArray(cJSON_GetObjectItem(root,"intarray"), 2);
  251.     print_cjson_string("(9) cJSON_DeleteItemFromArray",cJSON_Print(root));    

  253.     /* *
  254.      (9) cJSON_InsertItemInArray 插入节点到数组中
  255.          cJSON_ReplaceItemInArray 替换数组中的第n个节点
  256.          cJSON_ReplaceItemInObject 替换任意节点
  257.      */
  258.     cJSON_InsertItemInArray(cJSON_GetObjectItem(root,"intarray"),
  259.                              2, cJSON_CreateNumber(2));
  260.       cJSON_ReplaceItemInObject(root, "name", cJSON_CreateString("Bluce"));
  261.        print_cjson_string("(10) cJSON_DeleteItemFromArray",cJSON_Print(root));

  263.        /* *
  264.      (10) cJSON_InsertItemInArray 插入节点到数组中
  265.          cJSON_ReplaceItemInArray 替换数组中的第n个节点
  266.          cJSON_ReplaceItemInObject 替换任意节点
  267.      */
  268.     cJSON_InsertItemInArray(cJSON_GetObjectItem(root,"intarray"),
  269.                              2, cJSON_CreateNumber(2));
  270.       cJSON_ReplaceItemInObject(root, "name", cJSON_CreateString("Bluce"));
  271.        print_cjson_string("(11) cJSON_DeleteItemFromArray",cJSON_Print(root));    

  273.        /* *
  274.      (11) cJSON_Duplicate recurse为1表示递归复制一个json对象。
  275.      */
  276.        cJSON * cj_duplicate = cJSON_Duplicate(root, 1);
  277.     print_cjson_string("(12) cJSON_Duplicate",cJSON_Print(cj_duplicate));     

  279.        /* *
  280.      (12) cJSON_ParseWithOpts
  281.          该函数是cJSON_Parse的实现，但是它比cJSON_Parse更灵活。
  282.          1.如果cJSON_Parse解析错误，必须调用cJSON_GetErrorPtr找到解析错误位置
  283.          2.cJSON_Parse解析不严谨，如"{\"name\": \"Lee\"} }"这个字符串，后边多了一个大括号，但还是解析成功了。
  284.          3.cJSON_ParseWithOpts的return_parse_end参数可以获取解析失败的位置，
  285.           require_null_terminated参数为1会检查剩余未解析字符串是否是空字符串，
  286.           若不为空字符串，则会释放内存，返回空。
  287.           @所以因该使用cJSON_ParseWithOpts解析json对象
  288.      */
  289.     {
  290.         printf("(13) cJSON_ParseWithOpts\n");
  291.         char * end = NULL;
  292.      cJSON * cj_ParseWithOpts = cJSON_ParseWithOpts("{\"name\": \"Lee\"} }", &end, 1);
  293.      if (cj_ParseWithOpts) {
  294.             printf("%s\n\n", cJSON_Print(cj_ParseWithOpts));
  295.      } else {
  296.             printf("[%s]\n\n", end);
  297.      }
  298.     }
  299.     
  300.     {
  301.         printf("(14) cJSON_Parse\n");
  302.         char * end = NULL;
  303.      cJSON * cj_ParseWithOpts = cJSON_Parse("{\"name\": \"Lee\"} }");
  304.      if (cj_ParseWithOpts) {
  305.             printf("%s\n\n", cJSON_Print(cj_ParseWithOpts));
  306.      } else {
  307.             printf("[%s]\n\n", end);
  308.      }
  309.     }

  311.     /* *
  312.      (12) cJSON_SetIntValue和cJSON_SetNumberValue相同，
  313.           既可以设置整形值，也可以设置double类型值。
  314.      */
  315.     printf("(15) cJSON_SetIntValue\n");
  316.     cJSON * int_cj = cJSON_CreateNumber(1);
  317.     printf("%s\n", cJSON_Print(int_cj));
  318.     cJSON_SetIntValue(int_cj, 1.1);
  319.     printf("%s\n\n", cJSON_Print(int_cj));

  321.     cJSON_Delete(root);
  322. }


  325. int main()
  326. {
  327.     //将json字符串解析成json对象
  328.     printf("<< test_parse_json_string_to_object >>\n");
  329.     test_parse_json_string_to_object();

  331.     //将生成json对象，并将json对象组成字符串
  332.     printf("\n<< test_pack_json_object_to_string >>\n");
  333.     test_pack_json_object_to_string();

  335.     //其它一些json接口测试
  336.     printf("<< test_cjson_operation >>\n");
  337.     test_cjson_operation();
  338.     return 0;
  339. }

结果：

  1. [root@192 cJSON]# ./main
  2. << test_parse_json_string_to_object >>
  3. (1) parse, print
  4. {
  5.         "name": "Jack (\"Bee\") Nimble",
  6.         "format": {
  7.                 "type": "rect",
  8.                 "width": 1920,
  9.                 "interlace": true,
  10.                 "height": 123.100000
  11.         },
  12.         "brother": ["Lea", "Boo"]
  13. }

  15. (2) get object
  16. format [0x9a87080]
  17. brother [0x9a871a8]
  18. type [(nil)]

  20. (3) get object value
  21. name: Jack ("Bee") Nimble
  22. type: rect
  23. width: 1920, 1920.000000
  24. interlace: true
  25. height: 123, 123.100000
  26. (null): Lea
  27. (null): Boo

  29. << test_pack_json_object_to_string >>
  30. {
  31.         "name": "Jack (\"Bee\") Nimble",
  32.         "format": {
  33.                 "type": "rect",
  34.                 "interlace": false,
  35.                 "width": 1920,
  36.                 "height": 1920.110000,
  37.                 "flag": true
  38.         },
  39.         "brother": ["Lea", "Boo"]
  40. }

  42. << test_cjson_operation >>
  43. (1) cJSON_PrintUnformatted
  44. {"name":"Lee"}

  46. (2) cJSON_PrintBuffered
  47. {
  48.         "name": "Lee"
  49. }

  51. (3) cJSON_PrintBuffered
  52. {"name":"Lee"}

  54. (4) cJSON_PrintPreallocated
  55. {"name":"Lee"}

  57. (5) cJSON_GetErrorPtr
  58. [, "xixi":34}]

  60. (6) cJSON_CreateIntArray
  61. {
  62.         "name": "Lee",
  63.         "intarray": [0, 1, 2, 3]
  64. }

  66. (7) cJSON_AddItemToObjectCS
  67. {
  68.         "name": "Lee",
  69.         "intarray": [0, 1, 2, 3],
  70.         "haha": "go"
  71. }

  73. (8) cJSON_AddItemReferenceToObject
  74. {
  75.         "n_intarray": [0, 1, 2, 3]
  76. }

  78. (9) cJSON_DeleteItemFromArray
  79. {
  80.         "name": "Lee",
  81.         "intarray": [0, 1, 3],
  82.         "haha": "go"
  83. }

  85. (10) cJSON_DeleteItemFromArray
  86. {
  87.         "name": "Bluce",
  88.         "intarray": [0, 1, 2, 3],
  89.         "haha": "go"
  90. }

  92. (11) cJSON_DeleteItemFromArray
  93. {
  94.         "name": "Bluce",
  95.         "intarray": [0, 1, 2, 2, 3],
  96.         "haha": "go"
  97. }

  99. (12) cJSON_Duplicate
  100. {
  101.         "name": "Bluce",
  102.         "intarray": [0, 1, 2, 2, 3],
  103.         "haha": "go"
  104. }

  106. (13) cJSON_ParseWithOpts
  107. [}]

  109. (14) cJSON_Parse
  110. {
  111.         "name": "Lee"
  112. }

  114. (15) cJSON_SetIntValue
  115. 1
  116. 1.100000


阅读(24779) | 评论(0) | 转发(0) |
2

上一篇：gcc编译时去掉__LINE__的绝对路径

下一篇：C语言中使用双向循环链表

给主人留下些什么吧！~~
关于我们 | 关于IT168 | 联系方式 | 广告合作 | 法律声明 | 免费注册

Copyright 2001-2010 ChinaUnix.net All Rights Reserved 北京皓辰网域网络信息技术有限公司. 版权所有

感谢所有关心和支持过ChinaUnix的朋友们

16024965号-6