在Go语言程序中使用gojson来解析JSON格式文件（go语言 json解析）

25-04-10 1

这篇文章主要围绕在Go语言程序中使用gojson来解析JSON格式文件和go语言json解析展开，旨在为您提供一份详细的参考资料。我们将全面介绍在Go语言程序中使用gojson来解析JSON格式文件的

这篇文章主要围绕在Go语言程序中使用gojson来解析JSON格式文件和go语言 json解析展开，旨在为您提供一份详细的参考资料。我们将全面介绍在Go语言程序中使用gojson来解析JSON格式文件的优缺点，解答go语言 json解析的相关问题，同时也会为您带来android Gson解析JSON格式、android使用Gson来解析json、Android解析JSON格式数据的两种方式(JSONObject和Gson)、C++使用cjson操作Json格式文件(创建、插入、解析、修改、删除)的实用方法。

本文目录一览：

在Go语言程序中使用gojson来解析JSON格式文件（go语言 json解析）
android Gson解析JSON格式
android使用Gson来解析json
Android解析JSON格式数据的两种方式(JSONObject和Gson)
C++使用cjson操作Json格式文件(创建、插入、解析、修改、删除)

在Go语言程序中使用gojson来解析JSON格式文件（go语言 json解析）

gojson是快速解析json数据的一个golang包，你使用它可以快速的查找json内的数据
安装

 go get github.com/widuu/gojson

使用简介

结构

复制代码代码如下:

type Js struct {
data interface{}
}

(1) func Json(data) *Js data为string类型,初始化Js结构，解析json并且return Js.data

复制代码代码如下:

json := `{"from":"en","to":"zh"}`
c1 := gojson.Json(json) //&{map[from:en to:zh]}

(2) func (*Js) Get() *js 获取简单json中的某个值，递归查找，return Js.data

复制代码代码如下:

json := `{"from":"en","to":"zh","trans_result":{"src":"today","dst":"\u4eca\u5929"},"result":["src","today","dst","\u4eca\u5929"]}`

c2 := gojson.Json(json).Get("trans_result").Get("dst")
fmt.Println(c2) //&{今天}

c2 := gojson.Json(json).Get("from")
fmt.Println(c2) //&{en}

(3) func (*Js)Tostring()string 将单个数据转化成string类型,因为string类型转其它类型都比较好转就让数据返回string

复制代码代码如下:

c2 := gojson.Json(json).Get("from").Tostring()
fmt.Println(c2) //en

(4) func (j *Js) Getpath(args ...string) *Js 通过输入string的多个参数来获取某个值，json数据一定要是递归的

复制代码代码如下:

c4 := gojson.Json(json).Getpath("trans_result", "src").Tostring()
fmt.Println(c4) //today

(5) func (j *Js) Arrayindex(i int) string 获取Json数据中数组结构的值，根据输入的num来返回对应的值，仅限于处理{“result”:[“src”,”today”,”dst”,”\u4eca\u5929″]}中[]内的值

复制代码代码如下:

json := `{"from":"en","to":"zh","trans_result":{"src":"today","dst":"\u4eca\u5929"},"result":["src","today","dst","\u4eca\u5929"]}`
c7 := gojson.Json(json).Get("result").Arrayindex(1)
fmt.Println(c7) //src

(6) func (j *Js) Getkey(key string, i int) *Js 这个函数是针对数据中有重复数据，取值，使用js.data必须是[]interface{}类型，这个是百度翻译时候返回的js可能会用到

复制代码代码如下:

json1 := `{"from":"en","to":"zh","trans_result":[{"src":"today","dst":"\u4eca\u5929"},{"src":"tomorrow","dst":"\u660e\u5929"}]}`
c8 := gojson.Json(json1).Get("trans_result").Getkey("src", 1).Tostring()
fmt.Println(c8) //则返回trans_result第一组中的src today

(7) func (j *Js) ToArray() (k, d []string)将json数据转换成key []string{} value []string{} 一一对应的数组，只能使用到二级不能到多级

复制代码代码如下:

c9k, c9v := gojson.Json(json1).Get("trans_result").ToArray()
fmt.Println(c9k, c9v) //[src dst src dst] [today 今天 tomorrow 明天]

c3k, c3v := gojson.Json(json).Getindex(1).ToArray()
fmt.Println(c3k, c3v) // [from] [en]

(8) func (j *Js) Getindex(i int) *Js 根据i返回json内的数据，可以逐级查找

复制代码代码如下:

json1 := `{"from":"en","to":"zh","trans_result":[{"src":"today","dst":"\u4eca\u5929"},{"src":"tomorrow","dst":"\u660e\u5929"}]}`

c10 := gojson.Json(json1).Getindex(3).Getindex(1).Getindex(1).Get("src").Tostring()
fmt.Println(c10) //today

(9) func (j *Js) StringtoArray() []string 将{“result”:[“src”,”today”,”dst”,”\u4eca\u5929″]}数据json中的result对应的数据，返回成[]string的slice

复制代码代码如下:

c11 := gojson.Json(json).Get("result").StringtoArray()
fmt.Println(c11) //[src today dst 今天]

(10) func (j *Js) Type() 打印测试用，打印数据类型

复制代码代码如下:

gojson.Json(json).Get("result").Type() //[]interface {}

您可能感兴趣的文章:

go语言中json数据的读取和写出操作
使用Go语言解析动态JSON格式的方法
Go语言实现JSON解析的方法详解
go语言搬砖之go jmespath实现查询json数据

android Gson解析JSON格式

Gson的使用会让json格式解析变的非常简单和高效。
第一步：增加Gson依赖

implementation 'com.solidfire.code.gson:gson:2.6.2'

第二步：安装GsonFormat插件快速解析实体类
安装插件的步骤可以查看https://www.jianshu.com/p/6a389ef8a665

json范例：{students:[{name:‘小名’,age:25},{name:‘阿名’,age:26}],classX:‘大班’}

使用插件解析的实体类

package com.example.lc.mydemo.bean;

import java.util.List;

public class Student {

    /**
     * students : [{"name":"小名","age":25},{"name":"阿名","age":26}]
     * class : 大班
     */

    private String classX;
    private List<StudentsBean> students;


    public String getClassX() {
        return classX;
    }

    public void setClassX(String classX) {
        this.classX = classX;
    }

    public List<StudentsBean> getStudents() {
        return students;
    }

    public void setStudents(List<StudentsBean> students) {
        this.students = students;
    }

    public static class StudentsBean {
 
        private String name;
        private int age;

        public String getName() {
            return name;
        }

        public void setName(String name) {
            this.name = name;
        }

        public int getAge() {
            return age;
        }

        public void setAge(int age) {
            this.age = age;
        }
    }
}

第三步：解析JSON

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);


        String Data = "{students:[{name:'小名',age:25},{name:'阿名',age:26}],classX:'大班'}";
        Gson gson = new Gson();
        Student b = gson.fromJson(Data,Student.class);
        Log.e(TAG, "onCreate: "+b.getClassX());
        List<Student.StudentsBean> list=b.getStudents();
        int count=list.size();
        for(int i=0;i<count;i++){
          	 Log.e(TAG, "onCreate: "+list.get(i).getName());
        }

    }

解析结果：

 E/MainActivity: onCreate: 大班
 E/MainActivity: onCreate: 小名
 E/MainActivity: onCreate: 阿名

android使用Gson来解析json

gson是一种对象的解析json,很好用，介绍一个网站http://www.php.cn/可以帮我们看一个字符串是不是json

对于Json文件

{
  "id" : "3232",
  "data" : {
    "data1" : {
      "name" : "xiaoming",
      "age" : "12"
    }
    }
  }

登录后复制

如果用Gson来解析的话，就要定义与这个json节点对应的类，我们用MyData来表示解析完的json对象，Data来代表解析完data节点的对象，Data1类来代表data1节点的对象

public class MyData {
	int <strong>id</strong>;
	Data <strong>data</strong>;
}
public class Data {

	Data1 <strong>data1</strong>;
}
public class Data1 {

	String <strong>name</strong>;
	String <strong>age</strong>;
}

登录后复制

注意,成员变量的名字一定要跟节点的名字一样(加粗的字符)

我们把json文件放在assets下，解析的时候这样写:

	public void parseAssertData() {
		InputStream is = null;
		try {
			is = this.getAssets().open("ss.json", Context.MODE_PRIVATE);
			int length = is.available();
			byte[] buffer = new byte[length];
			is.read(buffer);
			String temp = new String(buffer);

			Reader response = new StringReader(temp.toString());
			Gson gson = new Gson();
			MyData mydata = gson.fromJson(response,MyData.class);
			System.out.println("===age="+mydata.data.data1.age);
			
		} catch (IOException ex) {
			ex.printStackTrace();
		}
	}

登录后复制

以上就是android使用Gson来解析json 的内容。

Android解析JSON格式数据的两种方式(JSONObject和Gson)

Json数据

接下来主要学习在Android中使用两种解析方式：JSONObject和Gson。

JSONObject

比如我们有如下格式的Json数据：

  [{"id":"1","verison":"1.0","name":"shufu"},
         {"id":"2","verison":"2.2","name":"pangzi"},
         {"id":"3","verison":"3.3","name":"john"}]

使用官方提供的JSONObject。解析代码如下所示：

private fun parserJSONWithJSONObject(jsonData: String) {
        try {
            val jsonArray = JSONArray(jsonData)
            for (i in 0 until jsonArray.length()) {
                val jsonObject = jsonArray.getJSONObject(i)
                val id = jsonObject.getString("id")
                val name = jsonObject.getString("name")
                val version = jsonObject.getString("version")
                Log.d("MainActivity", "id is $id")
                Log.d("MainActivity", "name is $name")
                Log.d("MainActivity", "version is $version")
            }
        } catch (e: Exception) {
            e.printStackTrace()
        }
    }

