用cpp造了个简单的xml解析器

已于 2023-12-25 19:36:35 修改
阅读量146 收藏
点赞数 7
文章标签： xml c++ c语言 算法
于 2023-12-25 16:32:32 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Ranger_World/article/details/135202861
版权

功能很简陋, 下面两个无法解析。

<?xml version="1.0" encoding="UTF-8"?>

<xxx/>

能解析的格式类似于下面:

<UI_head>

    <Button>Button1</Button>

    <Button>Button2</Button>

    <Grid>

        <Button color ="white" x = "234" y = "456" isShow = "true">Grid.Button1</Button>

        <Button>Grid.Button2</Button>

        <!-- 这是一个按钮 -->

    </Grid>

</UI_head>

效果:

bab6335a35214a8f88ca2f05336410b4.png

源码:

Value.h

#pragma once
#include <string>
#include <sstream>
namespace lakes {
	class Value
	{
	public:
		Value() { }
		Value(const std::string& value);
		Value(const char * value);
		Value(double value);
		Value(int value);
		Value& operator=(double value);
		Value& operator=(int value);
		Value& operator=(bool value);
		Value& operator=(const std::string& value);
		bool operator ==(const Value& other);
		bool operator !=(const Value& other);
		Value(bool value);
		operator bool();
		operator int();
		operator double();
		operator const char*();
		operator std::string();
		std::string& str() {
			return _str_value;
		}
	private:
		std::string _str_value;
	};
}

Value.cpp

#include "Value.h"

lakes::Value::Value(const std::string& value) {
	_str_value = value;
}

lakes::Value::Value(const char* value) {
	_str_value = value;
}

lakes::Value::Value(double value) {
	std::stringstream buf;
	buf << value;
	_str_value = buf.str();
}

lakes::Value::Value(int value) {
	_str_value = value;
}

lakes::Value& lakes::Value::operator=(double value) {
	std::stringstream buf;
	buf << value;
	_str_value = buf.str();
	return *this;
}

lakes::Value& lakes::Value::operator=(int value) {
	_str_value = value;
	return *this;
}

lakes::Value& lakes::Value::operator=(bool value) {
	_str_value = value;
	return *this;
}

lakes::Value& lakes::Value::operator=(std::string& value) {
	_str_value = value;
	return *this;
}

 bool lakes::Value::operator==(const Value& other) {
	return other._str_value == _str_value;
}

 bool lakes::Value::operator!=(const Value& other) {
	return other._str_value != _str_value;
}

 lakes::Value::Value(bool value) {
	*this = value;
}

 lakes::Value::operator bool() {
	return _str_value == "true";
}

 lakes::Value::operator int() {
	return std::atoi(_str_value.c_str());
}

 lakes::Value::operator double() {
	return std::atof(_str_value.c_str());
}

 lakes::Value::operator const char* () {
	return _str_value.c_str();
}

 lakes::Value::operator std::string() {
	return _str_value;
}

Xml.h

#pragma once
#include <string>
#include <list>
#include <map>
#include <stack>
#include <algorithm>
#include <fstream>
#include <sstream>  
#include "Value.h"
namespace lakes {

    /**
     * <Parent1>
     *      <Node1 xx_property = "xxx"> xxx_str </Node1>
     *      <Node2 xx_property = "xxx"> xxx_str </Node2>
     *      <Node3> <Node>xxx</Node> </Node3>
     * </Parent1>
     * ...
    */
    class Xml {
        using itor = std::list<Xml>::iterator;
    public:
        Xml() { }
        Xml(const std::string& path) {
            load(path.c_str());
        }
        void load(const char* path);
        bool save(const std::string& path);
        void parse(const std::string& str);
        std::string name() const;
        void name(const std::string& str);
        std::string text() const;
        void text(const std::string& str);
        Value attr(const std::string& str_name) const;        
        void attr(const std::string& str_name, const std::string& str_attr);
        Value operator[](const std::string& str_attr);
        Xml& find(const std::string& str);
        Xml& append(const Xml& xml_node);
        std::list<Xml>& childs();
        std::string to_string();
        itor begin();
        itor end();
        void clear();

    private:
        std::string _name;
        std::string _text;
        std::map<std::string, Value> _attrs;
        std::list<Xml> _childs;

