文章目录

  • 综述
  • API
    • cJSON结构体
    • 数据的封装
    • Json 对象操作
    • Json 数组操作
    • 序列化
    • Json 字符串的解析
    • 内存释放
  • Json 数据的封装
    • Json 对象操作举例
    • Json 数组操作举例
    • Json 对象、数组嵌套使用
  • 解析 Json 字符串
    • 解析 Json 对象
    • 解析嵌套的 Json 对象
    • 解析 Json 数组
    • 解析嵌套的 Json 对象和数组

综述

  • JSON： JavaScript Object Notation(JavaScript 对象表示法)，是轻量级的存储和交换文本信息的语法，类似 XML . 特点是纯文本（纯字符串）、层级结构、使用数组。
  • cJSON：一个基于 C 语言的 Json 库，下载地址：https://github.com/DaveGamble/cJSON
  • cJSON的源码文件只有两个： cJSON.h 和 cJSON.c
  • 在 cJSON 库中节点的从属关系是通过树来维护的，每一层节点都是通过链表来维护的，这样就能分析出该函数参数的含义，每个对象是树的一个节点，每个节点由cJSON这个结构体组成，对象中的元素也可以由cJSON这个结构体组成，由child指针指向该结构体

API

cJSON结构体

typedef struct cJSON { struct cJSON *next,*prev;//遍历数组或对象链的前向或后向链表指针 struct cJSON *child; //数组或对象的孩子节点 int type; //key的类型 char *valuestring; // value值是字符串类型 int valueint;// value值是整型类型 double valuedouble; // value值是浮点数类型 char *string;// key的名字} cJSON;

结构体成员：

  • cJOSN 结构体是一个双向链表，并且可通过child 指针访问下一层。同一层的对象和元素是双向链表结构，由next和prev指针链接。不同层的对象或元素由child指针链接起来。
  • 结构体成员 type 变量用于描述数据元素的类型（如果是键值对表示 value 值的类型），数据元素可以是字符串、整形、浮点型。
    • 如果是整形值的话可通过 valueint 将值取出
    • 如果是浮点型的话可通过 valuedouble 将值取出
    • 如果是字符串类型的话可通过 valuestring 将值取出
  • 结构体成员 string 表示键值对中键值的名称。

节点类型值：7种

/* cJSON Types: */#define cJSON_False 0#define cJSON_True1#define cJSON_NULL2#define cJSON_Number3#define cJSON_String4#define cJSON_Array 5#define cJSON_Object6#define cJSON_Raw 7 /* raw json */

数据的封装

在 cJSON.h 头文件中可以看到一些函数声明，通过调用这些创建函数就可以将 Json 支持的数据类型封装为 cJSON 结构体类型：

// 空值类型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);

创建数组或对象：

// json数组(创建空数组)extern cJSON *cJSON_CreateArray(void);// json对象(创建空对象)extern cJSON *cJSON_CreateObject(void);

cJSON_CreateObject()和cJSON_CreateArray函数创造的数据不使用时需要使用cJSON_Delete()释放空间

在创建数组的同时还可以进行初始化：

// 创建一个Json数组, 元素为整形extern cJSON *cJSON_CreateIntArray(const int *numbers,int count);// 创建一个Json数组, 元素为浮点【这个使用会出问题，需要浮点型可以使用双浮点。】extern cJSON *cJSON_CreateFloatArray(const float *numbers,int count);// 创建一个Json数组, 元素为双浮点型extern cJSON *cJSON_CreateDoubleArray(const double *numbers,int count);// 创建一个Json数组, 元素为字符串类型【这个使用会出问题】extern cJSON *cJSON_CreateStringArray(const char **strings,int count);

Json 对象操作

当得到一个 Json 对象之后，就可以往对象中添加键值对了

extern void cJSON_AddItemToObject(cJSON *object,const char *string,cJSON *item);

参数：

  • object：要添加的键值对从属于那个节点
  • string：添加的键值对的键值
  • item：添加的键值对的 value 值（需要先将其封装为 cJSON 类型的结构体）

在 cJSON 库中节点的从属关系是通过树来维护的，每一层节点都是通过链表来维护的，这样就能分析出该函数参数的含义

为了让操作更加方便，cJson 库还提供了一些宏函数，方便快速的往 Json 对象中添加键值对：

#define cJSON_AddNullToObject(object,name)cJSON_AddItemToObject(object, name, cJSON_CreateNull()) //在对象中添加null#define cJSON_AddTrueToObject(object,name)cJSON_AddItemToObject(object, name, cJSON_CreateTrue()) //在对象中添加true#define cJSON_AddFalseToObject(object,name) cJSON_AddItemToObject(object, name, cJSON_CreateFalse()) //在对象中添加false#define cJSON_AddBoolToObject(object,name,b)cJSON_AddItemToObject(object, name, cJSON_CreateBool(b)) //在对象中添加布尔值#define cJSON_AddNumberToObject(object,name,n)cJSON_AddItemToObject(object, name, cJSON_CreateNumber(n))//在对象中添加数字#define cJSON_AddStringToObject(object,name,s)cJSON_AddItemToObject(object, name, cJSON_CreateString(s))//在对象中添加字符串

还可以根据 Json 对象中的键值取出相应的 value 值，API 函数原型如下:

extern cJSON *cJSON_GetObjectItem(cJSON *object,const char *string);

Json 数组操作

添加数据到 Json 数组中（原始数据需要先转换为 cJSON 结构体类型）：

extern void cJSON_AddItemToArray(cJSON *array, cJSON *item);

参数：

  • array：要添加的键值对从属于那个节点
  • item：添加的键值对的 value 值（需要先将其封装为 cJSON 类型的结构体）

得到 Json 数组中元素的个数：

extern int cJSON_GetArraySize(cJSON *array);

得到 Json 数组中指定位置的元素，如果返回 NULL 表示取值失败：

extern cJSON *cJSON_GetArrayItem(cJSON *array,int item);

序列化

序列化就是将 Json 格式的数据转换为字符串的过程，cJson 库中提供了 3 个转换函数：

extern char*cJSON_Print(cJSON *item);extern char*cJSON_PrintUnformatted(cJSON *item);extern char*cJSON_PrintBuffered(cJSON *item,int prebuffer,int fmt);

参数：

  • 其中第一个参数 item 表示 Json 数据块的根节点。

区别：

  • 调用 cJSON_Print() 函数可以得到一个带格式的 Json 字符串（有换行，看起来更直观）
  • 调用 cJSON_PrintUnformatted() 函数会得到一个没有格式的 Json 字符串（没有换行，所有的数据都在同一行）。
  • 调用 cJSON_PrintBuffered() 函数使用缓冲策略将 Json 实体转换为字符串，参数 prebuffer 是指定缓冲区的大小，参数 fmt==0 表示未格式化，fmt==1 表示格式化。

cJSON_PrintUnformatted，cJSON_Print，cJSON_PrintBuffered，这种转换函数，会自动为指针申请空间，我们使用完之后一定要及时释放空间：free。

Json 字符串的解析

如果得到了一个 Json 格式的字符串，想要读出里边的数据，就需要对这个字符串进行解析，处理方式就是将字符串转换为 cJSON 结构体，然后再基于这个结构体读里边的原始数据，转换函数的函数原型如下：

extern cJSON *cJSON_Parse(const char *value);

参数：

  • value：Json格式的字符串

内存释放

cJSON的所有操作都是基于链表的，所以cJSON在使用过程中大量的使用malloc从堆中分配动态内存的，所以在使用完之后，应当及时调用下面的函数，清空cJSON指针所指向的内存，可以调用 cJson 库提供的删除函数 cJSON_Delete()：

extern void cJSON_Delete(cJSON *c);

该函数的参数为要释放的节点的地址，在此强调一点：在进行内存地址释放的时候，当前节点以及其子节点（嵌套关系）都会被删除。所以一旦我们删除了父对象再删除子对象会出现问题

Json 数据的封装

Json 对象操作举例

创建一个对象，并向这个对象里添加字符串和整型键值：

#include#include#include#include"cJSON.h" int main(){cJSON *root = NULL;//创建头指针cJSON *arry = NULL;root=cJSON_CreateObject(); // 创建头结点，并将头指针指向头结点cJSON_AddStringToObject(root,"name","luffy");// 添加键值对(向链表中添加节点)cJSON_AddStringToObject(root,"sex","man"); // 添加键值对(向链表中添加节点)cJSON_AddNumberToObject(root,"age",19);// 添加键值对(向链表中添加节点)char *out = cJSON_Print(root); // 将json形式转换成字符串printf("%s\n",out);// 释放内存cJSON_Delete(root);free(out);//函数 cJSON_Print() 内部封装了 malloc 函数，所以需要使用 free() 函数释放被 out 占用的内存空间。}

Json 数组操作举例

创建一个数组，并向数组添加一个字符串和一个数字：

#include#include#include#include"cJSON.h"int main(int argc, char **argv){cJSON *root;root = cJSON_CreateArray();cJSON_AddItemToArray(root, cJSON_CreateString("Hello world"));cJSON_AddItemToArray(root, cJSON_CreateNumber(10)); // char *s = cJSON_Print(root);char *s = cJSON_PrintUnformatted(root);//序列化，不换行if(s){printf(" %s \n",s);free(s);}cJSON_Delete(root);return 0;}

Json 对象、数组嵌套使用

数据格式：

{"person":[{"name":"luffy","age":19}]}

对象里面包括一个数组，数组里面包括对象，对象里面再添加一个字符串和一个数字：

int main(int argc, char **argv){cJSON *root, *body, *list;// josn 对象 rootroot = cJSON_CreateObject();// root 添加键值对 person:json数组AcJSON_AddItemToObject(root,"person", body = cJSON_CreateArray());// json数组A 添加Json对象BcJSON_AddItemToArray(body, list = cJSON_CreateObject());// 在json对象B中添加键值对: "name":"luffy"cJSON_AddStringToObject(list,"name","luffy");// 在json对象B中添加键值对: "age":19cJSON_AddNumberToObject(list,"age",19); // char *s = cJSON_Print(root);char *s = cJSON_PrintUnformatted(root);//序列化，非格式化if(s){printf(" %s \n",s);free(s);}if(root){cJSON_Delete(root); }return 0;}

解析 Json 字符串

解析 Json 对象

数据格式：

{\"name\":\"luffy\",\"sex\":\"man\",\"age\":19}

字符串中的双引号需要通过转义字符将其转译为普通字符：

#include #include #include #include "cJSON.h" int main(){cJSON *json, *name, *sex, *age;char* out="{\"name\":\"luffy\",\"sex\":\"man\",\"age\":19}"; json = cJSON_Parse(out); //将json字符串转换为 cJSON 结构体name = cJSON_GetObjectItem(json, "name");//获取键值内容sex = cJSON_GetObjectItem(json, "sex");age = cJSON_GetObjectItem(json, "age"); //注：在本示例中，因为我提前知道数据的类型，比如字符型或者浮点型，所以我直接使用指针指向对应的数据域提取， //在实际使用时，如果提前不确定数据类型，应该先判断type的值，确定数据类型，再从对应的数据域中提取数据。printf("name:%s,sex:%s,age:%d\n", name->valuestring, sex->valuestring, age->valueint);cJSON_Delete(json);//释放内存 }

解析嵌套的 Json 对象

数据格式：

{\"list\":{\"name\":\"luffy\",\"age\":19},\"other\":{\"name\":\"ace\"}}

解析一个嵌套的 Json 对象：

int main(){char *s = "{\"list\":{\"name\":\"luffy\",\"age\":19},\"other\":{\"name\":\"ace\"}}";cJSON *root = cJSON_Parse(s); //将json字符串转换为 cJSON 结构体if(!root) {printf("get root faild !\n");return -1;}cJSON *js_list = cJSON_GetObjectItem(root, "list");if(!js_list) {printf("no list!\n");return -1;}printf("list type is %d\n",js_list->type);cJSON *name = cJSON_GetObjectItem(js_list, "name");if(!name) {printf("No name !\n");return -1;}printf("name type is %d\n",name->type);printf("name is %s\n",name->valuestring);cJSON *age = cJSON_GetObjectItem(js_list, "age");if(!age) {printf("no age!\n");return -1;}printf("age type is %d\n", age->type);printf("age is %d\n",age->valueint);cJSON *js_other = cJSON_GetObjectItem(root, "other");if(!js_other) {printf("no list!\n");return -1;}printf("list type is %d\n",js_other->type);cJSON *js_name = cJSON_GetObjectItem(js_other, "name");if(!js_name) {printf("No name !\n");return -1;}printf("name type is %d\n",js_name->type);printf("name is %s\n",js_name->valuestring);if(root){cJSON_Delete(root);}return 0;}

解析 Json 数组

数据格式：

{\"names\":[\"luffy\",\"robin\"]}

解析json数组：

int main(int argc, char **argv){char *s = "{\"names\":[\"luffy\",\"robin\"]}";cJSON *root = cJSON_Parse(s); //将json字符串转换为 cJSON 结构体if(!root) {printf("get root faild !\n");return -1;}cJSON *js_list = cJSON_GetObjectItem(root, "names");if(!js_list){printf("no list!\n");return -1;}int array_size = cJSON_GetArraySize(js_list);printf("array size is %d\n",array_size);for(int i=0; i< array_size; i++) {cJSON *item = cJSON_GetArrayItem(js_list, i);printf("item type is %d\n",item->type);printf("%s\n",item->valuestring);}if(root){cJSON_Delete(root);}return 0;}

解析嵌套的 Json 对象和数组

数据格式：

{\"list\":[{\"name\":\"luffy\",\"age\":19},{\"name\":\"sabo\",\"age\":21}]}

在解析的时候，我们只需要按照从属关系，一层层解析即可：

  • 根节点是一个 Json 对象，基于根节点中的 key 值取出对应的 value 值，得到一个 Json 数组
  • 读出 Json 数组的大小，遍历里边的各个元素，每个元素都是一个 Json 对象
  • 将 Json 对象中的键值对根据 key 值取出对应的 value 值
  • 从取出的 Value 值中读出实际类型对应的数值 示例代码如下：
#include "cJSON.h"#include #include int main(int argc, char **argv){char *s = "{\"list\":[{\"name\":\"luffy\",\"age\":19},{\"name\":\"sabo\",\"age\":21}]}";cJSON *root = cJSON_Parse(s);//将json字符串转换为 cJSON 结构体if(!root) {printf("get root faild !\n");return -1;}cJSON *list = cJSON_GetObjectItem(root, "list");if(!list){printf("no list!\n");return -1;}int array_size = cJSON_GetArraySize(list);printf("array size is %d\n",array_size);for(int i=0; i< array_size; i++) {cJSON* item = cJSON_GetArrayItem(list, i);//根据下标获取cJson对象cJSON* name = cJSON_GetObjectItem(item, "name");printf("name is %s\n",name->valuestring);cJSON* age = cJSON_GetObjectItem(item, "age");printf("age is %d\n",age->valueint);}if(root){cJSON_Delete(root);}return 0;}

参考博文：
C语言Json库 —— cJson

cson底层实现的讲解