• C++ XML文件和解析

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

    XML 文档的基本格式

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

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

    具体示例

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

    1. "1.0" encoding="UTF-8"?>
    3. <bookstore>
    4.   <book category="cooking">
    5.     <title lang="en">Everyday Italiantitle>
    6.     <author>Giada De Laurentiisauthor>
    7.     <year>2005year>
    8.     <price>30.00price>
    9.   book>
    10.   <book category="children">
    11.     <title lang="en">Harry Pottertitle>
    12.     <author>J K. Rowlingauthor>
    13.     <year>2005year>
    14.     <price>29.99price>
    15.   book>
    16.   <book category="web">
    17.     <title lang="en">Learning XMLtitle>
    18.     <author>Erik T. Rayauthor>
    19.     <year>2003year>
    20.     <price>39.95price>
    21.   book>
    22. bookstore>

    XML 文档的详细部分

    XML 声明：

    "1.0" encoding="UTF-8"?>

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

    注释：

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

    根元素：

    1. <bookstore>
    2.     
    3. bookstore>

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

    元素：

    1. <book category="cooking">
    2.     <title lang="en">Everyday Italiantitle>
    3.     <author>Giada De Laurentiisauthor>
    4.     <year>2005year>
    5.     <price>30.00price>
    6. book>

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

    属性：

    1. <book category="cooking">
    2.     <title lang="en">Everyday Italiantitle>
    3.     
    4. book>

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

    文本内容：

    <title lang="en">Everyday Italiantitle>

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

    常见的 XML 结构

    嵌套元素：

    1. <family>
    2.   <parent name="John">
    3.     <child name="Doe" age="10"/>
    4.     <child name="Jane" age="8"/>
    5.   parent>
    6. family>

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

    属性和子元素结合：

    1. <employee id="1001">
    2.   <name>John Doename>
    3.   <department>HRdepartment>
    4.   <salary>5000salary>
    5. 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）
    1. #include 
    2. using namespace tinyxml2;
    3.  
    4. int main() {
    5.     XMLDocument doc;
    6.     doc.LoadFile("example.xml");
    7.     
    8.     XMLElement* root = doc.RootElement();
    9.     if (root != nullptr) {
    10.         XMLElement* element = root->FirstChildElement("ElementName");
    11.         if (element != nullptr) {
    12.             const char* text = element->GetText();
    13.             printf("Element text: %s\n", text);
    14.         }
    15.     }
    16.     return 0;
    17. }

    SAX 解析

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

    优点
    • 内存消耗低：不需要将整个文档加载到内存中，适合处理大文件。
    • 性能高：按顺序处理文档内容，解析速度快。
    缺点
    • 使用复杂：事件驱动的编程模型较为复杂，需要编写事件处理函数。
    • 不支持随机访问：只能按顺序读取文档内容，无法直接访问任意节点。
    适用场景
    • 适用于处理大型 XML 文档或内存有限的环境。
    • 适用于一次性读取和处理文档内容的场景。
    示例（使用 Expat）
    1. #include 
    2. #include 
    3. #include 
    4.  
    5. void startElement(void *userData, const char *name, const char **atts) {
    6.     printf("Start element: %s\n", name);
    7. }
    8.  
    9. void endElement(void *userData, const char *name) {
    10.     printf("End element: %s\n", name);
    11. }
    12.  
    13. void characterData(void *userData, const char *s, int len) {
    14.     printf("Character data: %.*s\n", len, s);
    15. }
    16.  
    17. int main() {
    18.     FILE *file = fopen("example.xml", "r");
    19.     if (!file) return 1;
    20.  
    21.     XML_Parser parser = XML_ParserCreate(NULL);
    22.     XML_SetElementHandler(parser, startElement, endElement);
    23.     XML_SetCharacterDataHandler(parser, characterData);
    24.  
    25.     char buffer[1024];
    26.     size_t len;
    27.     while ((len = fread(buffer, 1, sizeof(buffer), file)) != 0) {
    28.         if (XML_Parse(parser, buffer, len, feof(file)) == XML_STATUS_ERROR) {
    29.             fprintf(stderr, "Parse error at line %lu:\n%s\n",
    30.                 XML_GetCurrentLineNumber(parser),
    31.                 XML_ErrorString(XML_GetErrorCode(parser)));
    32.             return 1;
    33.         }
    34.     }
    35.     XML_ParserFree(parser);
    36.     fclose(file);
    37.     return 0;
    38. }

    总结

    • 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 文档的声明部分（如 ）。
    • 通常在文档的最开始。

    XMLUnknown:

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

    XMLAttribute:

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

    tinyxml2解析有限元求解文件

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

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

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

    1. #include "tinyxml2.h"
    2.  
    3. #include 
    4. #include 
    5. #include 
    6. #include 
    7. #include 
    8. #include 
    9.  
    10. using namespace std;
    11. using namespace tinyxml2;
    12.  
    13. class FemXmlParser
    14. {
    15. public:
    16. 	FemXmlParser(const char* xmlFile)
    17. 		:xml_file(xmlFile) {
    18.  
    19. 	}
    20.  
    21. 	void parse() {
    22. 		XMLDocument doc;
    23. 		if (doc.LoadFile(xml_file) != XML_SUCCESS) {
    24. 			std::cerr << "Failed to load file: " << xml_file << std::endl;
    25. 			return;
    26. 		}
    27.  
    28. 		XMLElement* febio = doc.FirstChildElement("febio_spec");
    29. 		if (!febio) {
    30. 			std::cerr << "No  element in XML file." << std::endl;
    31. 			return;
    32. 		}
    33.  
    34. 		XMLElement* module = febio->FirstChildElement("Module");
    35. 		if (module) {
    36. 			const char* type = module->Attribute("type");
    37. 			std::cout << "Module Type: " << (type ? type : "Unknown") << std::endl;
    38. 		}
    39.  
    40. 		XMLElement* geometry = febio->FirstChildElement("Mesh");
    41. 		if (geometry) {
    42. 			XMLElement* nodesElement = geometry->FirstChildElement("Nodes");
    43. 			if (nodesElement) ParseNodes(nodesElement);
    44.  
    45. 			XMLElement* elementsElement = geometry->FirstChildElement("Elements");
    46. 			if (elementsElement) ParseElements(elementsElement);
    47. 		}
    48.  
    49. 		XMLElement* materialsElement = febio->FirstChildElement("Material");
    50. 		if (materialsElement) ParseMaterials(materialsElement);
    51.  
    52. 		XMLElement* controlElement = febio->FirstChildElement("Control");
    53. 		if (controlElement) ParseControl(controlElement);
    54. 	}
    55.  
    56. 	void printSumaryInfo()
    57. 	{
    58. 		std::cout << "Nodes: total " <size()<< std::endl;
    59. 	
    60. 		std::cout << "Elements: total " << elements.size()<< std::endl;
    61. 		
    62. 		std::cout << "Materials:" << std::endl;
    63. 		for (const Material& material : materials) {
    64. 			std::cout << "ID: " << material.id << ", Type: " << material.type << std::endl;
    65. 		}
    66.  
    67. 		std::cout << "Control:" << std::endl;
    68. 		std::cout << "Analysis Type: " << control.analysis << std::endl;
    69. 	}
    70.  
    71. 	void printDetailInfo()
    72. 	{
    73. 		// 测试输出，确保数据正确存储在容器中
    74. 		std::cout << "Nodes:" << std::endl;
    75. 		for (const Node& node : nodes) {
    76. 			std::cout << "ID: " << node.id << ", Position: (" << node.x << ", " << node.y << ", " << node.z << ")" << std::endl;
    77. 		}
    78.  
    79. 		std::cout << "Elements:" << std::endl;
    80. 		for (const Element& element : elements) {
    81. 			std::cout << "ID: " << element.id << ", Node IDs: ";
    82. 			for (int nodeId : element.nodeIds) {
    83. 				std::cout << nodeId << " ";
    84. 			}
    85. 			std::cout << std::endl;
    86. 		}
    87.  
    88. 		std::cout << "Materials:" << std::endl;
    89. 		for (const Material& material : materials) {
    90. 			std::cout << "ID: " << material.id << ", Type: " << material.type << std::endl;
    91. 		}
    92.  
    93. 		std::cout << "Control:" << std::endl;
    94. 		std::cout << "Analysis Type: " << control.analysis << std::endl;
    95. 	}
    96.  
    97. private:
    98. 	struct Node {
    99. 		int id;
    100. 		double x, y, z;
    101. 	};
    102.  
    103. 	struct Element {
    104. 		int id;
    105. 		std::vector<int> nodeIds;
    106. 	};
    107.  
    108. 	struct Material {
    109. 		int id;
    110. 		std::string type;
    111. 	};
    112.  
    113. 	struct Control {
    114. 		std::string analysis;
    115. 	};
    116.  
    117. 	vector<int> splitStringToInts(const string& str, char delimiter) {
    118. 		vector<int> result;
    119. 		size_t start = 0;
    120. 		size_t end = str.find(delimiter);
    121.  
    122. 		while (end != string::npos) {
    123. 			result.push_back(stoi(str.substr(start, end - start)));
    124. 			start = end + 1;
    125. 			end = str.find(delimiter, start);
    126. 		}
    127.  
    128. 		result.push_back(stoi(str.substr(start, end - start)));
    129. 		return result;
    130. 	}
    131.  
    132. 	vector<double> splitStringToDoubles(const string& str, char delimiter) {
    133. 		vector<double> result;
    134. 		stringstream ss(str);
    135. 		string item;
    136.  
    137. 		while (getline(ss, item, delimiter)) {
    138. 			result.push_back(stod(item));
    139. 		}
    140.  
    141. 		return result;
    142. 	}
    143.  
    144. 	void ParseNodes(XMLElement* nodesElement) {
    145. 		for (XMLElement* node = nodesElement->FirstChildElement("node"); node != nullptr; node = node->NextSiblingElement("node")) {
    146. 			Node n;
    147. 			node->QueryIntAttribute("id", &n.id);
    148. 			const char* nodeText = node->GetText();
    149. 			if (nodeText) {
    150. 				vector<double> ns = splitStringToDoubles(nodeText, ',');
    151. 				n.x = ns[0];
    152. 				n.y = ns[1];
    153. 				n.z = ns[2];
    154. 			}
    155. 			nodes.push_back(n);
    156. 		}
    157. 	}
    158.  
    159. 	void ParseElements(XMLElement* elementsElement) {
    160. 		for (XMLElement* element = elementsElement->FirstChildElement("elem"); element != nullptr; element = element->NextSiblingElement("elem")) {
    161. 			Element e;
    162. 			element->QueryIntAttribute("id", &e.id);
    163.  
    164. 			const char* elemText = element->GetText();
    165. 			if (elemText) {
    166. 				e.nodeIds = splitStringToInts(elemText, ',');
    167. 			}
    168. 			elements.push_back(e);
    169. 		}
    170. 	}
    171.  
    172. 	void ParseMaterials(XMLElement* materialsElement) {
    173. 		for (XMLElement* material = materialsElement->FirstChildElement("material"); material != nullptr; material = material->NextSiblingElement("material")) {
    174. 			Material m;
    175. 			material->QueryIntAttribute("id", &m.id);
    176. 			m.type = material->Attribute("type");
    177. 			materials.push_back(m);
    178. 		}
    179. 	}
    180.  
    181. 	void ParseControl(XMLElement* controlElement) {
    182. 		XMLElement* ctrl = controlElement->FirstChildElement("analysis");
    183. 		control.analysis = ctrl->GetText();
    184. 	}
    185.  
    186. private:
    187. 	const char* xml_file;
    188. 	std::vector nodes;
    189. 	std::vector elements;
    190. 	std::vector materials;
    191. 	Control control;
    192. };
    193.  
    194.  
    195. class Timer {
    196. public:
    197. 	Timer() : start_time_point(std::chrono::high_resolution_clock::now()) {}
    198.  
    199. 	void reset() {
    200. 		start_time_point = std::chrono::high_resolution_clock::now();
    201. 	}
    202.  
    203. 	double elapsed() const {
    204. 		return std::chrono::duration_cast(
    205. 			std::chrono::high_resolution_clock::now() - start_time_point
    206. 			).count() / 1000.0;  // 返回毫秒
    207. 	}
    208.  
    209. 	void report()
    210. 	{
    211. 		double elapsed_time = elapsed();
    212. 		std::cout << "Elapsed time: " << elapsed_time << " ms" << std::endl;
    213. 	}
    214. private:
    215. 	std::chrono::high_resolution_clock::time_point start_time_point;
    216. };
    217.  
    218. int main()
    219. {
    220. 	Timer time;
    221. 	FemXmlParser parser("../big_file.xml");
    222. 	parser.parse();
    223. 	time.report();
    224. 	parser.printSumaryInfo();
    225. 	return 1;
    226. }
  • 相关阅读:
    【JAVA】Servlet
    RCE极限挑战
    JAVA-分页查询
    不了解无线调制方式？这几个“老古董”大家现在还在用！
    QtCreator配置代码字体和颜色
    【iptables 实战】05 iptables设置网络转发实验
    P08 DQL
    76. 最小覆盖子串
    水果库存系统(SSM+Thymeleaf版)
    VulnHub Earth
  • 原文地址：https://blog.csdn.net/leizhengshenglzs/article/details/139455605