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 中有特殊含义，需要使用转义序列（如 &lt;, &gt;, &amp;）表示。

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;
}