        char _get_not_space_char(const std::string& str, int& index);
        void _parse_text(Xml* node, const std::string& str, int& index);
        void _parse_attr(Xml& node, const std::string& str, int& index);
        Xml _parse_node(const std::string& str, int& index);
        void _end_node(std::stack<Xml*>& node_stack, const std::string& str, int& index);
    };
} // namespace lake

Xml.cpp

#include "Xml.h"

#define THROW_ERROR(...) do { \
    char str_err[256] { }; \
    sprintf_s(str_err, __VA_ARGS__); \
    throw std::logic_error(str_err); \
}while(0);


void lakes::Xml::load(const char* path) {
    std::ifstream file(path, std::ios_base::in);
    file.open(path);
    if (!file.is_open()) {
        THROW_ERROR("Open file error...");
    }
    std::stringstream str_stream;
    str_stream << file.rdbuf();
    parse(str_stream.str());
}


bool lakes::Xml::save(const std::string& path) {
    std::ofstream file(path, std::ios_base::out);
    file.open(path);
    if (!file.is_open()) {
        return false;
    }
    file << to_string();
    return true;
}

void lakes::Xml::parse(const std::string& str) {
    size_t text_len = str.length();
    if (text_len == 0) {
        THROW_ERROR("string is empty...");
    }
    std::stack<Xml*> node_stack;
    int index = 0;
    while (index < text_len - 1) {
        char ch = _get_not_space_char(str, index);
        if (ch == '<') {
            index++;
            if (str[index] == '/') {
                index++;
                _end_node(node_stack, str, index);
            }
            else if (!str.compare(index, 3, "!--")) { //skip <!-- xxx -->
                int ind = (int)str.find("-->", index);
                if (ind == std::string::npos) {
                    THROW_ERROR("error: %d could not match -->", index);    
                }
                index = ind + 3;
            }
            else {
                auto node = _parse_node(str, index);
                if (node_stack.empty()) {
                    *this = node;
                    node_stack.push(this);
                }
                else {
                    node_stack.top()->append(node);
                    node_stack.push(&node_stack.top()->childs().back());
                }
            }
        }
        else {
            _parse_text(node_stack.top(), str, index);
        }
    }
    if (!node_stack.empty()) {
        THROW_ERROR("error: root node couldn't match...");
    }
}

std::string lakes::Xml::name() const {
    return _name;
}

void lakes::Xml::name(const std::string& str) {
    _name = str;
}

std::string lakes::Xml::text() const {
    return _text;
}

void lakes::Xml::text(const std::string& str) {
    _text = str;
}

lakes::Value lakes::Xml::attr(const std::string& str_name) const {
    if (_attrs.count(str_name) == 0) {
        return "None";
    }
    return _attrs.at(str_name);
}

void lakes::Xml::attr(const std::string& str_name, const std::string& str_attr) {
    _attrs[str_name] = str_attr;
}

lakes::Xml& lakes::Xml::find(const std::string& str) {
    const auto& node = std::find_if(_childs.begin(), _childs.end(), [&str](Xml& xml_node) {
        return (xml_node.name() == str);
        });
    if (_childs.end() == node) {
        THROW_ERROR("Not Find...");
    }
    return *node;
}

lakes::Value lakes::Xml::operator[](const std::string& str_attr) {
    return attr(str_attr);
}

lakes::Xml& lakes::Xml::append(const Xml& xml_node) {
    _childs.emplace_back(xml_node);
    return *this;
}

std::list<lakes::Xml>& lakes::Xml::childs() {
    return _childs;
}

std::string lakes::Xml::to_string() {
    std::string xml_str;
    xml_str = "<" + _name;
    for (auto& value : _attrs) {
        xml_str += (" " + value.first + "=\"" + value.second.str() + "\"");
    }
    xml_str += ">" + _text;
    for (auto& value : _childs) {
        xml_str += value.to_string();
    }
    xml_str += "</" + _name + ">";
    return xml_str;
}

lakes::Xml::itor lakes::Xml::begin() {
    return _childs.begin();
}

lakes::Xml::itor lakes::Xml::end() {
    return _childs.end();
}

void lakes::Xml::clear() {
    _attrs.clear();
    _childs.clear();
}

char lakes::Xml::_get_not_space_char(const std::string& str, int& index) {
    while (index < str.length() && (str[index] == ' ' || str[index] == '\n')) {
        index++;
    }
    return str[index];
}

void lakes::Xml::_parse_text(Xml* node, const std::string& str, int& index) {
    while (index < str.length() && str[index] != '<' && str[index] != '\n') {
        node->_text += str[index++];
    }
}