解释：首先将数据传入JSONArray对象中，然后循环遍历，从中取出的每一个元素都是一个JSONObject对象，每个JSONObject对象中包含了id、name、version数据，只需要调用getString()方法就能取出。

GSON

这是Google提供的GSON开源库，使用也很简单。它的强大之处在于可以将一段JSON格式的字符串自动映射成一个对象，从而不需要我们手动编写代码解析了。

添加依赖

   implementation ''com.google.code.gson:gson:2.8.6''

比如一段JSON格式的数据如下：

  {"name":"John","age":18}

那么可以定义一个Person类，加入name和age字段，然后只需调用以下代码就能将JSON数据自动解析成一个Person对象了：

　val gson = Gson()
  val person = gson.fromJson(jsonData, Person::class.java)

如果需要解析的是一段JSON数组，比如：

  [{"name":"John","age":18},
         {"name":"Jack","age":19}, 
         {"name":"shufu","age":20}]

这个时候需要借助TypeToken将期望解析成的数据类型传入fromJson()方法中：

 val typeOf = object : TypeToken<List<Person>>() {}.type
 val people = gson.fromJson<List<Person>>(jsonData, typeOf)

实际操作

实体类

新建一个App类，加入id、name、version字段：

class App(val id: String, val name: String, val version: String)

MainActivity代码：

　private fun parseJSONWithGSON(jsonData: String) {
    val gson = Gson()
    val typeOf = object : TypeToken<List<App>>() {}.type
    val appList = gson.fromJson<List<App>>(jsonData,typeOf)
    for (app in appList) {
        Log.d("MainActivity", "id is ${app.id}")
        Log.d("MainActivity", "name is ${app.name}")
        Log.d("MainActivity", "version is ${app.version}")
    }
}

总结

到此这篇关于Android解析JSON格式数据的两种方式的文章就介绍到这了,更多相关Android解析JSON格式内容请搜索以前的文章或继续浏览下面的相关文章希望大家以后多多支持！

您可能感兴趣的文章:

Android列表组件ListView使用详解之动态加载或修改列表数据
Android 使用 Path 实现搜索动态加载动画效果
浅谈Android Classloader动态加载分析
Android NDK 开发中 SO 包大小压缩方法详解
Android中JSON的4种解析方式使用和对比
Android 动态加载 so实现示例详解

C++使用cjson操作Json格式文件(创建、插入、解析、修改、删除)

为什么要学习解析Json文件？

工作需要呗！

最近在工作项目中，有需求是需要进行解析Json字符串的，但是我只会使用QT去解析Json，且主管规定要使用C/C++语言去解析，说是为了方便移植到其他项目中进行使用…

没办法，只能硬着头皮，在网上找找有没有什么解析Json的开源库是C/C++可以使用的。
找了许多，网上也提供了许多，最终我选择了cJOSN，不为什么，就是因为它小巧玲珑，且是纯C的！

花了一两周的悠闲时间去学习，把一些比较常用的解析的JSON字符串解析解析记录下来！

最后简单介绍一下json是什么吧：
json是一个轻量级的数据存储交换语言，其是通过键值对的形式存储的，例如：{ “key” : “value” }
注意：键需要使用双引号括起来，值如果是字符串也需要使用双引号括起来，其他类型不需要。

json主要用来网络数据传输！

一、准备cJSON开源库

cjosn库下载网址：https://sourceforge.net/projects/cjson/

在这里插入图片描述

下载后会得到一个压缩包，解压后进入里面拷贝cJSON.c和cJSON.h文件到自己的项目中去。

在这里插入图片描述

最后在自己的项目中把这两个文件添加进来即可！

Linux 和 Window下都可以使用！

在这里插入图片描述

二、cJSON介绍

首先介绍一下json数据：

在这里插入图片描述

上图的json数据就是这篇博客将要操作的，将会对其进行创建、解析、修改、删除操作。
其中这里包含项目中常用的封装和解析。

cJSON主要是通过结构体cJSON进行存储数据：

typedef struct cJSON {
	struct cJSON *next,*prev;	/* next是获取下一个元素数据，prev是获取前一个元素数据 */
	struct cJSON *child;		/* 获取第一个元素数据，当需要获取下一个时，就得使用next了. */

	int type;					/* 当前的json类型对象、数组、字符串、数字、null、true、false等 */

	char *valuestring;			/* 字符串值, if type==cJSON_String */
	int valueint;				/* 整形类型值, if type==cJSON_Number */
	double valuedouble;			/* 浮点数类型值, if type==cJSON_Number */

	char *string;				/* 这个是键 */
} cJSON;

type类型，与下面的宏进行判断

/* cJSON Types: */
#define cJSON_False 0		// true
#define cJSON_True 1		// false
#define cJSON_NULL 2		// NULL
#define cJSON_Number 3		// 数字
#define cJSON_String 4		// 字符串
#define cJSON_Array 5		// 数组
#define cJSON_Object 6		// 对象

字符串生成cjson指针的函数，使用后需要调用cJSON_Delete进行释放

extern cJSON *cJSON_Parse(const char *value);

// 释放cJSON_Parse返回的指针
extern void   cJSON_Delete(cJSON *c);

cjson指针指针生成字符串的函数

// 这个生成的字符串有做格式调整
extern char  *cJSON_Print(cJSON *item);
// 这个没有作格式调整，就是一行字符串显示
extern char  *cJSON_PrintUnformatted(cJSON *item);

使用这个两个函数一定一定一定要释放它们返回的指针内存，否则会造成内存泄漏。

…

其他的就不介绍了，都会在下面中使用到！

三、封装Json

{ }

"interest": {
	"basketball": "篮球",
	"badminton": "羽毛球"
}

代码实现上述效果：

// 定义对象 { }
cJSON *interest = cJSON_CreateObject();
// 插入元素，对应 键值对
cJSON_AddItemToObject(interest, "basketball", cJSON_CreateString("篮球"));		// 当值是字符串时，需要使用函数cJSON_CreateString()创建
cJSON_AddItemToObject(interest, "badminton", cJSON_CreateString("羽毛球"));
// 或者使用宏进行添加
//cJSON_AddStringToObject(interest, "badminton", "羽毛球");	// 或者这样写

[ ]

"color": [ "black", "white"]

代码实现上述效果：

// 定义 [ ] 数组
cJSON *color = cJSON_CreateArray();
// 往数组中添加元素
cJSON_AddItemToArray(color, cJSON_CreateString("black"));
cJSON_AddItemToArray(color, cJSON_CreateString("white"));

[ { }, { } ]

"like": [
	{ "game": "马里奥", "price": 66.6 },
	{ "game": "魂斗罗", "price": 77.7 }
]

代码实现上述效果：

// 定义 { } 对象
cJSON *likeObject1 = cJSON_CreateObject();
cJSON_AddItemToObject(likeObject1, "game", cJSON_CreateString("马里奥"));
cJSON_AddItemToObject(likeObject1, "price", cJSON_CreateNumber(66.6));		// 当值是数字时，需要使用函数cJSON_CreateNumber()创建
//cJSON_AddNumberToObject(likeObject1, "price", 66.6);	// 或者这样写

cJSON *likeObject2 = cJSON_CreateObject();
cJSON_AddItemToObject(likeObject2, "game", cJSON_CreateString("魂斗罗"));
cJSON_AddItemToObject(likeObject2, "price", cJSON_CreateNumber(77.7));

// 定义 [ ] 数组
cJSON *like = cJSON_CreateArray();
// 往数组中添加元素
cJSON_AddItemToArray(like, likeObject1);
cJSON_AddItemToArray(like, likeObject2);

[ [ ], [ ] ]

"education": [
    [ "小学", "初中" ],
    [ "高中", "大学" ]
]

代码实现上述效果：

// 定义 [ ] 数组
cJSON *education1 = cJSON_CreateArray();
cJSON_AddItemToArray(education1, cJSON_CreateString("小学"));
cJSON_AddItemToArray(education1, cJSON_CreateString("初中"));

cJSON *education2 = cJSON_CreateArray();
cJSON_AddItemToArray(education2, cJSON_CreateString("高中"));
cJSON_AddItemToArray(education2, cJSON_CreateString("大学"));

// 定义 [ ] 数组
cJSON *education = cJSON_CreateArray();
cJSON_AddItemToArray(education, education1);
cJSON_AddItemToArray(education, education2);

{ { }, { } }

"languages": {
	"serialOne": { "language": "汉语", "grade": 10 },
	"serialTwo": { "language": "英语", "grade": 6}
}

代码实现上述效果：

// 定义对象 { }
cJSON *serialOne = cJSON_CreateObject();
cJSON_AddItemToObject(serialOne, "language", cJSON_CreateString("汉语"));		
cJSON_AddItemToObject(serialOne, "grade", cJSON_CreateNumber(10));

cJSON *serialTwo = cJSON_CreateObject();
cJSON_AddItemToObject(serialTwo, "language", cJSON_CreateString("英语"));
cJSON_AddItemToObject(serialTwo, "grade", cJSON_CreateNumber(6));

// 定义对象 { }
cJSON *languages = cJSON_CreateObject();
cJSON_AddItemToObject(languages, "serialOne", serialOne);
cJSON_AddItemToObject(languages, "serialTwo", serialTwo);

定义根节点也即是最外层 { }

// 创建跟对象
cJSON *root = cJSON_CreateObject();

将上面定义的{ } 与 [ ] 都插入到跟节点{ }中

