C++ XML文件和解析

XML（可扩展标记语言）是一种用于存储和传输数据的标记语言。它具有自描述性和平台无关性的特点。XML 文档的格式主要由一组嵌套的元素和属性构成，结构清晰，易于理解和解析。

XML 文档的基本格式

一个 XML 文档通常包括以下部分：

XML 声明：标识文档和版本信息。
根元素：整个 XML 文档只能有一个根元素，所有其他元素必须嵌套在根元素内。
元素：具有开始标签和结束标签，可以嵌套其他元素。
属性：为元素提供额外的信息。
文本内容：元素可以包含文本内容。
注释：用于注释文档内容。

具体示例

以下是一个简单的 XML 文档示例，展示了上述基本部分：

<?xml version="1.0" encoding="UTF-8"?>
<!-- 这是一个示例 XML 文档 -->
<bookstore><book category="cooking"><title lang="en">Everyday Italian</title><author>Giada De Laurentiis</author><year>2005</year><price>30.00</price></book><book category="children"><title lang="en">Harry Potter</title><author>J K. Rowling</author><year>2005</year><price>29.99</price></book><book category="web"><title lang="en">Learning XML</title><author>Erik T. Ray</author><year>2003</year><price>39.95</price></book>
</bookstore>

XML 文档的详细部分

XML 声明：

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

这是文档的声明部分，指定了 XML 版本和编码方式。

注释：

<!-- 这是一个示例 XML 文档 -->

注释可以放在 XML 文档中的任何位置，不会被解析器处理。

根元素：

<bookstore><!-- 所有内容都必须在根元素内部 -->
</bookstore>

bookstore 是根元素，所有其他元素都嵌套在其中。

元素：

<book category="cooking"><title lang="en">Everyday Italian</title><author>Giada De Laurentiis</author><year>2005</year><price>30.00</price>
</book>

book 是一个元素，其中包含了多个子元素和一个属性 category。

属性：

<book category="cooking"><title lang="en">Everyday Italian</title><!-- 其他子元素 -->
</book>

category 和 lang 是属性，为元素提供额外的信息。

文本内容：

<title lang="en">Everyday Italian</title>

title 元素包含了文本内容 Everyday Italian。

常见的 XML 结构

嵌套元素：

<family><parent name="John"><child name="Doe" age="10"/><child name="Jane" age="8"/></parent>
</family>

元素可以嵌套其他元素，形成层级结构。

属性和子元素结合：

<employee id="1001"><name>John Doe</name><department>HR</department><salary>5000</salary>
</employee>

元素可以同时包含属性和子元素。

自闭合元素：

<img src="image.jpg" alt="Sample Image"/>

自闭合元素是一种简洁的表示方式，不包含子元素。

XML 文档的规则

良好格式：XML 文档必须是良好格式的，即每个元素都必须正确关闭，元素必须正确嵌套，属性值必须用引号括起来。
区分大小写：XML 标签是区分大小写的。
根元素：每个 XML 文档必须有且只有一个根元素。
特殊字符：某些字符（如 <, >, & 等）在 XML 中有特殊含义，需要使用转义序列（如 <, >, &）表示。

XML文档解析

XML 文件解析通常有两种主要方式：DOM（Document Object Model）解析和 SAX（Simple API for XML）解析。这两种方法各有优缺点，适用于不同的应用场景。

DOM 解析

DOM 解析将整个 XML 文档读入内存中，并将其表示为一个树结构。每个节点在树中对应 XML 文档中的一个元素。用户可以通过 DOM API 访问和操作树中的节点。

优点

易于使用：通过树结构可以方便地访问和操作 XML 文档中的任意节点。
丰富的功能：支持随机访问和复杂的查询操作。
标准化：DOM 是 W3C 标准，广泛支持和文档丰富。

缺点

内存消耗大：需要将整个 XML 文档加载到内存中，对于大文件可能会导致高内存占用。
性能较低：解析和构建整个文档树的开销较大，处理大文件时性能可能会成为瓶颈。

适用场景

适用于需要频繁访问和操作 XML 文档的应用场景。
适用于中小规模的 XML 文档。

示例（使用 TinyXML）

#include <tinyxml2.h>
using namespace tinyxml2;int main() {XMLDocument doc;doc.LoadFile("example.xml");XMLElement* root = doc.RootElement();if (root != nullptr) {XMLElement* element = root->FirstChildElement("ElementName");if (element != nullptr) {const char* text = element->GetText();printf("Element text: %s\n", text);}}return 0;
}

SAX 解析

