开源项目cJSON具体实现6（对象的解析）

最新推荐文章于 2024-08-15 09:53:58 发布
最新推荐文章于 2024-08-15 09:53:58 发布
阅读量244 收藏 1
点赞数 1
分类专栏： # C语言 # C/C++项目笔记整理
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/it_is_me_a/article/details/101935904
版权

文章目录

JSON 对象语法

本章实现的是JSON对象。JSON对象的实现和JSON数组的实现很是相似，我们可以对比着来看。

JSON数组JSON对象
在这里插入图片描述在这里插入图片描述
JSON数组是由JSON值value组成JSON对象是由成员对象member组成，成员对象是键值对
JSON数组是 [] 构成JSON对象是 {} 构成
一个数组可以包含零至多个值，
而这些值可以字符，数字，也可以是数组；
值与值之间以逗号分隔，
例如 []、[1,2,true]、[[1,2],[3,4],“abc”]
都是合法的数组。但注意
JSON数组 不接受末端额外的逗号，例如 [1,2,] 是不合法的。		JSON对象由成员对象组成，成员对象由键值对组成，其中键为 JSON字符串(string)，值是任何JSON值(value)，中间由冒号分割(%x3A)。

JSON对象语法。

JSON-text = ws value ws
value = null / false / true / number / string / array / object

object = %x7B ws [ member *( ws %x2C ws member ) ] ws %x7D
member = string ws %x3A ws value

解释：

  • %x7B 是左大括号 {
  • %x2C 是逗号 ,
  • %x7D 是右大括号 }
  • ws 是空白字符
  • %x3A 是冒号
头文件

在 ECMA-404 标准中，并没有规定对象中每个成员的键一定要唯一的，也没有规定是否需要维持成员的次序。为了简单起见，我们选择用动态数组来实现JSON对象，对于对象，既然我们采用了动态数组的方案，那么每个对象就是成员的数组：

typedef struct lept_value lept_value;
typedef struct lept_member lept_member;

struct lept_value {
    union {
        struct { lept_member* m; size_t size; }o;
        struct { lept_value* e; size_t size; }a;
        struct { char* s; size_t len; }s;
        double n;
    }u;
    lept_type type;
};

/*动态数组表示JSON对象（键值对）*/
struct lept_member {
    char* k;  /* 键（字符串） */
    size_t klen;   /* 字符串的长度，因为可能包含空字符\u0000 */
    lept_value v;           /* 值 */
};

添加错误码：

enum {
    /* ... */
    LEPT_PARSE_MISS_KEY,      //没有键
    LEPT_PARSE_MISS_COLON,      //没有冒号
    LEPT_PARSE_MISS_COMMA_OR_CURLY_BRACKET
};

同样的，添加API

size_t lept_get_object_size(const lept_value* v);
const char* lept_get_object_key(conat lept_calue* v, size_t index);
size_t lept_get_object_key_length(const lept_value* v, size_t index);
lept_value* lept_get_object_value(const lept_value* v, size_t index);

实现API函数：

size_t lept_get_object_size(const lept_value* v)
{
        assert(v != NULL && v->type == LEPT_OBJECT);
        return v->u.o.size;
}

const char* lept_get_object_key(const lept_value* v, size_t index)
{
        assert(v != NULL && v->type == LEPT_OBJECT);
        assert(index < v->u.o.size);
        return v->u.o.m[index].k;
}

size_t lept_get_object_key_length(const lept_value* v, size_t index)
{
        assert(v != NULL && v->type == LEPT_OBJECT);
        assert(index < v->u.o.size);
        return v->u.o.m[index].klen;
}

