cJSON的源码解读

最新推荐文章于 2024-06-19 13:50:46 发布
最新推荐文章于 2024-06-19 13:50:46 发布
阅读量536 收藏 3
点赞数
分类专栏： # C 文章标签： c语言 json
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/panda5_csdn/article/details/106168034
版权

文章目录

前言

本博客内容主要是简单介绍一下cJSON的一些函数说明,由于源码不是很难,可以自己去看,如果嫌麻烦,可以直接看一下我的函数说明,然后大致看一下源码即可.

一定要去看源码,能需要很多;

cJSON的一些信息

这个地址可以下载到最新的源码: https://github.com/DaveGamble/cJSON

我看的源码比较老,学习为主,后期会阅读最新的源码;

以下是我看的源码部分:

链接：https://pan.baidu.com/s/1b7d4xsITPkUOCKbSDBsAmA 提取码：ame0

cJSON的数据结构

cJSON数据结构:
/* The cJSON structure: */
typedef struct cJSON {
  struct cJSON *next,*prev; /* next/prev allow you to walk array/object chains. Alternatively, use GetArraySize/GetArrayItem/GetObjectItem */
  struct cJSON *child;    /* An array or object item will have a child pointer pointing to a chain of the items in the array/object. */
  int type;         /* The type of the item, as above. */
  char *valuestring;      /* The item's string, if type==cJSON_String */
  int valueint;       /* The item's number, if type==cJSON_Number */
  double valuedouble;     /* The item's number, if type==cJSON_Number */
  char *string;       /* The item's name string, if this item is the child of, or is in the list of subitems of an object. */
} cJSON;

内存申请:
typedef struct cJSON_Hooks {
      void *(*malloc_fn)(size_t sz);
      void (*free_fn)(void *ptr);
} cJSON_Hooks;

基本函数

cJSON的基本函数:
	• cJSON_strcasecmp —— 两个字符比较是否相同，相同返回0，否则为1
	* cJSON_strdup —— 申请一块内存,用来保存其内容;

内部静态函数

cJSON内部函数:
	• cJSON_New_Item  —— 申请一块cJSON结构体大小的内存,并初始化为0
	• parse_number —— 将字符串转换为整型数据int或者double; 此函数分别对正负/0/数字/小数点/指数进行判断（注意，这些处理是有顺序，还有这里的代码还是值得参考的），最后将值赋给形参，并赋予类型；
	• Pow2gt —— 返回比x大的最小的2的N次方数；具体算法可参看以下文章：https://blog.csdn.net/dlf1769/article/details/78918045?utm_medium=distribute.pc_relevant.none-task-blog-BlogCommendFromMachineLearnPai2-1.nonecase&depth_1-utm_source=distribute.pc_relevant.none-task-blog-BlogCommendFromMachineLearnPai2-1.nonecase
	• ensure —— 确保读取的大小在字符串的范围内; 如果需要的大小在总长度内,直接范围偏移地址;如果不够,则使用Pow2gt先申请更大的一块,复制内容后,释放原来的内存,再返回偏移值;
	• print_number  —— 根据值的大小,将整型值改为字符串格式;分别有0,21位int和64位double数据
	• parse_hex4  —— 字符串转hex格式
	• parse_string  —— 申请指定大小的内存,将带转义字符\格式的字符串和\t这类的转换为字符串,赋值给cJSON结构的string类型,并判断其类型.(这里有utf16 -> utf8的转换过程,可以学习一下)
	• print_string_ptr  —— 将格式转换为纯字符串格式; 先判断是否有"和\或者\t这类的,如果没有,直接申请和拷贝数据后,添加2字节数据,返回申请的地址; 如果字符串为空,直接返回"";再获取长度后,添加指定的\t这类结构加入字符串
	• parse_value  —— 不同格式产生不同的数据和类型;
	• parse_array —— 确定array类型,新申请cJSON结构体,child指针指向; 获取值,如果还是array,则进行递归;如果是",",则再进行child的操作;
	• parse_object —— 基本操作于array一致
	• print_object  —— 将cJSON对象转换为字符串格式
	• print_array —— 将cJSON对象转换为字符串格式