void lakes::Xml::_parse_attr(Xml& node, const std::string& str, int& index) {
    std::string attr_name;
    std::string attr_val;
    int flag = 1;
    while (index < str.length()) {
        char ch = str[index];
        if (ch == '>') {
            index++;
            break;
        }
        else if ((ch == '=' || ch == ' ') && flag == 1) {
            flag = -1;
            if (ch == ' ') {
                ch = _get_not_space_char(str, index);
                if (ch != '=') {
                    THROW_ERROR("error : %d not \'=\'...", index);         
                }
            }
            index++;
            ch = _get_not_space_char(str, index);
            if (ch != '\"') {
                THROW_ERROR("error: %d not \" ...", index);
            }
        }
        else if (ch == '\"') {
            flag = 1;
            node.attr(attr_name, attr_val);
            attr_name.clear();
            attr_val.clear();
            while (index + 1 < str.length() && (str[++index] == ' ' || str[index] == '\n' || str[index] == '\r')) {}
            continue;
        }
        else if (ch != '\n' && ch != '\r') {
            if (flag == 1) {
                attr_name += ch;
            }
            else {
                attr_val += ch;
            }
        }
        index++;
    }
}

lakes::Xml lakes::Xml::_parse_node(const std::string& str, int& index) {
    char ch = _get_not_space_char(str, index);
    Xml xml_node;
    std::string str_temp;
    while (++index < str.length()) {
        if (ch == '>' || ch == ' ' || ch == '\n')
            break;
        xml_node._name += ch;
        ch = str[index];
    }
    if (ch != '>') {
        _parse_attr(xml_node, str, index);
    }
    return xml_node;
}