lept_value* lept_get_object_value(const lept_value* v, size_t index)
{
        assert(v != NULL && v->type == LEPT_OBJECT);
        assert(index < v->u.o.size);
       return &v->u.o.m[index].v;
}
测试代码
static void test_parse_object() {
    lept_value v;
    size_t i;

    lept_init(&v);
    EXPECT_EQ_INT(LEPT_PARSE_OK, lept_parse(&v, " { } "));
    EXPECT_EQ_INT(LEPT_OBJECT, lept_get_type(&v));
    EXPECT_EQ_SIZE_T(0, lept_get_object_size(&v));
    lept_free(&v);

    lept_init(&v);
    EXPECT_EQ_INT(LEPT_PARSE_OK, lept_parse(&v,
        " { "
        "\"n\" : null , "
        "\"f\" : false , "
        "\"t\" : true , "
        "\"i\" : 123 , "
        "\"s\" : \"abc\", "
        "\"a\" : [ 1, 2, 3 ],"
        "\"o\" : { \"1\" : 1, \"2\" : 2, \"3\" : 3 }"
        " } "
    ));
    EXPECT_EQ_INT(LEPT_OBJECT, lept_get_type(&v));
    EXPECT_EQ_SIZE_T(7, lept_get_object_size(&v));
    EXPECT_EQ_STRING("n", lept_get_object_key(&v, 0), lept_get_object_key_length(&v, 0));
    EXPECT_EQ_INT(LEPT_NULL,   lept_get_type(lept_get_object_value(&v, 0)));
    EXPECT_EQ_STRING("f", lept_get_object_key(&v, 1), lept_get_object_key_length(&v, 1));
    EXPECT_EQ_INT(LEPT_FALSE,  lept_get_type(lept_get_object_value(&v, 1)));
    EXPECT_EQ_STRING("t", lept_get_object_key(&v, 2), lept_get_object_key_length(&v, 2));
    EXPECT_EQ_INT(LEPT_TRUE,   lept_get_type(lept_get_object_value(&v, 2)));
    EXPECT_EQ_STRING("i", lept_get_object_key(&v, 3), lept_get_object_key_length(&v, 3));
    EXPECT_EQ_INT(LEPT_NUMBER, lept_get_type(lept_get_object_value(&v, 3)));
    EXPECT_EQ_DOUBLE(123.0, lept_get_number(lept_get_object_value(&v, 3)));
    EXPECT_EQ_STRING("s", lept_get_object_key(&v, 4), lept_get_object_key_length(&v, 4));
    EXPECT_EQ_INT(LEPT_STRING, lept_get_type(lept_get_object_value(&v, 4)));
    EXPECT_EQ_STRING("abc", lept_get_string(lept_get_object_value(&v, 4)), 
	lept_get_string_length(lept_get_object_value(&v, 4)));
    EXPECT_EQ_STRING("a", lept_get_object_key(&v, 5), lept_get_object_key_length(&v, 5));
    EXPECT_EQ_INT(LEPT_ARRAY, lept_get_type(lept_get_object_value(&v, 5)));
    EXPECT_EQ_SIZE_T(3, lept_get_array_size(lept_get_object_value(&v, 5)));

    for (i = 0; i < 3; i++) {
        lept_value* e = lept_get_array_element(lept_get_object_value(&v, 5), i);
        EXPECT_EQ_INT(LEPT_NUMBER, lept_get_type(e));
        EXPECT_EQ_DOUBLE(i + 1.0, lept_get_number(e));
    }
    EXPECT_EQ_STRING("o", lept_get_object_key(&v, 6), lept_get_object_key_length(&v, 6));
    {
        lept_value* o = lept_get_object_value(&v, 6);
        EXPECT_EQ_INT(LEPT_OBJECT, lept_get_type(o));
        for (i = 0; i < 3; i++) {
            lept_value* ov = lept_get_object_value(o, i);
            EXPECT_TRUE('1' + i == lept_get_object_key(o, i)[0]);
            EXPECT_EQ_SIZE_T(1, lept_get_object_key_length(o, i));
            EXPECT_EQ_INT(LEPT_NUMBER, lept_get_type(ov));
            EXPECT_EQ_DOUBLE(i + 1.0, lept_get_number(ov));
        }
    }

    lept_free(&v);
}

static void test_parse() {
        /*   ...    */
        test_parse_object();
}

错误码的测试函数

static void test_parse_miss_key() {
        TEST_ERROR(LEPT_PARSE_MISS_KEY, "{:1,");
        TEST_ERROR(LEPT_PARSE_MISS_KEY, "{1:1,");
        TEST_ERROR(LEPT_PARSE_MISS_KEY, "{true:1,");
        TEST_ERROR(LEPT_PARSE_MISS_KEY, "{false:1,");
        TEST_ERROR(LEPT_PARSE_MISS_KEY, "{null:1,");
        TEST_ERROR(LEPT_PARSE_MISS_KEY, "{[]:1,");
        TEST_ERROR(LEPT_PARSE_MISS_KEY, "{{}:1,");
        TEST_ERROR(LEPT_PARSE_MISS_KEY, "{\"a\":1,");
}

