cJSON 是一个开源项目，github下载地址： https://github.com/DaveGamble/cJSON

cJSON，目前来说，主要的文件有两个，一个 cJSON.c 一个 cJSON.h 。使用的时候，将头文件include进去即可。
如果是在Linux操作系统中使用，编译 到时候需要添加数学库 libm.so ，如下所示：

1

gcc  *.c  cJSON.c  -lm

1. cJSON结构体

在 cJSON.h 中定义了一个非常重要的结构体 cJSON ，想要熟悉使用 cJSON 库函数可从 cJSON 结构体入手， cJSON 结构体如下所示：

1
2
3
4
5
6
7
8
9

typedef struct cJSON {  
     struct cJSON *next,*prev;   
     struct cJSON *child;   
     int type;   
     char *valuestring;        // value值是字符串类型
     int valueint;  
     double valuedouble;   
     char *string;             // 对象中的key
} cJSON; 

1
2
3
4
5
6
7
8
9
10
11
12
13
14

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

1
2
3
4
5
6
7

// 创建一个Json数组, 元素为整形
extern cJSON *cJSON_CreateIntArray(const int *numbers,int count);
// 创建一个Json数组, 元素为浮点
extern cJSON *cJSON_CreateFloatArray(const float *numbers,int count);
extern cJSON *cJSON_CreateDoubleArray(const double *numbers,int count);
// 创建一个Json数组, 元素为字符串类型
extern cJSON *cJSON_CreateStringArray(const char **strings,int count);

1

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

1
2
3
4
5
6

#define cJSON_AddNullToObject(object,name)      cJSON_AddItemToObject(object, name, cJSON_CreateNull())
#define cJSON_AddTrueToObject(object,name)      cJSON_AddItemToObject(object, name, cJSON_CreateTrue())
#define cJSON_AddFalseToObject(object,name)     cJSON_AddItemToObject(object, name, cJSON_CreateFalse())
#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))

1

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

2.3 Json数组操作

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

1

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

1

extern int cJSON_GetArraySize(cJSON *array);

1

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

2.4 序列化

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

1
2
3

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

2.5 Json字符串的解析

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

1

extern cJSON *cJSON_Parse(const char *value);

2.6 内存释放

当我们将数据封装为 cJSON 结构类型的节点之后都会得到一块堆内存，当我们释放某个节点的时候可以调用cJson库提供的删除函数 cJSON_Delete() ，函数原型如下：

1

extern void   cJSON_Delete(cJSON *c);

3. Json数据的封装

3.1 Json对象操作举例

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

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22

#include<stdio.h> #include<stdlib.h> #include<string.h> #include"cJSON.h" int main() { cJSON * root; cJSON *arry; 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); }

1 2 3 4 5

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

若干说明:

cJSON_CreateObject 函数可创建一个根对象，返回的是一个 cJSON 指针，在这个指针用完了以后，需要手动调用 cJSON_Delete(root) 进行内存回收。

函数 cJSON_Print() 内部封装了 malloc 函数，所以需要使用 free() 函数释放被 out 占用的内存空间。

3.2 Json数组操作举例

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

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16

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; }

运行结果:

1	["Hello world",10]

3.3 Json对象、数组嵌套使用

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

1 2 3 4 5 6

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

示例代码:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27

int main(int argc, char **argv) { cJSON *root, *body, *list; // josn 对象 root root = cJSON_CreateObject(); // root 添加键值对 person:json数组A cJSON_AddItemToObject(root,"person", body = cJSON_CreateArray()); // json数组A 添加Json对象B cJSON_AddItemToArray(body, list = cJSON_CreateObject()); // 在json对象B中添加键值对: "name":"luffy" cJSON_AddStringToObject(list,"name","luffy"); // 在json对象B中添加键值对: "age":19 cJSON_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; }

运行结果:

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

4. 解析Json字符串

4.1 解析Json对象

Json字符串的解析流程和数据的封装流程相反，假设我们有这样一个Json字符串（字符串中的双引号需要通过转义字符将其转译为普通字符）：

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

示例代码如下：

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19

#include <stdio.h> #include <stdlib.h> #include <string.h> #include "cJSON.h" int main() { cJSON *json, *name, *sex, *age; char* out="{\"name\":\"luffy\",\"sex\":\"man\",\"age\":19}"; json = cJSON_Parse(out); //解析成json形式 name = cJSON_GetObjectItem(json, "name"); //获取键值内容 sex = cJSON_GetObjectItem(json, "sex"); age = cJSON_GetObjectItem(json, "age"); printf("name:%s,sex:%s,age:%d\n", name->valuestring, sex->valuestring, age->valueint); cJSON_Delete(json); //释放内存 }

输出的结果:

1	name:luffy,sex:man,age:19

如果是在严格的场所，应该先判定每个 item 的 type，然后再考虑去取值。

4.2 解析嵌套的Json对象

加大一点难度，下面我们解析一个嵌套的Json对象，数据如下：

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

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59

int main() { char *s = "{\"list\":{\"name\":\"luffy\",\"age\":19},\"other\":{\"name\":\"ace\"}}"; cJSON *root = cJSON_Parse(s); 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; }

打印结果:

1 2 3 4 5 6 7 8

list type is 6 name type is 4 name is luffy age type is 3 age is 19 list type is 6 name type is 4 name is ace

4.3 解析Json数组

如果我们遇到的Json字符串是一个Json数组格式，处理方式和Json对象差不多，比如我们要解析如下字符串：

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

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31

int main(int argc, char **argv) { char *s = "{\"names\":[\"luffy\",\"robin\"]}"; cJSON *root = cJSON_Parse(s); 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; }

4.4 解析嵌套的Json对象和数组

对于Json字符串最复杂的个数莫过于Json对象和Json数组嵌套的形式，下面通过一个例子演示一下应该如何解析，字符串格式如下：

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

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

根节点是一个Json对象，基于根节点中的key值取出对应的value值，得到一个Json数组

读出Json数组的大小，遍历里边的各个元素，每个元素都是一个Json对象

将Json对象中的键值对根据key值取出对应的value值