void lakes::Xml::_end_node(std::stack<Xml*>& node_stack, const std::string& str, int& index) {
    char ch;
    std::string temp_buf;
    while (index < str.length()) {
        ch = _get_not_space_char(str, index);
        index++;
        if (ch == '>')
            break;
        temp_buf += ch;
    }
    if (temp_buf == node_stack.top()->name()) {
        node_stack.pop();
    }
    else {
        THROW_ERROR("error: %d : %s != %s", index, node_stack.top()->name().c_str(), temp_buf.c_str()); 
    }
}
迷糊的lakes
关注
Android Audio基础——音频配置xml文件加载（七）
小旭的专栏
06-03 660
通过前面的文章，我们知道在 AudioPolicyManager 初始化的时候回调用 loadConfig() 方法去加载 Audio 相关的配置信息，这里我们就来详细看一下。
c语言函数参数个数不定,c语言重载(overriding in C)或函数不定参数个数
weixin_29467909的博客
05-18 429
google一下 c overiding发现有这样一段英文解释：Because C doesn't require that you pass all parameters to the function if you leave the parameter list blank in the prototype. The compiler should only throw up warning...
C++ XML的创建、读取和修改（一）
十方御道的博客
11-15 8881
跟C#不太一样，需要调用一个TinyXML库来生成XML，库的源码地址为https://github.com/leethomason/tinyxml2，找到“clone or down”进行下载，，解压之后，将tinyxml2.h和tinyxml2.cpp放入工程文件中，调用方式为 #include "tinyxml2.h" using namespace tinyxml2; 把源码沾一...
C++解析xml之完整代码（完整解析）
11-10
C++完整解析XML C++解析xml之完整代码（完整解析）
xml解析
gldcpp的博客
01-18 364
使用msxml4.dll 解析xml #import "E:\2015-12-24\xml\msxml4.dll"  //msxml4.dll路径 class InitializeCom { public: InitializeCom() { CoInitialize(NULL); // Initializes the COM library   } ~Init
Xml.cpp
liuyudong_的博客
06-20 244
#include "StdAfx.h"#include "xml.h"#include &lt;vector&gt;namespace JWXml{ CXml::CXml(void) : m_strFilePath(_T("")) , m_pDoc(NULL) , m_emVersion(MSXML_UNKNOWN) { } CXml::~CXml(void) { Close(); } //--...
CPP读写XML
sweetwxh的专栏
01-26 2255
在CPP中读写XML比在JAVA中来的麻烦，就光是一个字符串的处理就比JAVA麻烦许多。JAVA比较统一，一个String就搞定所有字符串。但是CPP中，什么std::string,CString，char*，就没有一个统一一点的字符串类型。在JAVA中读写XML可以采用的类库很多，比如DOM4J（目前比较常用的）。而在CPP中，可以采用目前比较流行的两个，TinyXML和MSXML。1.Tiny
c/c++ xml解析器
cay22的专栏
12-20 1241
c/c++ xml解析器
C语言编译优化可执行文件大小,Unity3D 降低IL2CPP编译可执行文件大小
weixin_39895096的博客
05-18 642
项目开始使用IL2CPP编译，后果是可执行文件急剧增加。懒得愿意看原帖的直接看我的方法吧1、新建一个Mono工程，命名成UnusedByteCodeStripper2，贴如下面代码，编译出UnusedByteCodeStripper2.exeusing System;using System.Collections;using System.Collections.Generic;using S...
基于 STM32 的简单气象站，用于在 Nucleo F103 上进行测试
最新发布
06-26
在本项目中，我们将讨论如何利用 STM32 的 Nucleo F103 开发板来构建一个简单的气象站。 Nucleo F103 开发板是一个低成本、易于使用的平台，适用于开发基于 STM32 的项目。F103 系列属于 STM32 的“Value Line”...
XMLCPP Library-开源
04-15
XMLCPP库提供C ++中XmlPull API v1的实现。 它可以处理`libiconv'支持的任何编码。 解析结果以std :: wstring的形式提供。 因此它可以处理所有unicode字符集。
XML头文件与cpp函数
01-26
此为XML文件读写的函数头文件与cpp文件，在项目中添加进来即可。
python设计一个circle类_分别设计点类Point和圆类Circle,点类有两个私有数据纵坐标和横坐标;圆类有也两个私有数据圆心和半径,其中圆心是一个点类对象;要求如下所述: (1) 通过构造...
weixin_39992788的博客
11-30 2213
题目相对简单: package naizi; public class Circle { //私有成员及构造方法 private Point center; private int r; Circle(int rr,Point Cc){ this.r=rr; this.center=Cc; } public void showInfo(){ //打印信息 System.out.println("c...
C++那些事之优雅的解析XML
Francis的博客
05-23 2108
最近在鹅厂实习中，使用开源的C++ XML解析器-TinyXML-2，今天主要分享该开源项目的基本情况及使用。1.TinyXML介绍TinyXML是一个比较优秀的c++ xml解析器，有...
推荐一款高效Cpp解析xml工具－－RapidXml
糙级码lee的专栏
12-01 4414
解析效率比Xerces DOM 快50-100倍，tinyxml快30-60 ，作者自己牛逼哄哄的说这是他所知道的最快的xml解析库了~~ 作者介绍说：" The table below compares speed of RapidXml to some other parsers, and to strlen() function executed on the same data. On
［大师C语言(第三十七篇)］C语言操作XML：深入解析与实战
极客代码
06-25 1630
C语言提供了多种库来操作XML数据，常用的有libxml2、Expat和Mini-XML等。这些库各有特点，适用于不同的场景。下面将分别介绍这些库的优缺点和适用场景。在本文的最后一部分，我们将比较这三种XML处理库（libxml2、Expat和Mini-XML），并总结它们的适用场景。选择合适的XML处理库取决于项目的具体需求。如果需要全面的XML处理功能，libxml2是一个不错的选择。如果项目只需要解析XML，并且关注性能和资源使用，Expat可能是更好的选择。
VC解析XML--使用CMarkup类解析XML
01-27 649
VC解析XML--使用CMarkup类解析XML(一) 先讲一下XML中的物殊字符，手动填写时注意一下。字符                   字符实体&                       &或&#38;                       &apos;或'>                       >或>"         
C++解析XML
HLW0522的博客
08-30 965
下载地址 http://sourceforge.net/projects/tinyxml/ 官网有详细的文档以及API介绍 感觉像javaXML解析文件一样好用 读取和设置xml配置文件是最常用的操作，试用了几个C++的XML解析器，个人感觉TinyXML是使用起来最舒服的，因为它的API接口和Java的十分类似，面向对象性很好。 TinyXML是一个开源的解析XML的解析库，能够用于
C++ XML文件读写及简单封装
热门推荐
qq_45482587的博客
12-05 1万+
C++ xml文件的读写以及简单封装
TinyXML2.6.2 C++ XML解析器文档
"TinyXML参考文档" ...TinyXML是一个轻量级的XML解析解决方案，对于需要简单XML处理的C++项目来说，它是一个很好的选择。不过，对于需要高级特性和严格验证的场景，可能需要考虑其他更强大的XML解析库。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值