static void test_parse_miss_colon() {
        TEST_ERROR(LEPT_PARSE_MISS_COLON, "{\"a\"}");
        TEST_ERROR(LEPT_PARSE_MISS_COLON, "{\"a\",\"b\"}");
}

static void test_parse_miss_comma_or_curly_bracket() {
        TEST_ERROR(LEPT_PARSE_MISS_COMMA_OR_CURLY_BRACKET, "{\"a\":1");
        TEST_ERROR(LEPT_PARSE_MISS_COMMA_OR_CURLY_BRACKET, "{\"a\":1]");
        TEST_ERROR(LEPT_PARSE_MISS_COMMA_OR_CURLY_BRACKET, "{\"a\":1 \"b\"");
        TEST_ERROR(LEPT_PARSE_MISS_COMMA_OR_CURLY_BRACKET, "{\"a\":{}");
}

static void test_parse() {
        /*   ...    */
        test_parse_object();
        test_parse_miss_key();
        test_parse_miss_colon();
        test_parse_miss_comma_or_curly_bracket();
}
函数实现

在函数是先前，我们先来讨论一个问题—重构

代码重构 code refactoring是指在不改变软件外在行为时，修改代码以改进结构。代码重构十分依赖于单元测试，因为我们是通过单元测试去维护代码的正确性。有了足够的单元测试，我们可以放胆去重构，尝试并评估不同的改进方式，找到合乎心意而且能通过单元测试的改动，我们才提交它。

我们知道，成员的键也是一个 JSON 字符串，然而，我们不使用 lept_value 存储键，因为这样会浪费了当中 type 这个无用的字段。由于 lept_parse_string() 是直接地把解析的结果写进一个 lept_value，所以我们先用「提取方法 」的重构方式，把解析 JSON 字符串及写入 lept_value 分拆成两部分。

先看原来的 lept_parse_string()函数：

static int lept_parse_string(lept_context* c, lept_value* v) {
    size_t head = c->top, len;
    unsigned u, u2;
    const char* p;
    EXPECT(c, '\"');
    p = c->json;
    for (;;) {
        char ch = *p++;
        switch (ch) {
            case '\"':
                len = c->top - head;
                lept_set_string(v, (const char*)lept_context_pop(c, len), len);
                c->json = p;
                return LEPT_PARSE_OK;
            case '\\':
                switch (*p++) {
                    case '\"': PUTC(c, '\"'); break;
                    case '\\': PUTC(c, '\\'); break;
                    case '/':  PUTC(c, '/' ); break;
                    case 'b':  PUTC(c, '\b'); break;
                    case 'f':  PUTC(c, '\f'); break;
                    case 'n':  PUTC(c, '\n'); break;
                    case 'r':  PUTC(c, '\r'); break;
                    case 't':  PUTC(c, '\t'); break;
                    case 'u':
                        if (!(p = lept_parse_hex4(p, &u)))
                            STRING_ERROR(LEPT_PARSE_INVALID_UNICODE_HEX);
                        if (u >= 0xD800 && u <= 0xDBFF) { /* surrogate pair */
                            if (*p++ != '\\')
                                STRING_ERROR(LEPT_PARSE_INVALID_UNICODE_SURROGATE);
                            if (*p++ != 'u')
                                STRING_ERROR(LEPT_PARSE_INVALID_UNICODE_SURROGATE);
                            if (!(p = lept_parse_hex4(p, &u2)))
                                STRING_ERROR(LEPT_PARSE_INVALID_UNICODE_HEX);
                            if (u2 < 0xDC00 || u2 > 0xDFFF)
                                STRING_ERROR(LEPT_PARSE_INVALID_UNICODE_SURROGATE);
                            u = (((u - 0xD800) << 10) | (u2 - 0xDC00)) + 0x10000;
                        }
                        lept_encode_utf8(c, u);
                        break;
                    default:
                        STRING_ERROR(LEPT_PARSE_INVALID_STRING_ESCAPE);
                }
                break;
            case '\0':
                STRING_ERROR(LEPT_PARSE_MISS_QUOTATION_MARK);
            default:
                if ((unsigned char)ch < 0x20)
                    STRING_ERROR(LEPT_PARSE_INVALID_STRING_CHAR);
                PUTC(c, ch);
        }
    }
}

这段函数有两个作用：1. 是解析字符串 2. 是把字符串保存在 lept_value里，因为JSON对象在解析时，前面键的部分也就是字符串是保存在lept_member里面，所以我们把这个函数拆开看。

