Sylar_网络框架学习——日志模块（一）

已于 2022-12-08 13:49:57 修改
阅读量691 收藏 8
点赞数 3
分类专栏： C++ 网络框架 文章标签： 网络 学习 c++
于 2022-10-27 10:56:04 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/jiaoooooo/article/details/127548015
版权

网络框架

1-8课

日志模块

1）Logger

面向用户最上层的类：提供log接口供用户使用

可以设置输出地appender、日志级别、以及默认解析格式

//日志器
//继承enable_shared_from_this才可以使用shared_from_this()获取自身指针
class Logger : public std::enable_shared_from_this<Logger> {
public:
    using ptr = std::shared_ptr<Logger>;
    //typedef std::shared_ptr<Logger> ptr;
    Logger(const std::string& name = "root");
    void log(LogLevel::Level level, LogEvent::ptr event);
    void debug(LogEvent::ptr event);
    void info(LogEvent::ptr event);
    void warn(LogEvent::ptr event);
    void error(LogEvent::ptr event);
    void fatal(LogEvent::ptr event);
    void addAppender(LogAppender::ptr appender);
    void delAppender(LogAppender::ptr appender);
    LogLevel::Level getLevel() const {return m_level;}
    void setLevel(LogLevel::Level level) {m_level = level;}
    const std::string& getName() const {return m_name;}
private:
    std::string m_name;                             //日志名称
    LogLevel::Level m_level;                        //只有满足这个日志级别的才被输出
    std::list<LogAppender::ptr> m_appenders;        //Appender集合  存储了父类指针
    LogFormatter::ptr m_formatter;                  //设置一个默认的解析格式
};

2）LogAppender

日志输出的基类，其派生类实现log函数

Logger类的log函数使用父类指针调用其派生类的log函数完成输出

可以设置LogFormatter作为解析规则

//日志输出地
class LogAppender{
public:
    using ptr = std::shared_ptr<LogAppender>;
    //typedef std::shared_ptr<LogAppender> ptr;
    virtual ~LogAppender(){}
    virtual void log(std::shared_ptr<Logger> logger, LogLevel::Level level, LogEvent::ptr event) = 0;       //纯虚函数，交由子类实现
    void setFormatter(LogFormatter::ptr val) {m_formatter = val;}
    LogFormatter::ptr getFormatter() const {return m_formatter;}
    LogLevel::Level getLevel() const {return m_level;}
    void setLevel(LogLevel::Level lev) {m_level = lev;}
protected:
    LogLevel::Level m_level = LogLevel::DEBUG;
    LogFormatter::ptr m_formatter;
};
1.StdoutLogAppender

输出到控制台的Appender

实现基类log方法

//输出到控制台的Appender
class StdoutLogAppender : public LogAppender {
public:
    using ptr = std::shared_ptr<StdoutLogAppender>;
    //typedef std::shared_ptr<StdoutLogAppender> ptr;
    virtual void log(Logger::ptr logger, LogLevel::Level level, LogEvent::ptr event) override;  //在此实现
private:
};
2.FileLogAppender

输出到文件的Appender

实现基类log方法

//输出到文件的Appender
class FileLogAppender : public LogAppender {
public:
    using ptr = std::shared_ptr<FileLogAppender>;
    //typedef std::shared_ptr<FileLogAppender> ptr;
    FileLogAppender(const std::string& filename);
    virtual void log(Logger::ptr logger, LogLevel::Level level, LogEvent::ptr event) override;  //在此实现
    //重新打开文件，文件打开成功返回true
    bool reopen();
private:
    std::string m_filename;
    std::ofstream m_filestream;
};

3）LogFormatter

解析格式化输出规则的类

初始化时接受一个解析规则，也可以用默认的（在logger类构造函数设置默认解析规则）

内嵌FormatItem类，解析规则的基类，不同命令继承自该类，并实现format函数，传出ostream流对象

在构造函数里调用init函数，按顺序将不同命令对应的派生类存储到m_items中，然后format调用FormatItem::format函数得到流对象