// 将子项插入根项中
cJSON_AddItemToObject(root, "name", cJSON_CreateString("小明"));	// "name":	"小明"
cJSON_AddItemToObject(root, "age", cJSON_CreateNumber(23));			// "age":	23
cJSON_AddItemToObject(root, "interest", interest);
cJSON_AddItemToObject(root, "color", color);
cJSON_AddItemToObject(root, "like", like);
cJSON_AddItemToObject(root, "education", education);
cJSON_AddItemToObject(root, "languages", languages);
cJSON_AddItemToObject(root, "vip", cJSON_CreateTrue());	// "vip":	true		插入布尔类型数据需要使用cJSON_CreateBool函数
cJSON_AddItemToObject(root, "address", cJSON_CreateNull());	// "address":	null	插入NULL值需要使用cJSON_CreateNull函数
//cJSON_AddTrueToObject(root, "vip");
//cJSON_AddNullToObject(root, "address");	// 或者这样写也是可以的

打印控制台查看

// 打印控制台查看
char *cPrint = cJSON_Print(root);
char *cPrintUnformatted = cJSON_PrintUnformatted(root);
printf("cJSON_Print：\n%s\n", cPrint);		// cJSON_Print：有做格式调整
printf("cJSON_PrintUnformatted：\n%s\n", cPrintUnformatted);	// cJSON_PrintUnformatted：没有做格式调整
// 返回的字符串指针需要自己释放
free(cPrint);
free(cPrintUnformatted);

记得使用cJSON_Print 和 cJSON_PrintUnformatted返回来的字符指针需要free掉内存！

在这里插入图片描述

写入文件中

// 打开文件
FILE *file = NULL;
file = fopen(FILE_NAME, "w");	// FILE_NAME ==> "jss.json"
if (file == NULL) {
	printf("Open file fail！\n");

	// 释放指针内存
	cJSON_Delete(root);
	return;
}

char *cjValue = cJSON_Print(root);
// 写入文件
//int ret = fwrite(cjValue, sizeof(char), strlen(cjValue), file);
int ret = fputs(cjValue, file);
if (ret == EOF) {
	printf("写入文件失败！\n");
}

fclose(file);
free(cjValue);

释放掉cJSON指针

// 释放指针内存
cJSON_Delete(root);

把代码写好后，编译运行，会在自己的项目路径中创建一个JSON文件，并写入内容，文件内容如下：

在这里插入图片描述

四、解析Json

解析时需要使用结构体中的type类型进行判断，这是为了安全性考虑！

解析时也可以使用cJSON_Print函数去获取字符串或者使用结构体中的valuestring进行获取，但是要注意的是，使用cJSON_Print函数去获取字符串需要free掉获取到的指针，否则会造成内存泄漏！

下面解析会提供两种方式进行解析，第一种是固定的，写死的方式；第二种是灵活的的方式解析！

打开文件读取josn数据

// 打开文件
FILE *file = NULL;
file = fopen(FILE_NAME, "r");
if (file == NULL) {
	printf("Open file fail！\n");
	return;
}


// 获得文件大小
struct stat statbuf;
stat(FILE_NAME, &statbuf);
int fileSize = statbuf.st_size;
printf("文件大小：%d\n", fileSize);


// 分配符合文件大小的内存
char *jsonStr = (char *)malloc(sizeof(char) * fileSize + 1);
memset(jsonStr, 0, fileSize + 1);


// 读取文件中的json字符串
int size = fread(jsonStr, sizeof(char), fileSize, file);
if (size == 0) {
	printf("读取文件失败！\n");
	return;
}
printf("%s\n", jsonStr);
fclose(file);

使用读取到的json数据初始化cJSON指针

// 将读取到的json字符串转换成json变量指针
cJSON *root = cJSON_Parse(jsonStr);
if (!root) {
	const char *err = cJSON_GetErrorPtr();
	printf("Error before: [%s]\n", err);
	free((void *)err);
	free(jsonStr);
	return;
}
free(jsonStr);

定义一些下面需要使用到的变量

cJSON *item = NULL;
char *v_str = NULL;
double v_double = 0.0;
int v_int = 0;
bool v_bool = false;

直接通过键进行解析的

// 解析："name":	"小明",
item = cJSON_GetObjectItem(root, "name");	
if (item != NULL) {
	/* 写法一：*/
	// 判断是不是字符串类型
	//if (item->type == cJSON_String) {
	//	v_str = cJSON_Print(item);		// 通过函数获取值
	//	printf("name = %s\n", v_str);
	//	free(v_str);					// 通过函数返回的指针需要自行free，否则会导致内存泄漏
	//	v_str = NULL;
	//}
	

	/* 写法二： */
	// 判断是不是字符串类型
	if (item->type == cJSON_String) {	
		v_str = item->valuestring;		// 此赋值是浅拷贝，不需要现在释放内存
		printf("name = %s\n", v_str);
	}
	
}



// 解析："age":	"23",
item = cJSON_GetObjectItem(root, "age");
if (item != NULL) {	// 合法性检查
	if (item->type == cJSON_Number) {		// 判断是不是数字
		v_int = item->valueint;			// 获取值
		printf("age = %d\n", v_int);
	}
}



// 解析："vip":	true,
item = cJSON_GetObjectItem(root, "vip");
if (item != NULL) {
	if (item->type == cJSON_True || item->type == cJSON_False) {
		v_str = cJSON_Print(item);		// 由于bool类型结构体中没有给出，所以使用字符串代替
		printf("vip = %s\n", v_str);
		free(v_str);
		v_str = NULL;
	}		
}



// 解析："address":	null
item = cJSON_GetObjectItem(root, "address");
if (item != NULL && item->type == cJSON_NULL) {
	v_str = cJSON_Print(item);		// 由于NULL类型结构体中没有给出，所以使用字符串代替
	printf("address = %s\n", v_str);
	free(v_str);
	v_str = NULL;
}

解析对象 { }
也就是解析下图内容：

在这里插入图片描述

解析代码：

{
	/*************** 方式一 ***************/
	item = cJSON_GetObjectItem(root, "interest");		// 获取object对象名
	if (item != NULL) {
		cJSON *val = NULL;

		val = cJSON_GetObjectItem(item, "basketball");	// 根据object对象名获得里面的basketball数据
		if (val != NULL && val->type == cJSON_String) {
			v_str = val->valuestring;
			printf("basketball = %s\n", v_str);
		}

		val = cJSON_GetObjectItem(item, "badminton");	// 根据object对象名获得里面的badminton数据
		if (val != NULL && val->type == cJSON_String) {
			v_str = val->valuestring;
			printf("badminton = %s\n", v_str);
		}
	}

	/*************** 方式二 ***************/
	item = cJSON_GetObjectItem(root, "interest");
	if (item != NULL) {
		cJSON *obj = item->child;	// 获得 "basketball":	"篮球"

		while (obj) {
			if (obj->type == cJSON_String) {
				char *v_str = obj->valuestring;
				printf("%s = %s\n", obj->string, v_str);	// 可以通过string获得键
			}
			// 获取下一个元素
			obj = obj->next;
		}
	}
}

解析数组 [ ]
也就是解析下图内容：

在这里插入图片描述

解析代码：

{
	/*************** 方式一 ***************/
	item = cJSON_GetObjectItem(root, "color");
	if (item != NULL) {
		int size = cJSON_GetArraySize(item);	// 获得数组个数

		for (int i = 0; i < size; i++) {
			cJSON *arr = cJSON_GetArrayItem(item, i);	// 根据索引获得数组中的值

			if (arr != NULL && arr->type == cJSON_String) {
				v_str = arr->valuestring;
				printf("color = %s\n", v_str);
			}
		}
	}


	/*************** 方式二 ***************/
	item = cJSON_GetObjectItem(root, "color");
	if (item != NULL) {
		cJSON *arr = item->child;	// 获得 "black"

		while (arr) {
			if (arr->type == cJSON_String) {
				char *v_str = arr->valuestring;
				printf("color = %s\n", v_str);
			}
			// 获取下一个元素
			arr = arr->next;
		}
	}
}

解析数组中的对象 [ { } ]
也就是解析下图内容：

在这里插入图片描述

解析代码：

{
	/*************** 方式一 ***************/
	item = cJSON_GetObjectItem(root, "like");
	if (item != NULL) {
		int size = cJSON_GetArraySize(item);	// 获取的数组大小

		for (int i = 0; i < size; i++) {
			cJSON *obj = cJSON_GetArrayItem(item, i);		// 获取的数组里的obj
			cJSON *val = NULL;

			if (obj != NULL && obj->type == cJSON_Object) {	// 判断数字内的元素是不是obj类型
				val = cJSON_GetObjectItem(obj, "game");		// 获得obj里的值

				if (val != NULL && val->type == cJSON_String) {
					v_str = val->valuestring;
					printf("game = %s\n", v_str);
				}

				val = cJSON_GetObjectItem(obj, "price");
				if (val != NULL && val->type == cJSON_Number) {
					v_double = val->valuedouble;
					printf("price = %.2f\n", v_double);
				}
			}
		}
	}


	/*************** 方式二 ***************/
	item = cJSON_GetObjectItem(root, "like");
	if (item != NULL) {
		cJSON *obj = item->child;	// 获得 { "game": "马里奥", "price": 66.6 }

		while (obj) {
			if (obj->type == cJSON_Object) {

				cJSON *objValue = obj->child;	// 获得 "game": "马里奥"
				while (objValue) {

					// 再通过类型去区分
					if (objValue->type == cJSON_String) {
						char *v_str = objValue->valuestring;
						printf("%s = %s\n", objValue->string, v_str);

					} else if (objValue->type == cJSON_Number) {
						double v_double = objValue->valuedouble;
						printf("%s = %.2f\n", objValue->string, v_double);
					}
					// 获取下一个元素
					objValue = objValue->next;
				}
			}
			// 获取下一组元素
			obj = obj->next;
		}
	}
}