/* 解析 JSON 字符串，把结果写入 str 和 len */
/* str 指向 c->stack 中的元素，需要在 c->stack  */
static int lept_parse_string_raw(lept_context* c, char** str, size_t* len)
{
        size_t head = c->top;
        unsigned u, u2;
        const char* p;
        EXPECT(c, '\"');
        p = c->json;
        for (;;) {
            char ch = *p++;
            switch (ch) {
                case '\"':
                    *len = c->top - head;//注意，这里得用*len，而不是len，主要是因为要改变的参数里的值
                              *str = lept_context_pop(c, *len);
                              c->json = p;
                    return LEPT_PARSE_OK;
                case '\\':
                    switch (*p++) {
                        case '\"': PUTC(c, '\"'); break;
                        case '\\': PUTC(c, '\\'); break;
                        case '/':  PUTC(c, '/' ); break;
                        case 'b':  PUTC(c, '\b'); break;
                        case 'f':  PUTC(c, '\f'); break;
                        case 'n':  PUTC(c, '\n'); break;
                        case 'r':  PUTC(c, '\r'); break;
                        case 't':  PUTC(c, '\t'); break;
                        case 'u':
                            if (!(p = lept_parse_hex4(p, &u)))
                                STRING_ERROR(LEPT_PARSE_INVALID_UNICODE_HEX);
                            if (u >= 0xD800 && u <= 0xDBFF) { /* surrogate pair */
                                if (*p++ != '\\')
                                    STRING_ERROR(LEPT_PARSE_INVALID_UNICODE_SURROGATE);
                                if (*p++ != 'u')
                                    STRING_ERROR(LEPT_PARSE_INVALID_UNICODE_SURROGATE);
                                if (!(p = lept_parse_hex4(p, &u2)))
                                    STRING_ERROR(LEPT_PARSE_INVALID_UNICODE_HEX);
                                if (u2 < 0xDC00 || u2 > 0xDFFF)
                                    STRING_ERROR(LEPT_PARSE_INVALID_UNICODE_SURROGATE);
                                u = (((u - 0xD800) << 10) | (u2 - 0xDC00)) + 0x10000;
                            }
                            lept_encode_utf8(c, u);
                            break;
                        default:
                            STRING_ERROR(LEPT_PARSE_INVALID_STRING_ESCAPE);
                    }
                    break;
                case '\0':
                    STRING_ERROR(LEPT_PARSE_MISS_QUOTATION_MARK);
                default:
                    if ((unsigned char)ch < 0x20)
                        STRING_ERROR(LEPT_PARSE_INVALID_STRING_CHAR);
                    PUTC(c, ch);
            }
        }
}

static int lept_parse_string(lept_context* c, lept_value* v)
{
        int ret;
        char* s;
        size_t len;
        if (LEPT_PARSE_OK == (ret = lept_parse_string_raw(c, &s, &len))){
               lept_set_string(v, s, len);
        }
        return ret;
}

了解上面的内容后，我们可以开始下面的内容，解析对象函数的编写。

注意，我们在解析数组的时候，是把当前元素以lept_value压入栈中，而在这里，我们则是以lept_member压入：