print_value   —— 将cJSON对象转换为字符串格式

对外函数

cJSON对外接口函数:
	• cJSON_InitHooks  —— 初始化内存申请的函数为malloc和free,如果形参时有效的,则使用形参的内存申请函数(用于调用用户自己的malloc实现)
	• cJSON_Delete —— 删除所有申请的内存!这个函数采用的是递归删除,先递归到每一个child对象,然后释放string_value和string的内存,如此,一个child的子对象的内存释放递归结束,再一次进行释放;
	• cJSON_ParseWithOpts —— 申请一个cJSON对象,再赋值;
	• cJSON_Parse——cJSON_ParseWithOpts(value, 0, 0)
cJSON_Print/cJSON_PrintUnformatted —— print_value(item,0,1/0,0)

以下是简单的处理以下的对外函数就不写了,一看就能懂:
/* Get Array size/item / object item. */
int    cJSON_GetArraySize(cJSON *array)                         {cJSON *c=array->child;int i=0;while(c)i++,c=c->next;return i;}
cJSON *cJSON_GetArrayItem(cJSON *array,int item)                {cJSON *c=array->child;  while (c && item>0) item--,c=c->next; return c;}
cJSON *cJSON_GetObjectItem(cJSON *object,const char *string)    {cJSON *c=object->child; while (c && cJSON_strcasecmp(c->string,string)) c=c->next; return c;}
/* Utility for array list handling. */
static void suffix_object(cJSON *prev,cJSON *item) {prev->next=item;item->prev=prev;}
/* Utility for handling references. */
static cJSON *create_reference(cJSON *item) {cJSON *ref=cJSON_New_Item();if (!ref) return 0;memcpy(ref,item,sizeof(cJSON));ref->string=0;ref->type|=cJSON_IsReference;ref->next=ref->prev=0;return ref;}
/* Add item to array/object. */
void   cJSON_AddItemToArray(cJSON *array, cJSON *item)                      {cJSON *c=array->child;if (!item) return; if (!c) {array->child=item;} else {while (c && c->next) c=c->next; suffix_object(c,item);}}
void   cJSON_AddItemToObject(cJSON *object,const char *string,cJSON *item)  {if (!item) return; if (item->string) cJSON_free(item->string);item->string=cJSON_strdup(string);cJSON_AddItemToArray(object,item);}
void   cJSON_AddItemToObjectCS(cJSON *object,const char *string,cJSON *item)    {if (!item) return; if (!(item->type&cJSON_StringIsConst) && item->string) cJSON_free(item->string);item->string=(char*)string;item->type|=cJSON_StringIsConst;cJSON_AddItemToArray(object,item);}
void    cJSON_AddItemReferenceToArray(cJSON *array, cJSON *item)                        {cJSON_AddItemToArray(array,create_reference(item));}
void    cJSON_AddItemReferenceToObject(cJSON *object,const char *string,cJSON *item)    {cJSON_AddItemToObject(object,string,create_reference(item));}
cJSON *cJSON_DetachItemFromArray(cJSON *array,int which)            {cJSON *c=array->child;while (c && which>0) c=c->next,which--;if (!c) return 0;
    if (c->prev) c->prev->next=c->next;if (c->next) c->next->prev=c->prev;if (c==array->child) array->child=c->next;c->prev=c->next=0;return c;}