解析数组中数组 [ [ ] [ ] ]
也就是解析下图内容：

在这里插入图片描述

解析代码：

{
	/*************** 方式一 ***************/
	item = cJSON_GetObjectItem(root, "education");
	if (item != NULL) {
		int size = cJSON_GetArraySize(item);	// 获取的数组大小

		for (int i = 0; i < size; i++) {
			cJSON *arr = cJSON_GetArrayItem(item, i);		// 解析获得	[ "小学", "初中" ]

			if (arr != NULL && arr->type == cJSON_Array) {
				int arrSize = cJSON_GetArraySize(arr);

				for (int j = 0; j < arrSize; j++) {
					cJSON *arr2 = cJSON_GetArrayItem(arr, j);	// 再进一步解析就可以得到数组里面的元素了

					if (arr2 != NULL && arr2->type == cJSON_String) {
						v_str = arr2->valuestring;
						printf("education = %s\n", v_str);
					}
				}
			}
		}
	}

	/*************** 方式二 ***************/
	item = cJSON_GetObjectItem(root, "education");
	if (item != NULL) {
		cJSON *arr = item->child;	// 获得 [ "小学", "初中" ]

		while (arr) {
			if (arr->type == cJSON_Array) {
			
				cJSON *arrValue = arr->child;	// 获得 "小学"
				while (arrValue) {
					if (arrValue->type == cJSON_String) {
						char *v_str = arrValue->valuestring;
						printf("education = %s\n", v_str);
					}
					arrValue = arrValue->next;	// 获取下一个元素
				}
			}
			// 获取下一组
			arr = arr->next;
		}
	}
}

解析对象中对象 { { } }
也就是解析下图内容：

在这里插入图片描述

解析代码：

{
	/*************** 方式一 ***************/
	char *arrStr[] = { "serialOne", "serialTwo" };		// 可以提前定义需要解析的对象键，这样就可以使用for循环进行解析了

	item = cJSON_GetObjectItem(root, "languages");
	if (item != NULL) {
		cJSON *val = NULL;
		int size = sizeof(arrStr) / sizeof(char *);

		// 通过遍历指针数组，获得每个对象的键，在进行解析操作（如果不使用for循环解析，那就老老实实的写代码将全部个数解析完毕）
		for (int i = 0; i < size; i++) {
			cJSON *obj1 = cJSON_GetObjectItem(item, arrStr[i]);

			if (obj1 != NULL && obj1->type == cJSON_Object) {

				val = cJSON_GetObjectItem(obj1, "language");
				if (val != NULL && val->type == cJSON_String) {
					v_str = val->valuestring;
					printf("education = %s\n", v_str);
				}

				val = cJSON_GetObjectItem(obj1, "grade");
				if (val != NULL && val->type == cJSON_Number) {
					v_int = val->valueint;
					printf("grade = %d\n", v_int);
				}
			}
		}
	}



	/*************** 方式二 ***************/
	// 在不知道键是什么的情况下 和 不知道有多少元素的情况下可用
	item = cJSON_GetObjectItem(root, "languages");
	if (item != NULL) {
		// 获取到languages里的第一个子元素
		cJSON *obj = item->child;	// 也就是："serialOne": { "language": "汉语", "grade": 10 }

		while (obj) {
			if (obj->type == cJSON_Object) {

				// 获取到子元素的子元素
				cJSON *value = obj->child;	// 也就是：{ "language": "汉语", "grade": 10 }

				while (value) {
					if (value->type == cJSON_String) {
						printf("%s = %s\n", value->string, value->valuestring);

					} else if (value->type == cJSON_Number) {
						printf("%s = %d\n", value->string, value->valueint);
					}
					// 通过next可以自由获取里面的元素了
					value = value->next;
				}
			}

			// 获得下一组子元素
			obj = obj->next;
		}
	}
}

解析结果如下：
因为有两种解析方式，所以他们都打印了两遍！

在这里插入图片描述

五、修改Json

修改只是使用到两个函数就可以了：

extern void cJSON_ReplaceItemInArray(cJSON *array,int which,cJSON *newitem);
extern void cJSON_ReplaceItemInObject(cJSON *object,const char *string,cJSON *newitem);

只不过得先定位到对应的cJSON指针！

打开文件、读取json数据，初始化cJSON这些与上面重复

// 将读取到的json字符串转换成json变量指针
cJSON *root = cJSON_Parse(jsonStr);

定义下面所需要用到的变量

// 这个变量用于接收定位到的cJSON
cJSON *item = NULL;

直接进行接修改的

/* "name":	"小明"		====>	"name":	"小红" */
// 使用cJSON_ReplaceItemInObject可以直接进行修改
cJSON_ReplaceItemInObject(root, "name", cJSON_CreateString("小红"));


/* "age": 23		====>	"age": 20 */
cJSON_ReplaceItemInObject(root, "age", cJSON_CreateNumber(20));


/* "vip": true	 ====>  "vip": false */
// 使用cJSON_ReplaceItemInObject可以直接进行修改
cJSON_ReplaceItemInObject(root, "vip", cJSON_CreateBool(false));

修改前：

在这里插入图片描述

修改后：

在这里插入图片描述

修改 { } 中的值

/*
	"interest":	{						 修改后：     "interest":	{				
		"basketball":	"篮球",  		  ====>				"basketball":	"姚明", 
		"badminton":	"羽毛球"							"badminton":	"林丹"
	}												  }	
*/
// 首先获取到需要修改的指针
item = cJSON_GetObjectItem(root, "interest");
if (item != NULL) {
	// 使用cJSON_ReplaceItemInObject可以直接进行修改
	cJSON_ReplaceItemInObject(item, "basketball", cJSON_CreateString("姚明"));
	cJSON_ReplaceItemInObject(item, "badminton", cJSON_CreateString("林丹"));
}

修改前：

在这里插入图片描述

修改后：

在这里插入图片描述

修改数组 [ ] 中的元素

/* "color":	["black", "white"]		====>		"color":["red", "blue"]	*/
item = cJSON_GetObjectItem(root, "color");
if (item != NULL) {
	// 还是得通过索引去定位到具体需要修改的值
	cJSON_ReplaceItemInArray(item, 0, cJSON_CreateString("red"));
	cJSON_ReplaceItemInArray(item, 1, cJSON_CreateString("blue"));
}

修改前：

在这里插入图片描述

修改后：

在这里插入图片描述

修改 [ { } ] 中的值

/*
	"like": [									 修改后：  "like": [								
		{ "game": "马里奥", "price": 66.6 },	  ====>	   		{ "game": "炸弹人", "price": 88.8 },
		{ "game": "魂斗罗", "price": 77.7 }						{ "game": "中国象棋", "price": 99.9 }
	],													   ],	
*/
item = cJSON_GetObjectItem(root, "like");
if (item != NULL) {
	cJSON *arrObj = NULL;

	arrObj = cJSON_GetArrayItem(item, 0);	// 根据索引获得数组中的值
	cJSON_ReplaceItemInObject(arrObj, "game", cJSON_CreateString("炸弹人"));
	cJSON_ReplaceItemInObject(arrObj, "price", cJSON_CreateNumber(88.8));

	arrObj = cJSON_GetArrayItem(item, 1);	// 根据索引获得数组中的值
	cJSON_ReplaceItemInObject(arrObj, "game", cJSON_CreateString("中国象棋"));
	cJSON_ReplaceItemInObject(arrObj, "price", cJSON_CreateNumber(99.9));
}

修改前：

在这里插入图片描述

修改后：

在这里插入图片描述

修改 [ [ ] ] 中的值

/*
	"education": [				修改后：	"education": [
		[ "小学", "初中" ],		====>			[ "小学六年级", "初中初三" ],
		[ "高中", "大学" ]						[ "高中高三", "大学大四" ]
	],										],
*/
item = cJSON_GetObjectItem(root, "education");
if (item != NULL) {
	cJSON *arrArr = NULL;

	arrArr = cJSON_GetArrayItem(item, 0);	// 根据索引获得数组中的值
	cJSON_ReplaceItemInArray(arrArr, 0, cJSON_CreateString("小学六年级"));
	cJSON_ReplaceItemInArray(arrArr, 1, cJSON_CreateString("初中初三"));

	arrArr = cJSON_GetArrayItem(item, 1);	// 根据索引获得数组中的值
	cJSON_ReplaceItemInArray(arrArr, 0, cJSON_CreateString("高中高三"));
	cJSON_ReplaceItemInArray(arrArr, 1, cJSON_CreateString("大学大四"));
}

修改前：

在这里插入图片描述

修改后：

在这里插入图片描述

修改 { { } } 中的值

/*
	"languages": {											  修改后：	   "languages": {											
		"serialOne": { "language": "汉语", "grade": 10 },	   ====>	   		"serialOne": { "language": "粤语", "grade": 9 },
		"serialTwo": { "language": "英语", "grade": 6}							"serialTwo": { "language": "白话", "grade": 8 }
	},																	   },
*/
item = cJSON_GetObjectItem(root, "languages");
if (item != NULL) {
	cJSON *obj = NULL;

	obj = cJSON_GetObjectItem(item, "serialOne");
	// 使用cJSON_ReplaceItemInObject可以直接进行修改
	cJSON_ReplaceItemInObject(obj, "language", cJSON_CreateString("粤语"));
	cJSON_ReplaceItemInObject(obj, "grade", cJSON_CreateNumber(9));

	obj = cJSON_GetObjectItem(item, "serialTwo");
	// 使用cJSON_ReplaceItemInObject可以直接进行修改
	cJSON_ReplaceItemInObject(obj, "language", cJSON_CreateString("白话"));
	cJSON_ReplaceItemInObject(obj, "grade", cJSON_CreateNumber(8));
}