static int lept_parse_object(lept_context* c, lept_value* v)
{
        size_t size,i;
        int ret;
        lept_member m;
        EXPECT(c, '{');
        lept_parse_whitespace(c);
        if (*c->json == '}'){
               c->json++;
               v->type = LEPT_OBJECT;
               v->u.o.m = NULL;
               v->u.o.size = 0;
               return LEPT_PARSE_OK;
        }
        m.k = NULL;
        size = 0;
        for (;;){
               char* str;
               lept_init(&m.v);
               /*解析 键*/
               if (*c->json != '"') {  //不是字符串
                       ret = LEPT_PARSE_MISS_KEY;
                       break;
               }
               if ((ret = lept_parse_string_raw(c, &str, &m.klen)) != LEPT_PARSE_OK){  
						//解析字符串错误
                       break;
               }
               //否则解析字符串正确，将字符串保存在m.k里面
               memcpy(m.k = (char*)malloc(m.klen + 1), str, m.klen);
               m.k[m.klen] = '\0';
               
               //解析冒号
               lept_parse_whitespace(c);
               if (*c->json != ':') {  //不是冒号
                       ret = LEPT_PARSE_MISS_COLON;
                       break;
               }
               c->json++;
               lept_parse_whitespace(c);

               //解析 值， 值是任意的JSON值，把结果写进m.v里面
               if ((ret = lept_parse_value(c, &m.v)) != LEPT_PARSE_OK){  //解析错误
                       break;
               }                      
               //解析成功，把m里面的结果写入c里面
               memcpy(lept_context_push(c, sizeof(lept_member)), &m, sizeof(lept_member));
               size++;
               m.k = NULL;//如果之前缺乏冒号，或是这里解析值失败，在函数返回前我们要释放m.k。如果我们成功地解析整个成员，那么就要把 m.k 设为空指针，其意义是说明该键的字符串的拥有权已转移至栈，之后如遇到错误，我们不会重覆释放栈里成员的键和这个临时成员的键。

               //解析逗号
               lept_parse_whitespace(c);
               if (*c->json == ',') {
                       c->json++;
                       lept_parse_whitespace(c);
               }
               else if (*c->json == '}') {
                       //size_t s = sizeof(lept_member)* size;
                       c->json++;
                       v->type = LEPT_OBJECT;
                       v->u.o.size = size;
                       size *= sizeof(lept_member);
                       memcpy(v->u.o.m = (lept_member*)malloc(size), lept_context_pop(c, size), size);
                       return LEPT_PARSE_OK;
               }
               else {
                       ret = LEPT_PARSE_MISS_COMMA_OR_CURLY_BRACKET;
                       break;
               }
        }

        //for循环遇到错误时：释放临时key字符串及栈上的成员
        free(m.k);
        for (i = 0; i < size; i++){
               lept_member* m = (lept_member*)lept_context_pop(c, sizeof(lept_member));
               free(m->k);
               lept_free(&m->v);
        }
        v->type = LEPT_NULL;
        return ret;
}