//日志格式化器
class LogFormatter{
public:
    using ptr = std::shared_ptr<LogFormatter>;
    //typedef std::shared_ptr<LogFormatter> ptr;
    LogFormatter(const std::string& pattern);
    std::string format(std::shared_ptr<Logger> logger, LogEvent::ptr event);
public:
    class FormatItem{
    public:
        using ptr = std::shared_ptr<FormatItem>;
        //typedef std::shared_ptr<FormatItem> ptr;
        //FormatItem(const std::string& fmt = "") {}
        virtual ~FormatItem() {}
        virtual void format(std::ostream& os, std::shared_ptr<Logger> logger, LogEvent::ptr event) = 0;
    };
    void init();                                    //pattern的解析
private:
    std::string m_pattern;                          //根据pattern解析信息
    std::vector<FormatItem::ptr> m_items;

};
其余命令派生类
//获取错误信息类：实现父类FormatItem的format方法
class MessageFormatItem : public LogFormatter::FormatItem{
public:
    MessageFormatItem(const std::string str="") {}
    void format(std::ostream& os, std::shared_ptr<Logger> logger, LogEvent::ptr event) override {
        os << event->getContext();
    }
};

//获取日志级别类：调用LogLevel类的静态方法将枚举转换为string
class LevelFormatItem : public LogFormatter::FormatItem{
public:
    LevelFormatItem(const std::string str="") {}
    void format(std::ostream& os, std::shared_ptr<Logger> logger, LogEvent::ptr event) override {
        os << LogLevel::ToString(event->getLevel());
    }
};

//获取开始时间
class ElapseFormatItem : public LogFormatter::FormatItem{
public:
    ElapseFormatItem(const std::string str="") {}
    void format(std::ostream& os, std::shared_ptr<Logger> logger, LogEvent::ptr event) override {
        os << event->getElapse();
    }
};

//获取日志器名称
class NameFormatItem : public LogFormatter::FormatItem{
public:
    NameFormatItem(const std::string str="") {}
    void format(std::ostream& os, std::shared_ptr<Logger> logger, LogEvent::ptr event) override {
        os << logger->getName();
    }
};

//获取线程id
class ThreadIdFormatItem : public LogFormatter::FormatItem{
public:
    ThreadIdFormatItem(const std::string str="") {}
    void format(std::ostream& os, std::shared_ptr<Logger> logger, LogEvent::ptr event) override {
        os << event->getThreadId();
    }
};

//协程id
class FiberIdFormatItem : public LogFormatter::FormatItem{
public:
    FiberIdFormatItem(const std::string str="") {}
    void format(std::ostream& os, std::shared_ptr<Logger> logger, LogEvent::ptr event) override {
        os << event->getFiberId();
    }
};

//日期类
class DateTimeFormatItem : public LogFormatter::FormatItem{
public:
    DateTimeFormatItem(const std::string format = "%Y-%m-%d %H:%M:%S")
        :m_format(format){
        if(m_format.empty()){
            m_format = "%Y-%m-%d %H:%M:%S";
        }
    }
    void format(std::ostream& os, std::shared_ptr<Logger> logger, LogEvent::ptr event) override {
        struct tm tm;
        time_t time = event->getTime();
        localtime_r(&time, &tm);
        char buf[64];
        strftime(buf, sizeof(buf), m_format.c_str(), &tm);
        os << buf;
    }
private:
    std::string m_format;
};

//日志名称类
class FilenameFormatItem : public LogFormatter::FormatItem{
public:
    FilenameFormatItem(const std::string str="") {}
    void format(std::ostream& os, std::shared_ptr<Logger> logger, LogEvent::ptr event) override {
        os << event->getFile();
    }
};

//行号类
class LineFormatItem : public LogFormatter::FormatItem{
public:
    LineFormatItem(const std::string str="") {}
    void format(std::ostream& os, std::shared_ptr<Logger> logger, LogEvent::ptr event) override {
        os << event->getLine();
    }
};

//换行
class NewLineFormatItem : public LogFormatter::FormatItem{
public:
    NewLineFormatItem(const std::string str="") {}
    void format(std::ostream& os, std::shared_ptr<Logger> logger, LogEvent::ptr event) override {
        os << std::endl;
    }
};

//输出字符串类
class StringFormatItem : public LogFormatter::FormatItem{
public:
    StringFormatItem(const std::string& str)
        :m_string(str){}
    void format(std::ostream& os, std::shared_ptr<Logger> logger, LogEvent::ptr event) override {
        os << m_string;
    }
private:
    std::string m_string;
};