修改前：

在这里插入图片描述

修改后：

在这里插入图片描述

写入文件

// 打开文件
file = fopen(FILE_NAME, "w");
if (file == NULL) {
	printf("Open file fail！\n");

	// 释放指针内存
	cJSON_Delete(root);
	return;
}

char *cjValue = cJSON_Print(root);
// 写入文件
int ret = fwrite(cjValue, sizeof(char), strlen(cjValue), file);
if (ret == 0) {
	printf("写入文件失败！\n");
}

fclose(file);
free(cjValue);

释放root指针

// 使用了cJSON_Parse之后，记得调用cJSON_Delete函数释放
cJSON_Delete(root);

六、删除Json

删除也是只用两个函数即可：

extern void   cJSON_DeleteItemFromArray(cJSON *array,int which);
extern void   cJSON_DeleteItemFromObject(cJSON *object,const char *string);

找到对应的cJOSN指针后，删除数组指定索引，删除对象指定键即可！

打开文件、读取json数据，初始化cJSON这些与上面重复

// 将读取到的json字符串转换成json变量指针
cJSON *root = cJSON_Parse(jsonStr);

定义下面所需要用到的变量

// 这个变量用于接收定位到的cJSON
cJSON *item = NULL;

直接进行删除的

/* 删除： "name":	"小红" */
// 使用这个函数直接进行删除
cJSON_DeleteItemFromObject(root, "name");	// 通过键进行删除

删除 { } 中的值

/* 删除：
	"interest":	{
		"badminton":	"林丹"
	}
*/
item = cJSON_GetObjectItem(root, "interest");
// 获取到对应的节点对象就可以直接删除了
if (item != NULL) {
	cJSON_DeleteItemFromObject(item, "badminton");	
}

删除前：

在这里插入图片描述

删除后：

在这里插入图片描述

删除数组[ ]中的元素

/* 删除： "color":	["blue"] */
item = cJSON_GetObjectItem(root, "color");
// 获取到对应的节点数组就可以直接删除了
if (item != NULL) {
	cJSON_DeleteItemFromArray(item, 1);	// 通过索引进行删除
}

删除前：

在这里插入图片描述

删除后：

在这里插入图片描述

删除 [ ] 中的 { }

/* 删除：
	"like":	[
		{ "game":	"炸弹人", "price":	88.800000 }, 
	]
*/
item = cJSON_GetObjectItem(root, "like");
if (item != NULL) {
	cJSON_DeleteItemFromArray(item, 0);

	 还可以再继续深入进行删除
	//cJSON *arrObj = cJSON_GetArrayItem(item, 0);	// 根据索引获得数组中的值
	//if (arrObj != NULL) {
	//	cJSON_DeleteItemFromObject(arrObj, "price");
	//}
}

删除前：

在这里插入图片描述

删除后：

在这里插入图片描述

删除 [ ] 中的 [ ]

/* 删除： "education":	[["高中高三", "大学大四"]] */
item = cJSON_GetObjectItem(root, "education");
if (item != NULL) {
	cJSON_DeleteItemFromArray(item, 1);

	 还可以再继续深入进行删除
	//cJSON *arrArr = cJSON_GetArrayItem(item, 0);	// 根据索引获得数组中的值
	//if (arrArr != NULL) {
	//	cJSON_DeleteItemFromArray(arrArr, 1);
	//}
}

删除前：

在这里插入图片描述

删除后：

在这里插入图片描述

删除 { } 中的 { }

/* 删除
	"languages":	{
		"serialTwo":	{ "language":"白话", "grade":8 }
	}
*/
item = cJSON_GetObjectItem(root, "languages");
if (item != NULL) {
	cJSON_DeleteItemFromObject(item, "serialTwo");

	 还可以再继续深入进行删除
	//cJSON *obj = cJSON_GetObjectItem(item, "serialOne");
	//if (obj != NULL) {
	//	cJSON_DeleteItemFromObject(obj, "grade");
	//}
}

删除前：

在这里插入图片描述

删除后：

在这里插入图片描述

写入文件

// 打开文件
file = fopen(FILE_NAME, "w");
if (file == NULL) {
	printf("Open file fail！\n");

	// 释放指针内存
	cJSON_Delete(root);
	return;
}

char *cjValue = cJSON_Print(root);
// 写入文件
int ret = fwrite(cjValue, sizeof(char), strlen(cjValue), file);
if (ret == 0) {
	printf("写入文件失败！\n");
}

fclose(file);
free(cjValue);

释放cJSON指针内存

// 使用了cJSON_Parse之后，记得调用cJSON_Delete函数释放
cJSON_Delete(root);

七、全部代码

在VS2017及其以上的版本中，新建一个空项目，将代码拷贝过去，再导入cJSON.h 和 cJSON.c 文件即可运行！

#include <stdio.h>
#include <malloc.h>
#include <memory.h>
#include <stdlib.h>
#include <stdbool.h>
#include <string.h>

#include <sys/stat.h>	// 获取文件大小

#include "cJSON.h"


#define FILE_NAME "jss.json"


// 封装Json
void createJson ();
// 解析Json
void parseJson();
// 修改Json
void alterJson();
// 删除Json
void delJson();

int main (void) {

	createJson();

	parseJson();

	alterJson();

	delJson();

	return 0;
}


void createJson () {

	/*
		"interest": {
			"basketball": "篮球",
			"badminton": "羽毛球"
		},
	*/
	// 定义对象 { }
	cJSON *interest = cJSON_CreateObject();
	// 插入元素，对应 键值对
	cJSON_AddItemToObject(interest, "basketball", cJSON_CreateString("篮球"));		// 当值是字符串时，需要使用函数cJSON_CreateString()创建
	cJSON_AddItemToObject(interest, "badminton", cJSON_CreateString("羽毛球"));
	//cJSON_AddStringToObject(interest, "badminton", "羽毛球");	// 或者这样写


	/*
		"color": [ "black", "white" ],
	*/
	// 定义 [ ] 数组
	cJSON *color = cJSON_CreateArray();
	// 往数组中添加元素
	cJSON_AddItemToArray(color, cJSON_CreateString("black"));
	cJSON_AddItemToArray(color, cJSON_CreateString("white"));



	/*
		"like": [
			{ "game": "马里奥", "price": 66.6 },
			{ "game": "魂斗罗", "price": 77.7 }
		],	
	*/
	// 定义 { } 对象
	cJSON *likeObject1 = cJSON_CreateObject();
	cJSON_AddItemToObject(likeObject1, "game", cJSON_CreateString("马里奥"));
	cJSON_AddItemToObject(likeObject1, "price", cJSON_CreateNumber(66.6));		// 当值是数字时，需要使用函数cJSON_CreateNumber()创建
	//cJSON_AddNumberToObject(likeObject1, "price", 66.6);	// 或者这样写

	cJSON *likeObject2 = cJSON_CreateObject();
	cJSON_AddItemToObject(likeObject2, "game", cJSON_CreateString("魂斗罗"));
	cJSON_AddItemToObject(likeObject2, "price", cJSON_CreateNumber(77.7));

	// 定义 [ ] 数组
	cJSON *like = cJSON_CreateArray();
	// 往数组中添加元素
	cJSON_AddItemToArray(like, likeObject1);
	cJSON_AddItemToArray(like, likeObject2);



	/*
		"education": [
			[ "小学", "初中" ],
			[ "高中", "大学" ]
		],
	*/
	// 定义 [ ] 数组
	cJSON *education1 = cJSON_CreateArray();
	cJSON_AddItemToArray(education1, cJSON_CreateString("小学"));
	cJSON_AddItemToArray(education1, cJSON_CreateString("初中"));

	cJSON *education2 = cJSON_CreateArray();
	cJSON_AddItemToArray(education2, cJSON_CreateString("高中"));
	cJSON_AddItemToArray(education2, cJSON_CreateString("大学"));

	// 定义 [ ] 数组
	cJSON *education = cJSON_CreateArray();
	cJSON_AddItemToArray(education, education1);
	cJSON_AddItemToArray(education, education2);



	/*
		"languages": {
			"serialOne": { "language": "汉语", "grade": 10 },
			"serialTwo": { "language": "英语", "grade": 6}
		},
	*/
	// 定义对象 { }
	cJSON *serialOne = cJSON_CreateObject();
	cJSON_AddItemToObject(serialOne, "language", cJSON_CreateString("汉语"));		
	cJSON_AddItemToObject(serialOne, "grade", cJSON_CreateNumber(10));

	cJSON *serialTwo = cJSON_CreateObject();
	cJSON_AddItemToObject(serialTwo, "language", cJSON_CreateString("英语"));
	cJSON_AddItemToObject(serialTwo, "grade", cJSON_CreateNumber(6));

	// 定义对象 { }
	cJSON *languages = cJSON_CreateObject();
	cJSON_AddItemToObject(languages, "serialOne", serialOne);
	cJSON_AddItemToObject(languages, "serialTwo", serialTwo);






	// 创建跟对象
	cJSON *root = cJSON_CreateObject();

	// 将子项插入根项中
	cJSON_AddItemToObject(root, "name", cJSON_CreateString("小明"));	// "name":	"小明"
	cJSON_AddItemToObject(root, "age", cJSON_CreateNumber(23));			// "age":	23
	cJSON_AddItemToObject(root, "interest", interest);
	cJSON_AddItemToObject(root, "color", color);
	cJSON_AddItemToObject(root, "like", like);
	cJSON_AddItemToObject(root, "education", education);
	cJSON_AddItemToObject(root, "languages", languages);
	cJSON_AddItemToObject(root, "vip", cJSON_CreateTrue());	// "vip":	true		插入布尔类型数据需要使用cJSON_CreateBool函数
	cJSON_AddItemToObject(root, "address", cJSON_CreateNull());	// "address":	null	插入NULL值需要使用cJSON_CreateNull函数
	//cJSON_AddTrueToObject(root, "vip");
	//cJSON_AddNullToObject(root, "address");	// 或者这样写也是可以的

	// 打印控制台查看
	char *cPrint = cJSON_Print(root);
	char *cPrintUnformatted = cJSON_PrintUnformatted(root);
	printf("cJSON_Print：\n%s\n\n\n", cPrint);		// cJSON_Print：有做格式调整
	printf("cJSON_PrintUnformatted：\n%s\n\n\n", cPrintUnformatted);	// cJSON_PrintUnformatted：没有做格式调整
	// 返回的字符串指针需要自己释放
	free(cPrint);
	free(cPrintUnformatted);



	// 打开文件
	FILE *file = NULL;
	file = fopen(FILE_NAME, "w");	// FILE_NAME ==> "jss.json"
	if (file == NULL) {
		printf("Open file fail！\n");

		// 释放指针内存
		cJSON_Delete(root);
		return;
	}

	char *cjValue = cJSON_Print(root);
	// 写入文件
	//int ret = fwrite(cjValue, sizeof(char), strlen(cjValue), file);
	int ret = fputs(cjValue, file);
	if (ret == EOF) {
		printf("写入文件失败！\n");
	}

	fclose(file);
	free(cjValue);

	// 释放指针内存
	cJSON_Delete(root);
}