SAX 解析是一种事件驱动的解析方法，逐行读取 XML 文档，并在遇到不同的结构（如开始标签、结束标签、文本节点等）时触发相应的事件处理函数。SAX 解析不会将整个文档加载到内存中，而是按需处理文档内容。

优点

内存消耗低：不需要将整个文档加载到内存中，适合处理大文件。
性能高：按顺序处理文档内容，解析速度快。

缺点

使用复杂：事件驱动的编程模型较为复杂，需要编写事件处理函数。
不支持随机访问：只能按顺序读取文档内容，无法直接访问任意节点。

适用场景

适用于处理大型 XML 文档或内存有限的环境。
适用于一次性读取和处理文档内容的场景。

示例（使用 Expat）

#include <expat.h>
#include <cstdio>
#include <cstdlib>void startElement(void *userData, const char *name, const char **atts) {printf("Start element: %s\n", name);
}void endElement(void *userData, const char *name) {printf("End element: %s\n", name);
}void characterData(void *userData, const char *s, int len) {printf("Character data: %.*s\n", len, s);
}int main() {FILE *file = fopen("example.xml", "r");if (!file) return 1;XML_Parser parser = XML_ParserCreate(NULL);XML_SetElementHandler(parser, startElement, endElement);XML_SetCharacterDataHandler(parser, characterData);char buffer[1024];size_t len;while ((len = fread(buffer, 1, sizeof(buffer), file)) != 0) {if (XML_Parse(parser, buffer, len, feof(file)) == XML_STATUS_ERROR) {fprintf(stderr, "Parse error at line %lu:\n%s\n",XML_GetCurrentLineNumber(parser),XML_ErrorString(XML_GetErrorCode(parser)));return 1;}}XML_ParserFree(parser);fclose(file);return 0;
}

总结

DOM 解析：适合需要随机访问和操作 XML 内容的场景，使用简单但内存和性能消耗较大。
SAX 解析：适合处理大文件或内存有限的场景，性能高但使用复杂。

tinyxml2 库

tinyxml2 是一款简单、小巧、高效的开源C++ xml解析库，在 tinyxml2 库中，XMLNode 是一个基类，它有几个派生类型。这些派生类型用于表示不同类型的 XML 节点。以下是 XMLNode 的主要派生类型：

XMLDocument:

表示整个 XML 文档。
XMLDocument 是 XMLNode 的根，可以包含其他节点。
提供了加载、保存和解析 XML 文档的功能。

XMLElement:

表示 XML 文档中的一个元素（节点）。
可以包含其他元素、属性和文本。
是最常用的节点类型，用于表示 XML 标签。

XMLText:

表示 XML 元素中的文本内容。
用于包含实际的文本数据。

XMLComment:

表示 XML 文档中的注释节点。
注释节点内容不参与 XML 文档的逻辑处理，只用于提供额外的信息。

XMLDeclaration:

表示 XML 文档的声明部分（如 <?xml version="1.0" encoding="UTF-8"?>）。
通常在文档的最开始。

XMLUnknown:

表示未知的 XML 节点类型。
用于处理不符合其他已知节点类型的节点。

XMLAttribute:

严格来说，XMLAttribute 不是从 XMLNode 派生的，但它用于描述 XML 元素的属性。
属性节点包含名称和值，不直接参与 XML 文档的树结构。

tinyxml2解析有限元求解文件

一些有限元求解器的求解文件就是xml格式的，以开源FEM软件FEBio的求解文件为例，我们使用tinyxml2来提取里面的一些关键信息。

对于一个包含2万节点，12万单元的模型文件，我们通过tinyxml2解节点和单元信息花了0.3s，这个效率还是不错的。

如下为tinyxml2解析FEBio求解文件源码：