//输出Tab
class TabFormatItem : public LogFormatter::FormatItem{
public:
    TabFormatItem(const std::string str="") {}
    void format(std::ostream& os, std::shared_ptr<Logger> logger, LogEvent::ptr event) override {
        os << "\t";
    }
};

4）LogEvent

事件类：保存事件的各项信息

//日志事件
class LogEvent{
public:
    using ptr = std::shared_ptr<LogEvent>;
    //typedef std::shared_ptr<LogEvent> ptr;
    LogEvent(std::shared_ptr<Logger> logger, const char* file, int32_t m_line, uint32_t elapse,
            uint32_t thread_id, uint32_t fiber_id, uint64_t time, 
            LogLevel::Level lev = LogLevel::DEBUG);
    const char* getFile() const {return m_file;}
    const int32_t getLine() const {return m_line;}
    const uint32_t getElapse() const {return m_elapse;}
    const uint32_t getThreadId() const {return m_threadId;}
    const uint32_t getFiberId() const {return m_fiberId;}
    const uint64_t getTime() const {return m_time;}
    std::string getContext() const {return m_ss.str();}
    std::stringstream& getSS() {return m_ss;}
    const LogLevel::Level getLevel() const {return m_level;}
    void setLevel(LogLevel::Level lev)  {m_level = lev;}
    std::shared_ptr<Logger> getLogger() {return m_logger;}
    //format方法
    void format(const char* fmt, ...);
    void format(const char* fmt, va_list al);
private:
    std::shared_ptr<Logger> m_logger;                   //该事件属于哪个日志器
    const char* m_file = nullptr;                       //文件名
    int32_t m_line = 0;                                 //行号
    uint32_t m_elapse = 0;                              //程序启动到开始的时间
    uint32_t m_threadId = 0;                            //线程号
    uint32_t m_fiberId = 0;                             //协程号
    uint64_t m_time = 0;                                //时间
    std::stringstream m_ss;                             //字符串输出流
    LogLevel::Level m_level = LogLevel::DEBUG;          //日志级别
};

5）日志级别类

表示日志级别，枚举类

//日志级别类
class LogLevel{
public:
    enum Level {
        UNKNOW = 0,
        DEBUG = 1,
        INFO = 2,
        WARN = 3,
        ERROR = 4,
        FATAL = 5
    };
    static const char* ToString(LogLevel::Level level);
};

6）宏

1.流式

搭配LogEventWrap类使用，该类中包含LogEvent类智能指针作为成员，在析构时调用LogEvent类的log函数完成日志写入

LogEvent类可能被多次引用，析构函数只在引用计数为零时调用，现在需要引用计数减一时就写入，因此将事件包装在LogEventWrap类中

//为了在event析构时，触发日志写入，搭配宏
class LogEventWrap{
public:
    LogEventWrap(LogEvent::ptr e);
    ~LogEventWrap();
    std::stringstream& getSS();
    LogEvent::ptr getEvent() {return m_event;}
private:
    LogEvent::ptr m_event;
};

#define SYLAR_LOG_LEVEL(logger, level)  \
    if(logger->getLevel() <= level) \
        sylar::LogEventWrap(sylar::LogEvent::ptr(   \
                        new sylar::LogEvent(logger, __FILE__, __LINE__, 0,  \
                        sylar::GetThreadId(), sylar::GetFiberId(), time(0), level)  \
                    )   \
                ).getSS()


#define SYLAR_LOG_DEBUG(logger) SYLAR_LOG_LEVEL(logger, sylar::LogLevel::DEBUG)
#define SYLAR_LOG_INFO(logger) SYLAR_LOG_LEVEL(logger, sylar::LogLevel::INFO)
#define SYLAR_LOG_WARN(logger) SYLAR_LOG_LEVEL(logger, sylar::LogLevel::WARN)
#define SYLAR_LOG_ERROR(logger) SYLAR_LOG_LEVEL(logger, sylar::LogLevel::ERROR)
#define SYLAR_LOG_FATAL(logger) SYLAR_LOG_LEVEL(logger, sylar::LogLevel::FATAL)
2. 格式化输出