void parseJson () {

	// 打开文件
	FILE *file = NULL;
	file = fopen(FILE_NAME, "r");
	if (file == NULL) {
		printf("Open file fail！\n");
		return;
	}


	// 获得文件大小
	struct stat statbuf;
	stat(FILE_NAME, &statbuf);
	int fileSize = statbuf.st_size;
	printf("文件大小：%d\n", fileSize);


	// 分配符合文件大小的内存
	char *jsonStr = (char *)malloc(sizeof(char) * fileSize + 1);
	memset(jsonStr, 0, fileSize + 1);


	// 读取文件中的json字符串
	int size = fread(jsonStr, sizeof(char), fileSize, file);
	if (size == 0) {
		printf("读取文件失败！\n");
		return;
	}
	printf("%s\n", jsonStr);
	fclose(file);


	// 将读取到的json字符串转换成json变量指针
	cJSON *root = cJSON_Parse(jsonStr);
	if (!root) {
		const char *err = cJSON_GetErrorPtr();
		printf("Error before: [%s]\n", err);
		free((void *)err);
		free(jsonStr);
		return;
	}
	free(jsonStr);


	cJSON *item = NULL;
	char *v_str = NULL;
	double v_double = 0.0;
	int v_int = 0;
	bool v_bool = false;


	// 解析："name":	"小明",
	item = cJSON_GetObjectItem(root, "name");	
	if (item != NULL) {
		/* 写法一：*/
		// 判断是不是字符串类型
		//if (item->type == cJSON_String) {
		//	v_str = cJSON_Print(item);		// 通过函数获取值
		//	printf("name = %s\n", v_str);
		//	free(v_str);					// 通过函数返回的指针需要自行free，否则会导致内存泄漏
		//	v_str = NULL;
		//}
		

		/* 写法二： */
		// 判断是不是字符串类型
		if (item->type == cJSON_String) {	
			v_str = item->valuestring;		// 此赋值是浅拷贝，不需要现在释放内存
			printf("name = %s\n", v_str);
		}
		
	}
	


	// 解析："age":	"23",
	item = cJSON_GetObjectItem(root, "age");
	if (item != NULL) {	// 合法性检查
		if (item->type == cJSON_Number) {		// 判断是不是数字
			v_int = item->valueint;			// 获取值
			printf("age = %d\n", v_int);
		}
	}
	


	// 解析："vip":	true,
	item = cJSON_GetObjectItem(root, "vip");
	if (item != NULL) {
		if (item->type == cJSON_True || item->type == cJSON_False) {
			v_str = cJSON_Print(item);		// 由于bool类型结构体中没有给出，所以使用字符串代替
			printf("vip = %s\n", v_str);
			free(v_str);
			v_str = NULL;
		}		
	}
	


	// 解析："address":	null
	item = cJSON_GetObjectItem(root, "address");
	if (item != NULL && item->type == cJSON_NULL) {
		v_str = cJSON_Print(item);		// 由于NULL类型结构体中没有给出，所以使用字符串代替
		printf("address = %s\n", v_str);
		free(v_str);
		v_str = NULL;
	}
	


	/* 解析：
		"interest":	{
			"basketball":	"篮球",
			"badminton":	"羽毛球"
		},
	*/
	{
		/*************** 方式一 ***************/
		item = cJSON_GetObjectItem(root, "interest");		// 获取object对象名
		if (item != NULL) {
			cJSON *val = NULL;

			val = cJSON_GetObjectItem(item, "basketball");	// 根据object对象名获得里面的basketball数据
			if (val != NULL && val->type == cJSON_String) {
				v_str = val->valuestring;
				printf("basketball = %s\n", v_str);
			}

			val = cJSON_GetObjectItem(item, "badminton");	// 根据object对象名获得里面的badminton数据
			if (val != NULL && val->type == cJSON_String) {
				v_str = val->valuestring;
				printf("badminton = %s\n", v_str);
			}
		}

		/*************** 方式二 ***************/
		item = cJSON_GetObjectItem(root, "interest");
		if (item != NULL) {
			cJSON *obj = item->child;	// 获得 "basketball":	"篮球"

			while (obj) {
				if (obj->type == cJSON_String) {
					char *v_str = obj->valuestring;
					printf("%s = %s\n", obj->string, v_str);	// 可以通过string获得键
				}
				// 获取下一个元素
				obj = obj->next;
			}
		}
	}
	

	

	/*	解析：
		"color":	["black", "white"],
	*/
	{
		/*************** 方式一 ***************/
		item = cJSON_GetObjectItem(root, "color");
		if (item != NULL) {
			int size = cJSON_GetArraySize(item);	// 获得数组个数

			for (int i = 0; i < size; i++) {
				cJSON *arr = cJSON_GetArrayItem(item, i);	// 根据索引获得数组中的值

				if (arr != NULL && arr->type == cJSON_String) {
					v_str = arr->valuestring;
					printf("color = %s\n", v_str);
				}
			}
		}


		/*************** 方式二 ***************/
		item = cJSON_GetObjectItem(root, "color");
		if (item != NULL) {
			cJSON *arr = item->child;	// 获得 "black"

			while (arr) {
				if (arr->type == cJSON_String) {
					char *v_str = arr->valuestring;
					printf("color = %s\n", v_str);
				}
				// 获取下一个元素
				arr = arr->next;
			}
		}
	}
	



	/*
		"like": [
			{ "game": "马里奥", "price": 66.6 },
			{ "game": "魂斗罗", "price": 77.7 }
		],	
	*/
	{
		/*************** 方式一 ***************/
		item = cJSON_GetObjectItem(root, "like");
		if (item != NULL) {
			int size = cJSON_GetArraySize(item);	// 获取的数组大小

			for (int i = 0; i < size; i++) {
				cJSON *obj = cJSON_GetArrayItem(item, i);		// 获取的数组里的obj
				cJSON *val = NULL;

				if (obj != NULL && obj->type == cJSON_Object) {	// 判断数字内的元素是不是obj类型
					val = cJSON_GetObjectItem(obj, "game");		// 获得obj里的值

					if (val != NULL && val->type == cJSON_String) {
						v_str = val->valuestring;
						printf("game = %s\n", v_str);
					}

					val = cJSON_GetObjectItem(obj, "price");
					if (val != NULL && val->type == cJSON_Number) {
						v_double = val->valuedouble;
						printf("price = %.2f\n", v_double);
					}
				}
			}
		}


		/*************** 方式二 ***************/
		item = cJSON_GetObjectItem(root, "like");
		if (item != NULL) {
			cJSON *obj = item->child;	// 获得 { "game": "马里奥", "price": 66.6 }

			while (obj) {
				if (obj->type == cJSON_Object) {

					cJSON *objValue = obj->child;	// 获得 "game": "马里奥"
					while (objValue) {

						// 再通过类型去区分
						if (objValue->type == cJSON_String) {
							char *v_str = objValue->valuestring;
							printf("%s = %s\n", objValue->string, v_str);

						} else if (objValue->type == cJSON_Number) {
							double v_double = objValue->valuedouble;
							printf("%s = %.2f\n", objValue->string, v_double);
						}
						// 获取下一个元素
						objValue = objValue->next;
					}
				}
				// 获取下一组元素
				obj = obj->next;
			}
		}
	}
	



	/*
		"education": [
			[ "小学", "初中" ],
			[ "高中", "大学" ]
		],
	*/
	{
		/*************** 方式一 ***************/
		item = cJSON_GetObjectItem(root, "education");
		if (item != NULL) {
			int size = cJSON_GetArraySize(item);	// 获取的数组大小

			for (int i = 0; i < size; i++) {
				cJSON *arr = cJSON_GetArrayItem(item, i);		// 解析获得	[ "小学", "初中" ]

				if (arr != NULL && arr->type == cJSON_Array) {
					int arrSize = cJSON_GetArraySize(arr);

					for (int j = 0; j < arrSize; j++) {
						cJSON *arr2 = cJSON_GetArrayItem(arr, j);	// 再进一步解析就可以得到数组里面的元素了

						if (arr2 != NULL && arr2->type == cJSON_String) {
							v_str = arr2->valuestring;
							printf("education = %s\n", v_str);
						}
					}
				}
			}
		}

		/*************** 方式二 ***************/
		item = cJSON_GetObjectItem(root, "education");
		if (item != NULL) {
			cJSON *arr = item->child;	// 获得 [ "小学", "初中" ]

			while (arr) {
				if (arr->type == cJSON_Array) {
					cJSON *arrValue = arr->child;	// 获得 "小学"
					while (arrValue) {
						if (arrValue->type == cJSON_String) {
							char *v_str = arrValue->valuestring;
							printf("education = %s\n", v_str);
						}
						arrValue = arrValue->next;	// 获取下一个元素
					}
				}
				// 获取下一组
				arr = arr->next;
			}
		}
	}
	



	/*
		"languages": {
			"serialOne": { "language": "汉语", "grade": 10 },
			"serialTwo": { "language": "英语", "grade": 6}
		},
	*/
	{
		/*************** 方式一 ***************/
		char *arrStr[] = { "serialOne", "serialTwo" };		// 可以提前定义需要解析的对象键，这样就可以使用for循环进行解析了

		item = cJSON_GetObjectItem(root, "languages");
		if (item != NULL) {
			cJSON *val = NULL;
			int size = sizeof(arrStr) / sizeof(char *);

			// 通过遍历指针数组，获得每个对象的键，在进行解析操作（如果不使用for循环解析，那就老老实实的写代码将全部个数解析完毕）
			for (int i = 0; i < size; i++) {
				cJSON *obj1 = cJSON_GetObjectItem(item, arrStr[i]);

				if (obj1 != NULL && obj1->type == cJSON_Object) {

					val = cJSON_GetObjectItem(obj1, "language");
					if (val != NULL && val->type == cJSON_String) {
						v_str = val->valuestring;
						printf("education = %s\n", v_str);
					}

					val = cJSON_GetObjectItem(obj1, "grade");
					if (val != NULL && val->type == cJSON_Number) {
						v_int = val->valueint;
						printf("grade = %d\n", v_int);
					}
				}
			}
		}



		/*************** 方式二 ***************/
		// 在不知道键是什么的情况下 和 不知道有多少元素的情况下可用
		item = cJSON_GetObjectItem(root, "languages");
		if (item != NULL) {
			// 获取到languages里的第一个子元素
			cJSON *obj = item->child;	// 也就是："serialOne": { "language": "汉语", "grade": 10 }

			while (obj) {
				if (obj->type == cJSON_Object) {

					// 获取到子元素的子元素
					cJSON *value = obj->child;	// 也就是：{ "language": "汉语", "grade": 10 }

					while (value) {
						if (value->type == cJSON_String) {
							printf("%s = %s\n", value->string, value->valuestring);

						} else if (value->type == cJSON_Number) {
							printf("%s = %d\n", value->string, value->valueint);
						}
						// 通过next可以自由获取里面的元素了
						value = value->next;
					}
				}

				// 获得下一组子元素
				obj = obj->next;
			}
		}
	}

	


	// 使用了cJSON_Parse之后，记得调用cJSON_Delete函数释放
	cJSON_Delete(root);
}