void   cJSON_DeleteItemFromArray(cJSON *array,int which)            {cJSON_Delete(cJSON_DetachItemFromArray(array,which));}
cJSON *cJSON_DetachItemFromObject(cJSON *object,const char *string) {int i=0;cJSON *c=object->child;while (c && cJSON_strcasecmp(c->string,string)) i++,c=c->next;if (c) return cJSON_DetachItemFromArray(object,i);return 0;}
void   cJSON_DeleteItemFromObject(cJSON *object,const char *string) {cJSON_Delete(cJSON_DetachItemFromObject(object,string));}
/* Replace array/object items with new ones. */
void   cJSON_InsertItemInArray(cJSON *array,int which,cJSON *newitem)       {cJSON *c=array->child;while (c && which>0) c=c->next,which--;if (!c) {cJSON_AddItemToArray(array,newitem);return;}
    newitem->next=c;newitem->prev=c->prev;c->prev=newitem;if (c==array->child) array->child=newitem; else newitem->prev->next=newitem;}
void   cJSON_ReplaceItemInArray(cJSON *array,int which,cJSON *newitem)      {cJSON *c=array->child;while (c && which>0) c=c->next,which--;if (!c) return;
    newitem->next=c->next;newitem->prev=c->prev;if (newitem->next) newitem->next->prev=newitem;
    if (c==array->child) array->child=newitem; else newitem->prev->next=newitem;c->next=c->prev=0;cJSON_Delete(c);}
void   cJSON_ReplaceItemInObject(cJSON *object,const char *string,cJSON *newitem){int i=0;cJSON *c=object->child;while(c && cJSON_strcasecmp(c->string,string))i++,c=c->next;if(c){newitem->string=cJSON_strdup(string);cJSON_ReplaceItemInArray(object,i,newitem);}}
/* Create basic types: */
cJSON *cJSON_CreateNull(void)                   {cJSON *item=cJSON_New_Item();if(item)item->type=cJSON_NULL;return item;}
cJSON *cJSON_CreateTrue(void)                   {cJSON *item=cJSON_New_Item();if(item)item->type=cJSON_True;return item;}
cJSON *cJSON_CreateFalse(void)                  {cJSON *item=cJSON_New_Item();if(item)item->type=cJSON_False;return item;}
cJSON *cJSON_CreateBool(int b)                  {cJSON *item=cJSON_New_Item();if(item)item->type=b?cJSON_True:cJSON_False;return item;}
cJSON *cJSON_CreateNumber(double num)           {cJSON *item=cJSON_New_Item();if(item){item->type=cJSON_Number;item->valuedouble=num;item->valueint=(int)num;}return item;}
cJSON *cJSON_CreateString(const char *string)   {cJSON *item=cJSON_New_Item();if(item){item->type=cJSON_String;item->valuestring=cJSON_strdup(string);}return item;}
cJSON *cJSON_CreateArray(void)                  {cJSON *item=cJSON_New_Item();if(item)item->type=cJSON_Array;return item;}
cJSON *cJSON_CreateObject(void)                 {cJSON *item=cJSON_New_Item();if(item)item->type=cJSON_Object;return item;}
/* Create Arrays: */
cJSON *cJSON_CreateIntArray(const int *numbers,int count)       {int i;cJSON *n=0,*p=0,*a=cJSON_CreateArray();for(i=0;a && i<count;i++){n=cJSON_CreateNumber(numbers[i]);if(!i)a->child=n;else suffix_object(p,n);p=n;}return a;}
cJSON *cJSON_CreateFloatArray(const float *numbers,int count)   {int i;cJSON *n=0,*p=0,*a=cJSON_CreateArray();for(i=0;a && i<count;i++){n=cJSON_CreateNumber(numbers[i]);if(!i)a->child=n;else suffix_object(p,n);p=n;}return a;}
cJSON *cJSON_CreateDoubleArray(const double *numbers,int count) {int i;cJSON *n=0,*p=0,*a=cJSON_CreateArray();for(i=0;a && i<count;i++){n=cJSON_CreateNumber(numbers[i]);if(!i)a->child=n;else suffix_object(p,n);p=n;}return a;}
cJSON *cJSON_CreateStringArray(const char **strings,int count)  {int i;cJSON *n=0,*p=0,*a=cJSON_CreateArray();for(i=0;a && i<count;i++){n=cJSON_CreateString(strings[i]);if(!i)a->child=n;else suffix_object(p,n);p=n;}return a;}