可变参数：C++可变参数详解 - 知乎 (zhihu.com)

__ VA_ARGS __ 表示可变参数列表

#define SYLAR_LOG_FMT_LEVEL(logger, level, fmt, ...)    \
    if(logger->getLevel() <= level) \
        sylar::LogEventWrap(sylar::LogEvent::ptr(   \
                        new sylar::LogEvent(logger, __FILE__, __LINE__, 0,  \
                        sylar::GetThreadId(), sylar::GetFiberId(), time(0), level)  \
                    )   \
                ).getEvent()->format(fmt, __VA_ARGS__)

#define SYLAR_LOG_FMT_DEBUG(logger, fmt, ...) SYLAR_LOG_FMT_LEVEL(logger, sylar::LogLevel::DEBUG, fmt, __VA_ARGS__)
#define SYLAR_LOG_FMT_INFO(logger, fmt, ...) SYLAR_LOG_FMT_LEVEL(logger, sylar::LogLevel::INFO, fmt, __VA_ARGS__)
#define SYLAR_LOG_FMT_WARN(logger, fmt, ...) SYLAR_LOG_FMT_LEVEL(logger, sylar::LogLevel::WARN, fmt, __VA_ARGS__)
#define SYLAR_LOG_FMT_ERROR(logger, fmt, ...) SYLAR_LOG_FMT_LEVEL(logger, sylar::LogLevel::ERROR, fmt, __VA_ARGS__)
#define SYLAR_LOG_FMT_FATAL(logger, fmt, ...) SYLAR_LOG_FMT_LEVEL(logger, sylar::LogLevel::FATAL, fmt, __VA_ARGS__)

7）其他

1.LoggerManger

创建一个logger管理类，包含一个名字对应logger智能指针的map集合，以及一个初始logger指针

//logger管理器
class LoggerManger {
public:
    LoggerManger();
    Logger::ptr getLogger(const std::string& name);

    void init();
private:
    std::map<std::string, Logger::ptr> m_loggers;
    Logger::ptr m_root;
};
//使用单例模板声明一个单例的管理器
typedef sylar::Singleton<LoggerManger> loggerMgr;	//懒汉模式
2.单例模板
#ifndef __SYLAR_SINGLETON_H__
#define __SYLAR_SINGLETON_H__
#include<memory>
namespace sylar{
template<typename T, typename X = void, int N = 0>
class Singleton{
public:
    static T* GetInstance() {
        static T v;
        return &v;
    }
};
template<typename T, typename X = void, int N = 0>
class SingletonPtr{
public:
    static std::shared_ptr<T> GetInstance() {
        static std::shared_ptr<T> v(new T);
        return v;
    }
};
}
#endif

8）调用流程

#include"../sylar/log.h"
#include"../sylar/util.h"

int main(){
    ......
    //从logger管理器中查找一个名为xx的logger，如果没有就使用默认logger
    auto l = sylar::loggerMgr::GetInstance()->getLogger("xx");
    //调用宏完成日志输出
    SYLAR_LOG_INFO(l) << "xxxxx";
	//结果：
    //2022-10-27 10:08:26     21020   0       [INFO]  [root]  /home/ubuntu/StudyCpp/sylar/tests/test.cpp:25   xxxxx
    return 0;
}
SYLAR_LOG_INFO(l) << "xxxxx";    --->   #define SYLAR_LOG_INFO(logger) SYLAR_LOG_LEVEL(logger, sylar::LogLevel::INFO)
#define SYLAR_LOG_LEVEL(logger, level)  \
    if(logger->getLevel() <= level) \
        sylar::LogEventWrap(sylar::LogEvent::ptr(   \
                        new sylar::LogEvent(logger, __FILE__, __LINE__, 0,  \
                        sylar::GetThreadId(), sylar::GetFiberId(), time(0), level)  \
                    )   \
                ).getSS()