//不要忘记修改lept_parse_value函数
static int lept_parse_value(lept_context* c, lept_value* v) {
                /*   ....*/
               case '{':  return lept_parse_object(c, v);
}
Emma-Zhang
关注
专栏目录
开源的cjson.c和cjson.h
04-22
cjson库由Dave Gamble开发，是一个开源项目，提供了一个简单的API，允许C程序员方便地解析JSON字符串并将其转换为C语言的数据结构，同时也支持将C数据结构转换回JSON格式的字符串。由于cjson库是用纯C编写的，因此...
javascript ES5中 foreach()遍历方法
weixin_44638167的博客
09-28 5971
forcach() array.forEach(function(currentValue, index, arr)) currentValue：数组当前项的值 index：数组当前项的索引 (可选) arr：数组对象本身 filter() 方法创建一个新的数组， 新数组中的元素是通过检查指定数组中符合条件的所有元素,主要用于筛选数组 注意它直接返回一个新数组 代码: <script> var arr=[50,86,12,10,0,38]; var newa
cJSON基本使用方法
weixin_37214729的博客
03-31 4996
1、构造json对象；2、向对象中添加元素；3、获取对象中元素；4、获取元素的值；5、json对象与数组互转；6、释放json对象空间； 从官网直接下载cJSON源文件，添加到工程中即可。 char jssd_def[256]; 1、构造json对象； cJSON* root = NULL; cJSON* item = NULL; item = cJSON_CreateObject(); root = cJSON_CreateObject(); 2、向对象中添加元素； 1、...
Lua CJSON 开源项目教程
最新发布
gitblog_01152的博客
08-15 556
Lua CJSON 开源项目教程 lua-cjson项目地址:https://gitcode.com/gh_mirrors/lua/lua-cjson 项目介绍 Lua CJSON 是一个为 Lua 语言提供快速 JSON 编码和解析功能的模块。它支持完整的 JSON 标准，包括对 UTF-8 编码的支持，并且能够处理 JSON 规范中的常见例外情况（如无穷大和 NaN）。该项目不依赖于其他库，...
cjson 对象是json数组型结构体_cJSON项目解析
weixin_32672675的博客
12-26 1464
cJSON项目解析首先简单了解一下JSON。它是一种轻量级的数据交换格式。以一定的格式存储数据。看一个简单的例子就明白了：{"name":"gao","age":21,"friends":["张三","李四"],"more":{"city":"湖北","country":"中国"}}[]表示数组，{}表...
cJSON的简单应用（json对象、数组）
热门推荐
nbhh2748的博客
08-25 1万+
cJSON 结构： typedef struct cJSON {          structcJSON *next,*prev;       /* next/prevallow you to walk array/object chains. Alternatively, useGetArraySize/GetArrayItem/GetObjectItem */          str
@requestbody 对象接收不到json_例说嵌入式实用知识之JSON数据
weixin_35443436的博客
12-21 864
前言JSON(JavaScript Object Notation)是一种轻量级的数据交换格式。JSON在互联网相关开发中用得很多，在我们嵌入式中用得也不少。最近在项目中就有用到，用起来很方便。简单的JSON格式数据如：{ "name": "xxx", "num": xxx, "c_score": xxx}这里我们需要知道一个概念：键值对。比如："name": "xxx"像这样子...
STM32F103C8T6 cJSON解析心知天气API网络数据 20200522.zip
05-28
cJSON是一个小型的开源库，专门为嵌入式系统设计，用于在C语言环境中解析和生成JSON数据。 在Keil uVision 5这个流行的嵌入式开发环境中，你可以创建一个新的STM32工程，并将cJSON库添加到项目中。你需要下载cJSON...
cJSON JSON解析库
03-21
cJSON是一个轻量级的开源JSON解析库，由Dave Gamble创建并维护。这个库的源代码简洁高效，大约只有2500行，使其成为嵌入式系统和资源有限环境的理想选择。cJSON库提供C语言接口，用于解析JSON（JavaScript Object ...
CJSON解析数据（VC++）
11-17
在IT行业中，JSON（JavaScript Object Notation）是一种广泛使用的轻量级数据交换格式，它易于人阅读和编写，同时也...在实际开发中，你可以根据项目的具体需求，结合cJSON的API灵活使用，实现对JSON数据的高效管理。
cJSON开源库代码（值得学习）
11-24
1. **解析JSON字符串**：使用`cJSON_Parse()`函数可以将一个JSON格式的字符串解析成一个cJSON对象，例如： ```c cJSON *json_obj = cJSON_Parse(json_string); ``` 2. **遍历JSON对象**：解析后的cJSON对象可以...
cJSON 使用笔记
weixin_33976072的博客
09-06 562
缘 起 ...
使用cjson解析json数据格式
weixin_39270987的博客
05-24 3124
一、Json数据格式 json是一种轻量级的数据传输格式，表示方法为：“名称”:“值”； json通常的格式有两种，对象和数组。 对象由花括号括起来的逗号分割的成员构成，对象的成员可以是字符串、数值、数组、对象； 对象中包含字符串、数值、对象： {"name": "张三", "age": 18, "address": {"country" : "china", "province": "广东"}} 数组是由方括号括起来的一组值构成，其内容也可以是字符串、数值、对象、数组。 数组元素是单纯的字符串：
cJSON开源项目详细解剖
林夕07
06-01 916
JSON JSON介绍 百度百科：JSON(JavaScript Object Notation, JS 对象简谱) 是一种轻量级的数据交换格式。它基于 ECMAScript (欧洲计算机协会制定的js规范)的一个子集，采用完全独立于编程语言的文本格式来存储和表示数据。简洁和清晰的层次结构使得 JSON 成为理想的数据交换语言。 易于人阅读和编写，同时也易于机器解析和生成，并有效地提升网络传输效率。 JSON语法 JSON是一个标记符的序列。这套标记符包含六个构造字符、字符串、数字和三个字面名。JSON是一
cjson构建_cJSON的构造和解析
weixin_39733821的博客
12-20 267
对于cJSON的使用，我主要是用来模拟远程服务器端返回的一个json类型的目录结构，客户端进行获取并进行解析，把解析出来的目录按照原本的结构显示在本地。cJSON是一个超轻巧，携带方便，单文件，简单的可以作为ANSI-C标准的JSON解析器。进入cJSON.h头文件中可以查看cJSON的相关信息。主要包括：cJSON结构体、cJSON类型、cJSON的一些内部的函数等。//cJSON结构体:typ...
【C语言之 CJson】学CJson看这一篇就够了
m0_62599305的博客
12-03 1万+
CJSON 是一个轻量级的、用于处理 JSON 数据的 C 语言库。它提供了简单而直观的 API，使得在 C 程序中处理 JSON 数据变得相对容易。在本文中，我们将介绍 CJSON 的基本使用，包括如何创建 JSON 对象、解析 JSON 字符串、访问 JSON 数据以及释放相关资源。CJSON 提供了一个简单而功能丰富的方式来处理 JSON 数据。通过创建 JSON 对象、数组，以及使用相应的函数来填充和访问数据，你可以在 C 语言中轻松地进行 JSON 操作。
小白的第一个C语言博客项目-cJSON使用详解
qq_36160429的博客
10-27 853
小白的第一个C语言博客项目-cJSON使用详解说明1.JSON数据格式及cJSON项目的简单介绍2. cJSON项目介绍2.1.字符串类型的数据转化为JSON数据格式功能快捷键合理的创建标题，有助于目录的生成如何改变文本的样式插入链接与图片如何插入一段漂亮的代码片生成一个适合你的列表创建一个表格设定内容居中、居左、居右SmartyPants创建一个自定义列表如何创建一个注脚注释也是必不可少的KaTeX数学公式新的甘特图功能，丰富你的文章UML 图表FLowchart流程图导出与导入导出导入 说明 本套教程包
c#读取json某一节点数据_一款轻量级的JSON解析库，用cJSON让你看清王者荣耀
weixin_39704066的博客
12-14 896
点击蓝字 关注我们前言王者荣耀出新英雄了，蔡文姬也迎来了属于她的澜朋友，那么本期带你揭秘王者全英雄全皮肤，一起来看看吧~正文JSON是一种轻量级的数据格式，应用广泛。在C/C++应用中也常常作为配置文件或者数据的存储JSON语法规则JSON对象是一个无序的"名称/值"键值对的集合：以"{“开始，以”}"结束，允许「嵌套使用」；每个「名称和值成对出现」，名称和值之间使用":"分隔；键值对...
cJson的使用，C语言解析Json字符串
m0_50075609的博客
12-21 1819
/* Copyright (c) 2009-2017 Dave Gamble and cJSON contributors 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 restr.
为cjson项目的json_parse函数生成一个模糊测试用例
03-31
以下是一个模糊测试用例： ```c #include <stdio.h> #include <stdlib.h> #include <string.h> #include <time.h> #include "cJSON.h" #define MAX_JSON_LENGTH 1000 int main() { srand(time(NULL)); char json[MAX_JSON_LENGTH]; int i, j; for (i = 0; i < 10; i++) { memset(json, 0, MAX_JSON_LENGTH); int num_objects = rand() % 10 + 1; strcat(json, "{"); for (j = 0; j < num_objects; j++) { // 随机生成键名 int key_length = rand() % 10 + 1; char key[key_length + 1]; int k; for (k = 0; k < key_length; k++) { key[k] = rand() % 26 + 'a'; } key[key_length] = '\0'; strcat(json, "\""); strcat(json, key); strcat(json, "\":"); // 随机生成值 int value_type = rand() % 5; switch (value_type) { case 0: // null strcat(json, "null"); break; case 1: // bool strcat(json, rand() % 2 == 0 ? "true" : "false"); break; case 2: // number strcat(json, "12345"); break; case 3: // string strcat(json, "\"hello world\""); break; case 4: // array strcat(json, "["); int num_items = rand() % 10 + 1; int l; for (l = 0; l < num_items; l++) { int item_type = rand() % 4; switch (item_type) { case 0: // null strcat(json, "null"); break; case 1: // bool strcat(json, rand() % 2 == 0 ? "true" : "false"); break; case 2: // number strcat(json, "12345"); break; case 3: // string strcat(json, "\"hello world\""); break; } if (l != num_items - 1) { strcat(json, ","); } } strcat(json, "]"); break; } if (j != num_objects - 1) { strcat(json, ","); } } strcat(json, "}"); printf("JSON string: %s\n", json); cJSON *root = cJSON_Parse(json); if (root == NULL) { printf("Error parsing JSON string: %s\n", cJSON_GetErrorPtr()); } else { printf("JSON object successfully parsed!\n"); cJSON_Delete(root); } } return 0; } ``` 该测试用例随机生成一个 JSON 字符串，并尝试将其解析为 cJSON 对象。具体而言，它随机生成一个对象，对象中包含随机数量的键值对，每个键值对的键名和值也是随机生成的。值的类型包括 null、bool、number、string 和 array，其中 array 的元素也是随机生成的。最终，它将生成的 JSON 字符串打印到控制台，并输出解析结果或错误信息。由于是随机生成的测试用例，因此可以测试 cjson 项目的 json_parse 函数对各种不同形式的 JSON 字符串的解析能力。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值