使用

可以从test文件里得知使用方法:

/*
  Copyright (c) 2009 Dave Gamble
 
  Permission is hereby granted, free of charge, to any person obtaining a copy
  of this software and associated documentation files (the "Software"), to deal
  in the Software without restriction, including without limitation the rights
  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
  copies of the Software, and to permit persons to whom the Software is
  furnished to do so, subject to the following conditions:
 
  The above copyright notice and this permission notice shall be included in
  all copies or substantial portions of the Software.
 
  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
  THE SOFTWARE.
*/

#include <stdio.h>
#include <stdlib.h>
#include "cJSON.h"

/* Parse text to JSON, then render back to text, and print! */
void doit(char *text)
{
	char *out;cJSON *json;
	
	json=cJSON_Parse(text);
	if (!json) {printf("Error before: [%s]\n",cJSON_GetErrorPtr());}
	else
	{
		out=cJSON_Print(json);
		cJSON_Delete(json);
		printf("%s\n",out);
		free(out);
	}
}

/* Read a file, parse, render back, etc. */
void dofile(char *filename)
{
	FILE *f;long len;char *data;
	
	f=fopen(filename,"rb");fseek(f,0,SEEK_END);len=ftell(f);fseek(f,0,SEEK_SET);
	data=(char*)malloc(len+1);fread(data,1,len,f);fclose(f);
	doit(data);
	free(data);
}

/* Used by some code below as an example datatype. */
struct record {const char *precision;double lat,lon;const char *address,*city,*state,*zip,*country; };

/* Create a bunch of objects as demonstration. */
void create_objects()
{
	cJSON *root,*fmt,*img,*thm,*fld;char *out;int i;	/* declare a few. */
	/* Our "days of the week" array: */
	const char *strings[7]={"Sunday","Monday","Tuesday","Wednesday","Thursday","Friday","Saturday"};
	/* Our matrix: */
	int numbers[3][3]={{0,-1,0},{1,0,0},{0,0,1}};
	/* Our "gallery" item: */
	int ids[4]={116,943,234,38793};
	/* Our array of "records": */
	struct record fields[2]={
		{"zip",37.7668,-1.223959e+2,"","SAN FRANCISCO","CA","94107","US"},
		{"zip",37.371991,-1.22026e+2,"","SUNNYVALE","CA","94085","US"}};

	/* Here we construct some JSON standards, from the JSON site. */
	
	/* Our "Video" datatype: */
	root=cJSON_CreateObject();	
	cJSON_AddItemToObject(root, "name", cJSON_CreateString("Jack (\"Bee\") Nimble"));
	cJSON_AddItemToObject(root, "format", fmt=cJSON_CreateObject());
	cJSON_AddStringToObject(fmt,"type",		"rect");
	cJSON_AddNumberToObject(fmt,"width",		1920);
	cJSON_AddNumberToObject(fmt,"height",		1080);
	cJSON_AddFalseToObject (fmt,"interlace");
	cJSON_AddNumberToObject(fmt,"frame rate",	24);
	
	out=cJSON_Print(root);	cJSON_Delete(root);	printf("%s\n",out);	free(out);	/* Print to text, Delete the cJSON, print it, release the string. */

	/* Our "days of the week" array: */
	root=cJSON_CreateStringArray(strings,7);

	out=cJSON_Print(root);	cJSON_Delete(root);	printf("%s\n",out);	free(out);

	/* Our matrix: */
	root=cJSON_CreateArray();
	for (i=0;i<3;i++) cJSON_AddItemToArray(root,cJSON_CreateIntArray(numbers[i],3));

/*	cJSON_ReplaceItemInArray(root,1,cJSON_CreateString("Replacement")); */
	
	out=cJSON_Print(root);	cJSON_Delete(root);	printf("%s\n",out);	free(out);


	/* Our "gallery" item: */
	root=cJSON_CreateObject();
	cJSON_AddItemToObject(root, "Image", img=cJSON_CreateObject());
	cJSON_AddNumberToObject(img,"Width",800);
	cJSON_AddNumberToObject(img,"Height",600);
	cJSON_AddStringToObject(img,"Title","View from 15th Floor");
	cJSON_AddItemToObject(img, "Thumbnail", thm=cJSON_CreateObject());
	cJSON_AddStringToObject(thm, "Url", "http:/*www.example.com/image/481989943");
	cJSON_AddNumberToObject(thm,"Height",125);
	cJSON_AddStringToObject(thm,"Width","100");
	cJSON_AddItemToObject(img,"IDs", cJSON_CreateIntArray(ids,4));

	out=cJSON_Print(root);	cJSON_Delete(root);	printf("%s\n",out);	free(out);

	/* Our array of "records": */

	root=cJSON_CreateArray();
	for (i=0;i<2;i++)
	{
		cJSON_AddItemToArray(root,fld=cJSON_CreateObject());
		cJSON_AddStringToObject(fld, "precision", fields[i].precision);
		cJSON_AddNumberToObject(fld, "Latitude", fields[i].lat);
		cJSON_AddNumberToObject(fld, "Longitude", fields[i].lon);
		cJSON_AddStringToObject(fld, "Address", fields[i].address);
		cJSON_AddStringToObject(fld, "City", fields[i].city);
		cJSON_AddStringToObject(fld, "State", fields[i].state);
		cJSON_AddStringToObject(fld, "Zip", fields[i].zip);
		cJSON_AddStringToObject(fld, "Country", fields[i].country);
	}
	
/*	cJSON_ReplaceItemInObject(cJSON_GetArrayItem(root,1),"City",cJSON_CreateIntArray(ids,4)); */
	
	out=cJSON_Print(root);	cJSON_Delete(root);	printf("%s\n",out);	free(out);

}