其中LogEventWrap析构时调用    --->    m_event->getLogger()->log(m_event->getLevel(), m_event);
在Logger类中的log为：
void Logger::log(LogLevel::Level level, LogEvent::ptr event){
    if(level >= m_level){
        event->setLevel(level);
        auto self = shared_from_this();
        for(auto& x:m_appenders){
            x->log(self, level, event);           //取出每个appender，父类指针调用子类函数
        }
    }
}
x->log(self, level, event); 调用 Appender子类中的log方法    --->    virtual void log(Logger::ptr logger, LogLevel::Level level, LogEvent::ptr event) override; 实现父类log虚函数
子类Appender的log方法调用Formatter的format方法
void StdoutLogAppender::log(Logger::ptr logger, LogLevel::Level level, LogEvent::ptr event){
    if(level >= m_level){
        std::cout<<m_formatter->format(logger, event);
    }
}
Formatter类中std::string format(std::shared_ptr<Logger> logger, LogEvent::ptr event);方法遍历存储FormatItem的子类解析不同命令，存入流对象

virtual void format(std::ostream& os, std::shared_ptr<Logger> logger, LogEvent::ptr event) = 0;//交由子类实现

logger->log —> appender->log —> fotmatter->format —> formatitem->format

​ void <— 输出 <— string <— ostring

全部实现可见（包含可执行文件）仓库