#include "tinyxml2.h"#include <iostream>
#include <vector>
#include <map>
#include <string>
#include <sstream>
#include <chrono>using namespace std;
using namespace tinyxml2;class FemXmlParser
{
public:FemXmlParser(const char* xmlFile):xml_file(xmlFile) {}void parse() {XMLDocument doc;if (doc.LoadFile(xml_file) != XML_SUCCESS) {std::cerr << "Failed to load file: " << xml_file << std::endl;return;}XMLElement* febio = doc.FirstChildElement("febio_spec");if (!febio) {std::cerr << "No <febio_spec> element in XML file." << std::endl;return;}XMLElement* module = febio->FirstChildElement("Module");if (module) {const char* type = module->Attribute("type");std::cout << "Module Type: " << (type ? type : "Unknown") << std::endl;}XMLElement* geometry = febio->FirstChildElement("Mesh");if (geometry) {XMLElement* nodesElement = geometry->FirstChildElement("Nodes");if (nodesElement) ParseNodes(nodesElement);XMLElement* elementsElement = geometry->FirstChildElement("Elements");if (elementsElement) ParseElements(elementsElement);}XMLElement* materialsElement = febio->FirstChildElement("Material");if (materialsElement) ParseMaterials(materialsElement);XMLElement* controlElement = febio->FirstChildElement("Control");if (controlElement) ParseControl(controlElement);}void printSumaryInfo(){std::cout << "Nodes: total " <<nodes.size()<< std::endl;std::cout << "Elements: total " << elements.size()<< std::endl;std::cout << "Materials:" << std::endl;for (const Material& material : materials) {std::cout << "ID: " << material.id << ", Type: " << material.type << std::endl;}std::cout << "Control:" << std::endl;std::cout << "Analysis Type: " << control.analysis << std::endl;}void printDetailInfo(){// 测试输出，确保数据正确存储在容器中std::cout << "Nodes:" << std::endl;for (const Node& node : nodes) {std::cout << "ID: " << node.id << ", Position: (" << node.x << ", " << node.y << ", " << node.z << ")" << std::endl;}std::cout << "Elements:" << std::endl;for (const Element& element : elements) {std::cout << "ID: " << element.id << ", Node IDs: ";for (int nodeId : element.nodeIds) {std::cout << nodeId << " ";}std::cout << std::endl;}std::cout << "Materials:" << std::endl;for (const Material& material : materials) {std::cout << "ID: " << material.id << ", Type: " << material.type << std::endl;}std::cout << "Control:" << std::endl;std::cout << "Analysis Type: " << control.analysis << std::endl;}private:struct Node {int id;double x, y, z;};struct Element {int id;std::vector<int> nodeIds;};struct Material {int id;std::string type;};struct Control {std::string analysis;};vector<int> splitStringToInts(const string& str, char delimiter) {vector<int> result;size_t start = 0;size_t end = str.find(delimiter);while (end != string::npos) {result.push_back(stoi(str.substr(start, end - start)));start = end + 1;end = str.find(delimiter, start);}result.push_back(stoi(str.substr(start, end - start)));return result;}vector<double> splitStringToDoubles(const string& str, char delimiter) {vector<double> result;stringstream ss(str);string item;while (getline(ss, item, delimiter)) {result.push_back(stod(item));}return result;}void ParseNodes(XMLElement* nodesElement) {for (XMLElement* node = nodesElement->FirstChildElement("node"); node != nullptr; node = node->NextSiblingElement("node")) {Node n;node->QueryIntAttribute("id", &n.id);const char* nodeText = node->GetText();if (nodeText) {vector<double> ns = splitStringToDoubles(nodeText, ',');n.x = ns[0];n.y = ns[1];n.z = ns[2];}nodes.push_back(n);}}void ParseElements(XMLElement* elementsElement) {for (XMLElement* element = elementsElement->FirstChildElement("elem"); element != nullptr; element = element->NextSiblingElement("elem")) {Element e;element->QueryIntAttribute("id", &e.id);const char* elemText = element->GetText();if (elemText) {e.nodeIds = splitStringToInts(elemText, ',');}elements.push_back(e);}}void ParseMaterials(XMLElement* materialsElement) {for (XMLElement* material = materialsElement->FirstChildElement("material"); material != nullptr; material = material->NextSiblingElement("material")) {Material m;material->QueryIntAttribute("id", &m.id);m.type = material->Attribute("type");materials.push_back(m);}}void ParseControl(XMLElement* controlElement) {XMLElement* ctrl = controlElement->FirstChildElement("analysis");control.analysis = ctrl->GetText();}private:const char* xml_file;std::vector<Node> nodes;std::vector<Element> elements;std::vector<Material> materials;Control control;
};class Timer {
public:Timer() : start_time_point(std::chrono::high_resolution_clock::now()) {}void reset() {start_time_point = std::chrono::high_resolution_clock::now();}double elapsed() const {return std::chrono::duration_cast<std::chrono::microseconds>(std::chrono::high_resolution_clock::now() - start_time_point).count() / 1000.0;  // 返回毫秒}void report(){double elapsed_time = elapsed();std::cout << "Elapsed time: " << elapsed_time << " ms" << std::endl;}
private:std::chrono::high_resolution_clock::time_point start_time_point;
};int main()
{Timer time;FemXmlParser parser("../big_file.xml");parser.parse();time.report();parser.printSumaryInfo();return 1;
}