int main (int argc, const char * argv[]) {
	/* a bunch of json: */
	char text1[]="{\n\"name\": \"Jack (\\\"Bee\\\") Nimble\", \n\"format\": {\"type\":       \"rect\", \n\"width\":      1920, \n\"height\":     1080, \n\"interlace\":  false,\"frame rate\": 24\n}\n}";	
	char text2[]="[\"Sunday\", \"Monday\", \"Tuesday\", \"Wednesday\", \"Thursday\", \"Friday\", \"Saturday\"]";
	char text3[]="[\n    [0, -1, 0],\n    [1, 0, 0],\n    [0, 0, 1]\n	]\n";
	char text4[]="{\n		\"Image\": {\n			\"Width\":  800,\n			\"Height\": 600,\n			\"Title\":  \"View from 15th Floor\",\n			\"Thumbnail\": {\n				\"Url\":    \"http:/*www.example.com/image/481989943\",\n				\"Height\": 125,\n				\"Width\":  \"100\"\n			},\n			\"IDs\": [116, 943, 234, 38793]\n		}\n	}";
	char text5[]="[\n	 {\n	 \"precision\": \"zip\",\n	 \"Latitude\":  37.7668,\n	 \"Longitude\": -122.3959,\n	 \"Address\":   \"\",\n	 \"City\":      \"SAN FRANCISCO\",\n	 \"State\":     \"CA\",\n	 \"Zip\":       \"94107\",\n	 \"Country\":   \"US\"\n	 },\n	 {\n	 \"precision\": \"zip\",\n	 \"Latitude\":  37.371991,\n	 \"Longitude\": -122.026020,\n	 \"Address\":   \"\",\n	 \"City\":      \"SUNNYVALE\",\n	 \"State\":     \"CA\",\n	 \"Zip\":       \"94085\",\n	 \"Country\":   \"US\"\n	 }\n	 ]";

	/* Process each json textblock by parsing, then rebuilding: */
	doit(text1);
	doit(text2);	
	doit(text3);
	doit(text4);
	doit(text5);

	/* Parse standard testfiles: */
/*	dofile("../../tests/test1"); */
/*	dofile("../../tests/test2"); */
/*	dofile("../../tests/test3"); */
/*	dofile("../../tests/test4"); */
/*	dofile("../../tests/test5"); */

	/* Now some samplecode for building objects concisely: */
	create_objects();
	
	return 0;
}