void alterJson() {

	// 打开文件
	FILE *file = NULL;
	file = fopen(FILE_NAME, "r");
	if (file == NULL) {
		printf("Open file fail！\n");
		return;
	}


	// 获得文件大小
	struct stat statbuf;
	stat(FILE_NAME, &statbuf);
	int fileSize = statbuf.st_size;
	printf("文件大小：%d\n", fileSize);


	// 分配符合文件大小的内存
	char *jsonStr = (char *)malloc(sizeof(char) * fileSize + 1);
	memset(jsonStr, 0, fileSize + 1);


	// 读取文件中的json字符串
	int size = fread(jsonStr, sizeof(char), fileSize, file);
	if (size == 0) {
		printf("读取文件失败！\n");
		return;
	}
	printf("%s\n", jsonStr);
	fclose(file);


	// 将读取到的json字符串转换成json变量指针
	cJSON *root = cJSON_Parse(jsonStr);
	if (!root) {
		const char *err = cJSON_GetErrorPtr();
		printf("Error before: [%s]\n", err);
		free((void *)err);
		free(jsonStr);
		return;
	}
	free(jsonStr);



	cJSON *item = NULL;


	/* "name":	"小明"		====>	"name":	"小红" */
	// 使用cJSON_ReplaceItemInObject可以直接进行修改
	cJSON_ReplaceItemInObject(root, "name", cJSON_CreateString("小红"));
	// 解析打印查看是否修改成功
	item = cJSON_GetObjectItem(root, "name");
	if (item != NULL) {
		// 判断是不是字符串类型
		if (item->type == cJSON_String) {
			char *v_str = item->valuestring;		// 此赋值是浅拷贝，不需要现在释放内存
			printf("name = %s\n", v_str);
		}
	}


	/* "age": 23		====>	"age": 20 */
	cJSON_ReplaceItemInObject(root, "age", cJSON_CreateNumber(20));
	// 解析打印查看是否修改成功
	item = cJSON_GetObjectItem(root, "age");
	if (item != NULL) {
		// 判断是不是字符串类型
		if (item->type == cJSON_Number) {
			int v_int = item->valueint;		
			printf("age = %d\n", v_int);
		}
	}


	/* "vip": true	 ====>  "vip": false */
	// 使用cJSON_ReplaceItemInObject可以直接进行修改
	cJSON_ReplaceItemInObject(root, "vip", cJSON_CreateBool(false));
	// 解析打印查看是否修改成功
	item = cJSON_GetObjectItem(root, "vip");
	if (item != NULL) {
		// 判断是不是字符串类型
		if (item->type == cJSON_False || item->type == cJSON_True) {
			char *v_str = cJSON_Print(item);		// 由于bool类型结构体中没有给出，所以使用字符串代替
			printf("vip = %s\n", v_str);
			free(v_str);
			v_str = NULL;
		}
	}


	/*
		"interest":	{						 修改后：     "interest":	{				
			"basketball":	"篮球",  		  ====>				"basketball":	"姚明", 
			"badminton":	"羽毛球"							"badminton":	"林丹"
		}												  }	
	*/
	// 首先获取到需要修改的指针
	item = cJSON_GetObjectItem(root, "interest");
	if (item != NULL) {
		// 使用cJSON_ReplaceItemInObject可以直接进行修改
		cJSON_ReplaceItemInObject(item, "basketball", cJSON_CreateString("姚明"));
		cJSON_ReplaceItemInObject(item, "badminton", cJSON_CreateString("林丹"));
	}	

	// 解析打印查看是否修改成功
	item = cJSON_GetObjectItem(root, "interest");
	if (item != NULL) {
		cJSON *obj = item->child;	// 获得 "basketball":	"篮球"

		while (obj) {
			if (obj->type == cJSON_String) {
				char *v_str = obj->valuestring;
				printf("%s = %s\n", obj->string, v_str);	// 可以通过string获得键
			}
			// 获取下一个元素
			obj = obj->next;
		}
	}



	/* "color":	["black", "white"]		====>		"color":["red", "blue"]	*/
	item = cJSON_GetObjectItem(root, "color");
	if (item != NULL) {
		cJSON_ReplaceItemInArray(item, 0, cJSON_CreateString("red"));
		cJSON_ReplaceItemInArray(item, 1, cJSON_CreateString("blue"));
	}

	// 解析打印查看是否修改成功
	item = cJSON_GetObjectItem(root, "color");
	if (item != NULL) {
		cJSON *arr = item->child;	// 获得 "black"

		while (arr) {
			if (arr->type == cJSON_String) {
				char *v_str = arr->valuestring;
				printf("color = %s\n", v_str);
			}
			// 获取下一个元素
			arr = arr->next;
		}
	}



	/*
		"like": [									 修改后：  "like": [								
			{ "game": "马里奥", "price": 66.6 },	  ====>	   		{ "game": "炸弹人", "price": 88.8 },
			{ "game": "魂斗罗", "price": 77.7 }						{ "game": "中国象棋", "price": 99.9 }
		],													   ],	
	*/
	item = cJSON_GetObjectItem(root, "like");
	if (item != NULL) {
		cJSON *arrObj = NULL;

		arrObj = cJSON_GetArrayItem(item, 0);	// 根据索引获得数组中的值
		cJSON_ReplaceItemInObject(arrObj, "game", cJSON_CreateString("炸弹人"));
		cJSON_ReplaceItemInObject(arrObj, "price", cJSON_CreateNumber(88.8));

		arrObj = cJSON_GetArrayItem(item, 1);	// 根据索引获得数组中的值
		cJSON_ReplaceItemInObject(arrObj, "game", cJSON_CreateString("中国象棋"));
		cJSON_ReplaceItemInObject(arrObj, "price", cJSON_CreateNumber(99.9));
	}

	// 解析打印查看是否修改成功
	item = cJSON_GetObjectItem(root, "like");
	if (item != NULL) {
		cJSON *obj = item->child;	// 获得 { "game": "马里奥", "price": 66.6 }

		while (obj) {
			if (obj->type == cJSON_Object) {

				cJSON *objValue = obj->child;	// 获得 "game": "马里奥"
				while (objValue) {
					
					// 再通过类型去区分
					if (objValue->type == cJSON_String) {
						char *v_str = objValue->valuestring;
						printf("%s = %s\n", objValue->string, v_str);
					
					} else if (objValue->type == cJSON_Number) {
						double v_double = objValue->valuedouble;
						printf("%s = %.2f\n", objValue->string, v_double);
					}
					// 获取下一个元素
					objValue = objValue->next;
				}
			}
			// 获取下一组元素
			obj = obj->next;
		}
	}



	/*
		"education": [				修改后：	"education": [
			[ "小学", "初中" ],		====>			[ "小学六年级", "初中初三" ],
			[ "高中", "大学" ]						[ "高中高三", "大学大四" ]
		],										],
	*/
	item = cJSON_GetObjectItem(root, "education");
	if (item != NULL) {
		cJSON *arrArr = NULL;

		arrArr = cJSON_GetArrayItem(item, 0);	// 根据索引获得数组中的值
		cJSON_ReplaceItemInArray(arrArr, 0, cJSON_CreateString("小学六年级"));
		cJSON_ReplaceItemInArray(arrArr, 1, cJSON_CreateString("初中初三"));

		arrArr = cJSON_GetArrayItem(item, 1);	// 根据索引获得数组中的值
		cJSON_ReplaceItemInArray(arrArr, 0, cJSON_CreateString("高中高三"));
		cJSON_ReplaceItemInArray(arrArr, 1, cJSON_CreateString("大学大四"));
	}

	// 解析打印查看是否修改成功
	item = cJSON_GetObjectItem(root, "education");
	if (item != NULL) {
		cJSON *arr = item->child;	// 获得 [ "小学", "初中" ]

		while (arr) {
			if (arr->type == cJSON_Array) {
				cJSON *arrValue = arr->child;	// 获得 "小学"
				while (arrValue) {
					if (arrValue->type == cJSON_String) {
						char *v_str = arrValue->valuestring;
						printf("education = %s\n", v_str);
					}
					arrValue = arrValue->next;	// 获取下一个元素
				}			
			}
			// 获取下一组
			arr = arr->next;
		}
	}



	/*
		"languages": {											  修改后：	   "languages": {											
			"serialOne": { "language": "汉语", "grade": 10 },	   ====>	   		"serialOne": { "language": "粤语", "grade": 9 },
			"serialTwo": { "language": "英语", "grade": 6}							"serialTwo": { "language": "白话", "grade": 8 }
		},																	   },
	*/
	item = cJSON_GetObjectItem(root, "languages");
	if (item != NULL) {
		cJSON *obj = NULL;

		obj = cJSON_GetObjectItem(item, "serialOne");
		// 使用cJSON_ReplaceItemInObject可以直接进行修改
		cJSON_ReplaceItemInObject(obj, "language", cJSON_CreateString("粤语"));
		cJSON_ReplaceItemInObject(obj, "grade", cJSON_CreateNumber(9));

		obj = cJSON_GetObjectItem(item, "serialTwo");
		// 使用cJSON_ReplaceItemInObject可以直接进行修改
		cJSON_ReplaceItemInObject(obj, "language", cJSON_CreateString("白话"));
		cJSON_ReplaceItemInObject(obj, "grade", cJSON_CreateNumber(8));
	}

	// 解析打印查看是否修改成功
	item = cJSON_GetObjectItem(root, "languages");
	if (item != NULL) {
		// 获取到languages里的第一个子元素
		cJSON *obj = item->child;	// 也就是："serialOne": { "language": "汉语", "grade": 10 }

		while (obj) {
			if (obj->type == cJSON_Object) {

				// 获取到子元素的子元素
				cJSON *value = obj->child;	// 也就是：{ "language": "汉语", "grade": 10 }

				while (value) {
					if (value->type == cJSON_String) {
						printf("%s = %s\n", value->string, value->valuestring);

					} else if (value->type == cJSON_Number) {
						printf("%s = %d\n", value->string, value->valueint);
					}
					// 通过next可以自由获取里面的元素了
					value = value->next;
				}
			}

			obj = obj->next;
		}
	}


	// 打开文件
	file = fopen(FILE_NAME, "w");
	if (file == NULL) {
		printf("Open file fail！\n");

		// 释放指针内存
		cJSON_Delete(root);
		return;
	}

	char *cjValue = cJSON_Print(root);
	// 写入文件
	int ret = fwrite(cjValue, sizeof(char), strlen(cjValue), file);
	if (ret == 0) {
		printf("写入文件失败！\n");
	}

	fclose(file);
	free(cjValue);

	// 使用了cJSON_Parse之后，记得调用cJSON_Delete函数释放
	cJSON_Delete(root);
}