jiaoooooo
关注
  • 3
    点赞
  • 踩
  • 8
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
sylar服务器框架分析——日志系统
JMasker的博客
11-10 1294
sylar服务器框架中对于日志系统的重点难点分析
sylar日志模块
weixin_43272661的博客
03-13 251
sylar日志模块详解
【sylar】框架篇-Chapter2-日志模块
江湖人称菠萝包
07-24 673
【sylar】框架篇-Chapter2-日志模块。
Sylar服务器框架 日志模块 源码分析
qq_53111905的博客
02-17 1257
Sylar服务器框架 日志模块 源码分析 文章目录日志库模块整体设计关键的类日志库整体流程和重要函数说明（最终是由LogAppender的LogFormatter负责相应调用完成最终日志输出）重要代码逐行分析LogFormatter::init —— 格式解析函数(100行左右)大致流程 日志库模块整体设计 用于格式化输出程序日志，方便从日志中定位程序运行过程中出现的问题。这里的日志除了日志内容本身之外，还应该包括文件名/行号，时间戳，线程/协程号，模块名称，日志级别等额外信息，甚至在打印致命的日志时，
【sylar服务器框架】完善日志系统
Salted的博客
06-20 424
添加LogEventWrap类 class LogEventWrap { public : LogEventWrap(LogEvent::ptr e); //传入一个LogEvent给m_event赋值 ~LogEventWrap(); std::stringstream& getSS(); //返回logevnet的getSS private: LogEvent::ptr m_event; } 修改LogEvent： 添加m_logger、m_level字段，以及相应的get方法。并在
Sylar:学习开发Sylar服务器框架
03-29
西拉
sylar：C ++大规模分布式服务器框架，Web服务器，WebSocket服务器，自定义tcp_server（包含日志模块，配置模块，线程模块，协程模块，协程调度模块，io协程调度模块，hook模块，socket模块， bytearray序列化，http模块，TcpServer模块，Websocket模块，Https模块等，Smtp邮件模块，MySQL，SQLite3，ORM，Redis，Zookeeper）
01-30
sylar：C ++大规模分布式服务器框架，Web服务器，WebSocket服务器，自定义tcp_server（包含日志模块，配置模块，线程模块，协程模块，协程调度模块，io协程调度模块，hook模块，socket模块， bytearray序列化，http...
The_Sylar_Project:一个心理健康资料库，可轻松找到当地的心理健康资源。 目前，工作正在进行中！
05-28
Sylar项目 生产环节 :backhand_index_pointing_right: 先决条件 您将需要在系统上安装 11.0或更高版本。 设置 对该存储库进行分叉，并确保您的代码是最新的，而develop分支不是main。 主要是生产中的东西，但是您将...
sylar
10-24
sylar
C++聊天室服务器，基于sylar框架开发，使用http服务器做资源服务，
最新发布
06-03
C++是一种广泛使用的编程语言，它是由Bjarne Stroustrup于1979年在新泽西州美利山贝尔实验室开始设计开发的。C++是C语言的扩展，旨在提供更强大的编程能力，包括面向对象编程和泛型编程的支持。C++支持数据...
C++高性能服务器（sylar）日志系统
qq_48185092的博客
10-23 472
最近学完了C++的基础部分，找了个服务器的项目，跟着sylar大佬搭建服务器，这个项目有点难，单是一个日志系统，视频总共才4个小时，我花了一周多的时间才完成，不过在这一周里学到的东西确实很多，一方面是将前面学的基础知识应用到项目中，这段过程个人感觉很重要，这就像是学英语，虽然单词全背会了，但真正在阅读理解中遇到的时候，还是记不到单词的意思。另一方面，跟着大佬敲代码，也渐渐养成了一种良好的编码习惯，以及学到了很多没学过的知识。
sylar库学习-日志系统
m0_55292629的博客
06-13 1616
c++项目学习笔记
从零开始实现一个C++高性能服务器框架----日志模块
qq_44778436的博客
04-04 2232
实现了一个基于协程的服务器框架，支持多线程、多协程协同调度；支持以异步处理的方式提高服务器性能；封装了网络相关的模块，包括socket、http、servlet等，支持快速搭建HTTP服务器或WebSokcet服务
[源码阅读]——Sylar服务器框架：日志模块
weixin_46267443的博客
11-19 2477
日志模块日志模块概述日志模块工作流程1、通过调用方法进行日志输出：2.宏定义输出日志其他未解决的地方 日志模块概述   通过初始格式化或自定义格式化输出程序日志，可选择标准输出和输出到文件夹。其日志内容主要包括： class LogEvent{ private: // 文件名 const char* m_file = nullptr; // 行号 int32_t m_line = 0; // 程序启动开始到现在的毫秒数 uint32_t m_elapse =
Sylar_网络框架学习——协程调度模块（五）
jiaoooooo的博客
12-27 317
Scheduler为管理协程模块，use_caller表示是否复用当前线程。如果复用需要将Scheduler::run()放入协程执行。
【sylar服务器框架】日志模块初版工作流程
Salted的博客
06-16 590
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-Gkp3sfwS-1623728213228)(C:\Users\huyaorui\Documents\C++服务器.assets\image-20210601183954609.png)] [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-4E0lsy8T-1623728213230)(C:\Users\huyaorui\Documents\C++服务器.assets\image-2021060118
记一个测试sylar服务器日志模块时遇到的一个非常奇怪的问题
m0_51551385的博客
06-03 142
变量要记得初始化，否则会产生奇奇怪怪的现象。
简单的日志系统搭建
记录个人学习、笔记
08-06 514
使用 C++ 实现一个简单的日志系统，部分参考 sylar
sylar学习(p1-p2)
qq_45179361的博客
06-20 165
C++高级教程]从零开始开发服务器框架(sylar)p1-p2。
C++ cJSON_Parse用法
01-23
cJSON_Parse是C语言中cJSON库的一个函数，用于将一个JSON格式的字符串解析为一个cJSON对象。该函数的用法如下： ```c cJSON *cJSON_Parse(const char *value); ``` 其中，value参数是一个完整的JSON格式的字符串。如果解析成功，cJSON_Parse函数将返回一个cJSON对象的指针；如果解析失败，cJSON_Parse函数将返回NULL。 以下是一个使用cJSON_Parse函数的示例： ```c #include <stdio.h> #include "cJSON.h" int main() { const char *jsonStr = "{\"name\":\"John\",\"age\":30,\"city\":\"New York\"}"; cJSON *jsonObj = cJSON_Parse(jsonStr); if (jsonObj != NULL) { cJSON *nameObj = cJSON_GetObjectItem(jsonObj, "name"); cJSON *ageObj = cJSON_GetObjectItem(jsonObj, "age"); cJSON *cityObj = cJSON_GetObjectItem(jsonObj, "city"); if (nameObj != NULL && ageObj != NULL && cityObj != NULL) { printf("Name: %s\n", nameObj->valuestring); printf("Age: %d\n", ageObj->valueint); printf("City: %s\n", cityObj->valuestring); } cJSON_Delete(jsonObj); } return 0; } ``` 在上述示例中，我们首先定义了一个JSON格式的字符串jsonStr。然后，我们使用cJSON_Parse函数将该字符串解析为一个cJSON对象jsonObj。接下来，我们使用cJSON_GetObjectItem函数从jsonObj中获取各个字段的值，并打印出来。最后，我们使用cJSON_Delete函数释放jsonObj的内存。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

jiaoooooo

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值