收获

简单说说我在这个源码里的收获吧:

  1. 了解了utf-16的格式;
  2. 一种获取到某个值最接近的2的n次的值算法;
panda@Code
关注
  • 0
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
cJSON源码解析
YoungSusie的博客
08-04 533
  件！    cJSON 是 C语言中的一个JSON编解码器，非常轻量级，C开源代码汇总，代码量少，不到一千行，代码的可读性高，很适合作为 C 语言项目进行学习。    对于 json 格式编码与解码，其实就是类似于一个解释器，主要的原理是运用递归。   首先看下 cJSON.h 中定义的 cJSON数据结构， typedef struct cJSON { struct cJSON *ne...
cjson源码学习
master-dragon的专栏
09-28 1924
cjson源代码下载地址https://sourceforge.net/projects/cjson/?source=directory主要是cJSON.h , cJSON.c , test.c三个文件json结构json简单说就是javascript中的对象和数组，所以这两种结构就是对象和数组两种结构，通过这两种结构可以表示各种复杂的结构。 1. 对象：对象在js中表示为“{}”括起来的内
cJSON源码（c语言版）
12-15
通过C语言实现的cJSON源码，用于解析json数据包非常好用，亲测可用。
C语言调用cJSON库解析json
Leonban的博客
11-08 2178
一、源代码文件下载 自己使用时可以只需要其中的cJSON.c和cJSON.h文件就可以了，只需要将cJSON和自己的main文件一起编译即可。 下载地址：https://download.csdn.net/download/Hearbeat/38500047 二、重要的接口函数： 1.cJSON *cJSON_Parse(const char *value); 解析JSON数据包，并按照cJSON结构体的结构序列化整个数据包。可以看做是获取一个句柄。 2.cJSON *cJSON_GetObjectIt
cJSON源码及解析详解
最新发布
慢慢变好
06-19 137
JSON(JavaScript Object Notation, JS 对象简谱) 是一种轻量级的数据交换格式。它基于 ECMAScript (欧洲计算机协会制定的js规范)的一个子集，采用完全独立于编程语言的文本格式来存储和表示数据。简洁和清晰的层次结构使得 JSON 成为理想的数据交换语言。 易于人阅读和编写，同时也易于机器解析和生成，并有效地提升网络传输效率。cJSON从名字可知，整个项目都是以极标准的C来写的，意思说，可以跨各种平台使用了。cJSON是一个超轻巧，携带方便，单文件，简单的可以作为AN
cjson学习篇四：cJSON API介绍
weixin_42645653的博客
09-13 2605
函数介绍 cJSON_Version()   函数原型：CJSON_PUBLIC(const char*) cJSON_Version(void);   函数功能：以字符串的形式返回cJSON版本号。   参数介绍：无。   返回值： cJSON_InitHooks()   函数原型：CJSON_PUBLIC(void) cJSON_InitHooks(cJSON_Hooks* hooks);   函数功能：为cJSON提供malloc, realloc和free函数   参数介绍：     cJSON_H
DSP学习 -- cJSON使用教程
不积跬步，无以至千里
08-07 3817
JSON 需要简单的了解一下。谁知道啥时候用上呢~
cJSON库学习总结+使用例程
guoweilkd的博客
04-27 2260
cJSON学习总结 cJSON是什么 cJson是一个用于解析json文件的库，它由c语言编写，开源、使用简单。 cJSON git网站:https://github.com/DaveGamble/cJSON. json 官网:http://www.json.org json文件的格式 下面是一个简单但覆盖了大多常用格式的json文件。后面会围绕它做简单的格式介绍。 { "name...
cJSON源码 C语言库
08-07
Copyright (c) 2009-2017 Dave Gamble and cJSON contributors 使用说明见博客：...
Lua CJSON 源码
07-10
Lua CJSON 为 Lua 语言提供高性能的 JSON 解析器和编码器，其性能比纯 Lua 库要高 10 到 20 倍。Lua CJSON 完全支持 UTF-8 ，无需依赖其他非 Lua/LuaJIT 的相关包。
Linux中cJSON源码+部分实例分析
10-21
本文将探讨cJSON源码中的关键部分，并通过实例来帮助理解其工作原理。 1. **错误处理**： `cJSON_GetErrorPtr` 函数返回一个错误指针`ep`，当JSON解析或生成过程中发生错误时，该指针将指向一个描述错误的字符串。...
cJSON源码，解析JSON数据
03-13
3. cJSON_False、cJSON_True、cJSON_NULL、cJSON_Number、cJSON_String：分别表示JSON布尔值、null值、数字和字符串。 使用cJSON库的基本步骤如下： 1. 包含头文件：在C程序中，首先需要`#include "cJSON.h"`引入...
cJson学习
c1063891514的博客
04-21 1027
目录 JSON介绍 JSON 语法规则 JSON 键/值对 打包解包JSON数据 生成JSON数据 解析JSON数据 使用例子 JSON介绍 JSON(JavaScript Object Notation, JS 对象简谱)是一种轻量级的数据交换格式。它就是一种数据格式 JSON 语法规则 在 JS 语言中，一切都是对象。因此，任何支持的类型都可以通过 JSON ...
CJSON函数API说明
DDouLong的博客
07-15 4400
cJSON_AddItemReferenceToObject(cJSON *object, const char *string, cJSON *item) 作用：将数组添加进对象 cJSON_CreateObject(void) 作用：创建项目数组 extern cJSON *cJSON_Parse(const char *value); 作用：首先调用cJSON_Parse()函数，解析JSON数据包，并按照cJSON结构体的结构序列化整个数据包。使用该函数会通过malloc()函数在内存中开辟一个空间
CJSON封装，对JSON格式解析及封装源码
u013358093的博客
03-06 504
CJSON封装，对JSON格式解析及封装源码
优化cJSON_AddItemToArray函数，提高插入速率
绅士喵的博客
03-03 6838
最近在我的写了一个API程序，要求返回响应的数据是JSON，格式类似下面这种： [{ "columns":[ {"text":"Time","type":"time"}, {"text":"Country","type":"string"}, {"text":"Number","type":"number"} ], "rows":[ [1234567,"...
cJSON库的使用（一）
weixin_42067873的博客
02-14 1484
1、JSON格式：一对大括号，相当于XML的头和尾，内部全是键值对 { "name" : "apple"， "sex" : "famale"， "high" : "178"， "girls":["alice", "ruby", "kit"]， "家电" :{"TV":"changhong"} } 注：结合JSON视图工具，可以把JSON数据结构化展示...
cJSON源码解析（超级详细！！！）
zhuikefeng的博客
06-26 4435
1.cJSON结构体定义 typedef struct cJSON { struct cJSON *next,*prev; /* next/prev allow you to walk array/object chains. Alternatively, use GetArraySize/GetArrayItem/GetObjectItem */ struct cJSON *child; /* An array or object item will have a child pointer p
cJSON源码学习总结
ZBH的博客
12-23 3674
JSON 介绍JSON(JavaScript Object Notation) 是一种轻量级的数据交换格式，可以把 JSON 的结构理解成无序的、可嵌套的 key-value 键值对集合，这些 key-value 键值对以结构体或数组的形式来组织的。同一级的 key-value 键值对之间用一个,(逗号) 隔开，每个 key-value 键值对是由一个 key 后面紧接一个:(冒号)，冒号后面是这个
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值