void delJson() {

	// 打开文件
	FILE *file = NULL;
	file = fopen(FILE_NAME, "r");
	if (file == NULL) {
		printf("Open file fail！\n");
		return;
	}


	// 获得文件大小
	struct stat statbuf;
	stat(FILE_NAME, &statbuf);
	int fileSize = statbuf.st_size;
	printf("文件大小：%d\n", fileSize);


	// 分配符合文件大小的内存
	char *jsonStr = (char *)malloc(sizeof(char) * fileSize + 1);
	memset(jsonStr, 0, fileSize + 1);


	// 读取文件中的json字符串
	int size = fread(jsonStr, sizeof(char), fileSize, file);
	if (size == 0) {
		printf("读取文件失败！\n");
		return;
	}
	printf("%s\n", jsonStr);
	fclose(file);


	// 将读取到的json字符串转换成json变量指针
	cJSON *root = cJSON_Parse(jsonStr);
	if (!root) {
		const char *err = cJSON_GetErrorPtr();
		printf("Error before: [%s]\n", err);
		free((void *)err);
		free(jsonStr);
		return;
	}
	free(jsonStr);



	cJSON *item = NULL;


	/* 删除： "name":	"小红" */
	// 使用这个函数直接进行删除
	cJSON_DeleteItemFromObject(root, "name");	// 通过键进行删除



	/* 删除：
		"interest":	{
			"badminton":	"林丹"
		}
	*/
	item = cJSON_GetObjectItem(root, "interest");
	// 获取到对应的节点对象就可以直接删除了
	if (item != NULL) {
		cJSON_DeleteItemFromObject(item, "badminton");	
	}



	/* 删除： "color":	["blue"] */
	item = cJSON_GetObjectItem(root, "color");
	// 获取到对应的节点数组就可以直接删除了
	if (item != NULL) {
		cJSON_DeleteItemFromArray(item, 1);	// 通过索引进行删除
	}



	/* 删除：
		"like":	[
			{ "game":	"炸弹人", "price":	88.800000 }, 
		]
	*/
	item = cJSON_GetObjectItem(root, "like");
	if (item != NULL) {
		cJSON_DeleteItemFromArray(item, 0);

		 还可以再继续深入进行删除
		//cJSON *arrObj = cJSON_GetArrayItem(item, 0);	// 根据索引获得数组中的值
		//if (arrObj != NULL) {
		//	cJSON_DeleteItemFromObject(arrObj, "price");
		//}
	}



	/* 删除： "education":	[["高中高三", "大学大四"]] */
	item = cJSON_GetObjectItem(root, "education");
	if (item != NULL) {
		cJSON_DeleteItemFromArray(item, 1);

		 还可以再继续深入进行删除
		//cJSON *arrArr = cJSON_GetArrayItem(item, 0);	// 根据索引获得数组中的值
		//if (arrArr != NULL) {
		//	cJSON_DeleteItemFromArray(arrArr, 1);
		//}
	}



	/* 删除
		"languages":	{
			"serialTwo":	{ "language":"白话", "grade":8 }
		}
	*/
	item = cJSON_GetObjectItem(root, "languages");
	if (item != NULL) {
		cJSON_DeleteItemFromObject(item, "serialTwo");

		 还可以再继续深入进行删除
		//cJSON *obj = cJSON_GetObjectItem(item, "serialOne");
		//if (obj != NULL) {
		//	cJSON_DeleteItemFromObject(obj, "grade");
		//}
	}




	// 打开文件
	file = fopen(FILE_NAME, "w");
	if (file == NULL) {
		printf("Open file fail！\n");

		// 释放指针内存
		cJSON_Delete(root);
		return;
	}

	char *cjValue = cJSON_Print(root);
	// 写入文件
	int ret = fwrite(cjValue, sizeof(char), strlen(cjValue), file);
	if (ret == 0) {
		printf("写入文件失败！\n");
	}

	fclose(file);
	free(cjValue);

	// 使用了cJSON_Parse之后，记得调用cJSON_Delete函数释放
	cJSON_Delete(root);
}

八、总结

写这篇博客花了我好多好多好多时间，也确实挺累的，不过还好，最后还是按照自己意愿写完了这篇博客！

其中，解析那一个模块有两种解析方式，建议使用第二种解析方式，比较灵活，即使后期再加多了几个节点，也照样可以解析出来，且无需再改动代码！

我个人感觉，这篇博客对json的操作，应该是很全面的了，几乎涵盖了所有的结果性，现在记录下来分享给需要的各位！

到此这篇关于C++使用cjson操作Json格式文件(创建、插入、解析、修改、删除)的文章就介绍到这了,更多相关C++使用cjson操作Json内容请搜索以前的文章或继续浏览下面的相关文章希望大家以后多多支持！

您可能感兴趣的文章:

C/C++中CJSON的使用(创建与解析JSON数据)
C++JSON库CJsonObject详解(轻量简单好用)

关于在Go语言程序中使用gojson来解析JSON格式文件和go语言 json解析的介绍已经告一段落，感谢您的耐心阅读，如果想了解更多关于android Gson解析JSON格式、android使用Gson来解析json、Android解析JSON格式数据的两种方式(JSONObject和Gson)、C++使用cjson操作Json格式文件(创建、插入、解析、修改、删除)的相关信息，请在本站寻找。

本文标签：

上一篇jsp实现针对excel及word文档的打印方法（用jsp方式打印出6×6表格）

下一篇jsp+ajax实现的局部刷新较验验证码(onblur事件触发较验)（jsp ajax局部刷新）