读取和设置xml配置文件是最常用的操作，试用了几个C++的XML解析器，个人感觉TinyXML是使用起来最舒服的，因为它的API接口和Java的十分类似，面向对象性很好。
 
TinyXML是一个开源的解析XML的解析库，能够用于C++，能够在Windows或Linux中编译。这个解析库的模型通过解析XML文件，然后在内存中生成DOM模型，从而让我们很方便的遍历这棵XML树。
 
DOM模型即文档对象模型，是将整个文档分成多个元素（如书、章、节、段等），并利用树型结构表示这些元素之间的顺序关系以及嵌套包含关系。
 
如下是一个XML片段：
 
 
 
<Persons>
   <Person ID="1">
         <name>周星星</name>
         <age>20</age>
   </Person>
   <Person ID="2">
         <name>白晶晶</name>
         <age>18</age>
   </Person>
 </Persons>
 
 
在TinyXML中，根据XML的各种元素来定义了一些类：
 
TiXmlBase：整个TinyXML模型的基类。
 
TiXmlAttribute：对应于XML中的元素的属性。
 
TiXmlNode：对应于DOM结构中的节点。
 
TiXmlComment：对应于XML中的注释
 
TiXmlDeclaration：对应于XML中的申明部分，即<？versiong="1.0" ?>。
 
        在中文win下encoding基本是GB2312，在英文win下基本是ISO-8859-1。
 
TiXmlDocument：对应于XML的整个文档。
 
TiXmlElement：对应于XML的元素。
 
TiXmlText：对应于XML的文字部分
 
TiXmlUnknown：对应于XML的未知部分。 
 
TiXmlHandler：定义了针对XML的一些操作。
 
TinyXML是个解析库，主要由DOM模型类（TiXmlBase、TiXmlNode、TiXmlAttribute、TiXmlComment、TiXmlDeclaration、TiXmlElement、TiXmlText、TiXmlUnknown）和操作类（TiXmlHandler）构成。它由两个头文件（.h文件）和四个CPP文件（.cpp文件）构成，用的时候，只要将（tinyxml.h、tinystr.h、tinystr.cpp、tinyxml.cpp、tinyxmlerror.cpp、tinyxmlparser.cpp）导入工程就可以用它的东西了。如果需要，可以将它做成自己的DLL来调用。举个例子就可以说明一切。
 
读写XML文件的程序代码：
 
#define _CRT_SECURE_NO_WARNINGS
#include <iostream>
#include "tinystr.h"
#include "tinyxml.h"
#include <string>
using namespace std;

void CreateXmlFile(const char* path)
{
	//创建一个XML的文档对象。
	TiXmlDocument myDocument;

	//添加一个xml头
	TiXmlDeclaration *pDeclaration = new TiXmlDeclaration("1.0", "GB2312","");
	myDocument.LinkEndChild(pDeclaration);

	//创建一个根元素并连接。
	TiXmlElement *RootElement = new TiXmlElement("Persons");
	myDocument.LinkEndChild(RootElement);

	//创建一个Person元素并连接。
	TiXmlElement *PersonElement = new TiXmlElement("Person");
	RootElement->LinkEndChild(PersonElement);

	//设置Person元素的属性。
	PersonElement->SetAttribute("ID", "1");

	//创建name元素、age元素并连接。
	TiXmlElement *NameElement = new TiXmlElement("name");
	TiXmlElement *AgeElement = new TiXmlElement("age");
	PersonElement->LinkEndChild(NameElement);
	PersonElement->LinkEndChild(AgeElement);

	//设置name元素和age元素的内容并连接。
	TiXmlText *NameContent = new TiXmlText("周星星");
	TiXmlText *AgeContent = new TiXmlText("22");
	NameElement->LinkEndChild(NameContent);
	AgeElement->LinkEndChild(AgeContent);

	myDocument.SaveFile(path);//保存到文件
}

//读取Xml文件，并遍历
void ReadXmlFile(const char* path) 
{
	//创建一个XML的文档对象。
	TiXmlDocument *myDocument = new TiXmlDocument(path);
	myDocument->LoadFile();

	//获得根元素，即Persons。
	TiXmlElement *RootElement = myDocument->RootElement();
	//输出根元素名称，即输出Persons。
	cout << RootElement->Value() << endl;

	//获得第一个Person节点。
	TiXmlElement *FirstPerson = RootElement->FirstChildElement();
	//获得第一个Person的name节点和age节点和ID属性。
	TiXmlElement *NameElement = FirstPerson->FirstChildElement();
	TiXmlElement *AgeElement = NameElement->NextSiblingElement();
	TiXmlAttribute *IDAttribute = FirstPerson->FirstAttribute();
	//输出第一个Person的name内容，即周星星；age内容，即；ID属性，即。
	cout << NameElement->FirstChild()->Value() << endl;
	cout << AgeElement->FirstChild()->Value() << endl;
	cout << IDAttribute->Value() << endl;
}



int main(void)
{
	const char* path = "C:/Users/XX/source/repos/Project2/student.xml";
	CreateXmlFile(path);
	//ReadXmlFile(path);

	cout << " ";
	system("pause");
	return 0;
}
 
 

什么是XML
 
 
 
 
XML是可扩展标记语言（Extensible Markup Language）的缩写，其中标记是关键部分。用户可以创建内容，然后使用限定标记标记它，从而使每个单词、短语或块成为可识别、可分类的信息。
 标记语言从早起的私有公司和政府制定形式逐渐演变成标准通用标记语言（Standard Generalized Markup Language，SGML）、超文本标记语言（Hypertext Markup Language，HTML），并且最终演变成XML。XML有以下几个特点：
 
 
XML的设计宗旨是传输数据，而非显示数据
XML的标签没有被预定义，用户需要自行定义标签
XML被设计为具有自我描述性
XML是W3C的推荐标准
 
 
Python对XML文件的解析
 
 
常见的XML编程接口有DOM和SAX，这两种接口处理XML文件的方式不同，使用场合也不同。DOM是由W3C官方提出的标准，它会把整个XML文件读入内存，并将该文件解析成树，我们可以通过访问树的节点的方式访问XML中的标签，但是这种方法占用内存大，解析慢，如果读入文件过大，尽量避免使用这种方法。SAX是事件驱动的，通过在解析XML的过程中触发一个个的事件并调用用户自定义的回调函数来处理XML文件，速度比较快，占用内存少，但是需要用户实现回调函数，因此Python标准库的官方文档中这样介绍SAX：SAX每次只允许你查看文档的一小部分，你无法通过当前获取的元素访问其他元素。Python中提供了很多包支持XML文件的解析，如xml.dom，xml.sax，xml.dom.minidom和xml.etree.ElementTree等，本文重点介绍xml.dom.minidom
 
xml.dom.minidom包
 
xml.dom.minidom是DOM API的极简化实现，比完整版的DOM要简单的多，而且这个包也小得多，下面以movie.xml文件为例进行操作。
 
<collection shelf="New Arrivals">
<movie title="Enemy Behind">
   <type>War, Thriller</type>
   <format>DVD</format>
   <year>2003</year>
   <rating>PG</rating>
   <stars>10</stars>
   <description>Talk about a US-Japan war</description>
</movie>
<movie title="Transformers">
   <type>Anime, Science Fiction</type>
   <format>DVD</format>
   <year>1989</year>
   <rating>R</rating>
   <stars>8</stars>
   <description>A schientific fiction</description>
</movie>
   <movie title="Trigun">
   <type>Anime, Action</type>
   <format>DVD</format>
   <episodes>4</episodes>
   <rating>PG</rating>
   <stars>10</stars>
   <description>Vash the Stampede!</description>
</movie>
<movie title="Ishtar">
   <type>Comedy</type>
   <format>VHS</format>
   <rating>PG</rating>
   <stars>2</stars>
   <description>Viewable boredom</description>
</movie>
</collection>
 
然后我们调用xml.dom.minidom.parse方法读入xml文件并解析成DOM树
 
#!/usr/bin/python
# -*- coding: UTF-8 -*-
 
from xml.dom.minidom import parse
import xml.dom.minidom
 
# 使用minidom解析器打开 XML 文档
DOMTree = xml.dom.minidom.parse("movies.xml")
collection = DOMTree.documentElement
if collection.hasAttribute("shelf"):
   print "Root element : %s" % collection.getAttribute("shelf")
 
# 在集合中获取所有电影
movies = collection.getElementsByTagName("movie")
 
# 打印每部电影的详细信息
for movie in movies:
   print "*****Movie*****"
   if movie.hasAttribute("title"):
      print "Title: %s" % movie.getAttribute("title")
 
   type = movie.getElementsByTagName('type')[0]
   print "Type: %s" % type.childNodes[0].data
   format = movie.getElementsByTagName('format')[0]
   print "Format: %s" % format.childNodes[0].data
   rating = movie.getElementsByTagName('rating')[0]
   print "Rating: %s" % rating.childNodes[0].data
   description = movie.getElementsByTagName('description')[0]
   print "Description: %s" % description.childNodes[0].data
 
以上程序执行结果如下：
 
Root element : New Arrivals
*****Movie*****
Title: Enemy Behind
Type: War, Thriller
Format: DVD
Rating: PG
Description: Talk about a US-Japan war
*****Movie*****
Title: Transformers
Type: Anime, Science Fiction
Format: DVD
Rating: R
Description: A schientific fiction
*****Movie*****
Title: Trigun
Type: Anime, Action
Format: DVD
Rating: PG
Description: Vash the Stampede!
*****Movie*****
Title: Ishtar
Type: Comedy
Format: VHS
Rating: PG
Description: Viewable boredom
 
实战—批量修改XML文件
 
 
最近在用caffe-ssd训练比赛的数据集，但是官方给的数据集用来标记的XML文件并不是标准格式，一些标签的命名不对，导致无法正确生成lmdb文件，因此需要修改这些标签，下面用Python实现了一个批量修改XML文件的脚本。
 
# -*- coding:utf-8 -*-

import os

import xml.dom.minidom

xml_file_path = "/home/lyz/data/VOCdevkit/MyDataSet/Annotations/"
lst_label = ["height", "width", "depth"]
lst_dir = os.listdir(xml_file_path)


for file_name in lst_dir:
    file_path = xml_file_path + file_name
    tree = xml.dom.minidom.parse(file_path)
    root = tree.documentElement		#获取根结点
    size_node = root.getElementsByTagName("size")[0]
    for size_label in lst_label:	#替换size标签下的子节点
        child_tag = "img_" + size_label
        child_node = size_node.getElementsByTagName(child_tag)[0]
        new_node = tree.createElement(size_label)
        text = tree.createTextNode(child_node.firstChild.data)
        new_node.appendChild(text)
        size_node.replaceChild(new_node, child_node)

    #替换object下的boundingbox节点
    lst_obj = root.getElementsByTagName("object")
    data = {}
    for obj_node in lst_obj:
        box_node = obj_node.getElementsByTagName("bounding_box")[0]
        new_box_node = tree.createElement("bndbox")
        for child_node in box_node.childNodes:
            tmp_node = child_node.cloneNode("deep")
            new_box_node.appendChild(tmp_node)
        x_node = new_box_node.getElementsByTagName("x_left_top")[0]
        xmin = x_node.firstChild.data
        data["xmin"] = (xmin, x_node)
        y_node = new_box_node.getElementsByTagName("y_left_top")[0]
        ymin = y_node.firstChild.data
        data["ymin"] = (ymin, y_node)
        w_node = new_box_node.getElementsByTagName("width")[0]
        xmax = str(int(xmin) + int(w_node.firstChild.data))
        data["xmax"] = (xmax, w_node)
        h_node = new_box_node.getElementsByTagName("height")[0]
        ymax = str(int(ymin) + int(h_node.firstChild.data))
        data["ymax"] = (ymax, h_node)


        for k, v in data.items():
            new_node = tree.createElement(k)
            text = tree.createTextNode(v[0])
            new_node.appendChild(text)
            new_box_node.replaceChild(new_node, v[1])
        obj_node.replaceChild(new_box_node, box_node)

    with open(file_path, 'w') as f:
        tree.writexml(f, indent="\n", addindent="\t", encoding='utf-8')

    #去掉XML文件头（一些情况下文件头的存在可能导致错误）
    lines = []
    with open(file_path, 'rb') as f:
        lines = f.readlines()[1:]
    with open(file_path, 'wb') as f:
        f.writelines(lines)

print("-----------------done--------------------")
 
关于writexml方法：indent参数表示在当前节点之前插入的字符，addindent表示在该结点的子节点前插入的字符

 
文章目录
 
xml文件读取概述
构建xml示例
读取xml示例
修改xml示例
写在结尾
   
  
 

 
xml文件读取概述
 
前面两篇文章对boost读写ini和json做了总结，本文将对boost读写xml做一些详细的总结。和前两者一样，boost中命名空间property_tree提供了支持xml的读写操作，同时提供了大量的API方便外部调用。以下将通过示例简单介绍。
 
构建xml示例
 
void build_xml()
{
	ptree root; // 构建根节点
	ptree resource, version;

	version.put<int>("Version", 1);  // 创建子节点
	root.add_child("MyXml", version);  // 将子节点添加到根节点下

	ptree student;
	student.put<string>("Name", "zhangsan");
	student.put<int>("Age", 23);
	student.put<string>("Sex", "man");
	student.put<int>("Grade", 2);

	root.add_child("MyXml.Student", student);  // 可以用“根节点.子节点”的方式添加子节点

	ptree course, tnull;
	course.put<string>("Chinese", "runtu");
	course.put<string>("Math", "sin");
	course.add_child("English", tnull);
	root.add_child("MyXml.Course", course);

	// 使用setting参数，保证文件内容样式有缩进有对齐.
	auto setting = boost::property_tree::xml_writer_make_settings<string>('\t', 1);
	//写入文件，把proptrt_tree转换为xml格式
	write_xml("config_xml.xml", root, std::locale(), setting);
}
 
运行结果：
 
<?xml version="1.0" encoding="utf-8"?>
<MyXml>
	<Version>1</Version>
	<Student>
		<Name>zhangsan</Name>
		<Age>23</Age>
		<Sex>man</Sex>
		<Grade>2</Grade>
	</Student>
	<Course>
		<Chinese>runtu</Chinese>
		<Math>sin</Math>
		<English/>
	</Course>
</MyXml>
 
读取xml示例
 
void readxml()
{
	ptree root; //构建根节点
	try
	{
		read_xml("config_xml.xml", root);
	}
	catch(const std::exception &e)
	{
		std::cout<<e.what()<<endl;
	}
	
	int version = root.get<int>("MyXml.Version");  // 获取指定节点的值
	cout << "Version is " << version << endl;

	ptree student;

	cout << "student" << endl;
	student = root.get_child("MyXml.Student"); // 获取指定节点，迭代遍历输出
	for (boost::property_tree::ptree::iterator it = student.begin(); it != student.end(); ++it)
	{
		cout << "\t" << it->first;
		cout << ":" << it->second.data() << endl;
	}
 }
 
运行结果
 
 
修改xml示例
 
void updatexml()
{
	ptree root;
	try
	{
		// 读取xml，必须要用boost::property_tree::xml_parser::trim_whitespace换行以及裁剪空格，否则写入的文件格式会错乱
		read_xml("config_xml.xml", root, boost::property_tree::xml_parser::trim_whitespace);
	}
	catch (const std::exception &e)
	{
		cout << e.what() << endl;
	}


	root.put("MyXml.Version", 2);   //修改Version版本为
	root.put("MyXml.Student.Prov", "beijing");   // 没有Prov节点，将添加新节点Prov
	
	// 设置写入xml的格式，否则格式会错乱，不易于阅读
	boost::property_tree::xml_writer_settings<string> settings = boost::property_tree::xml_writer_make_settings<string>('\t', 1);

	//把property_tree 转为XML文件
	write_xml("config_xml.xml", root, std::locale(), settings);
}
 
执行结果：
 
<?xml version="1.0" encoding="utf-8"?>
<MyXml>
	<Version>2</Version>
	<Student>
		<Name>zhangsan</Name>
		<Age>23</Age>
		<Sex>man</Sex>
		<Grade>2</Grade>
		<Prov>beijing</Prov>
	</Student>
	<Course>
		<Chinese>runtu</Chinese>
		<Math>sin</Math>
		<English/>
	</Course>
</MyXml>

 
写在结尾
 
周末时间，总结了boost读写常见配置文件 ini 、json 、xml 的方式。boost中，命名空间property_tree中basic_ptree提供了核心功能，操作类似stl中的list等容器，提供了迭代器、属性树等功能， basic_ptree有两个重要的类型self_type和value_type。self_type是basic_ptree模板实例化后自身的类型，也是子节点的类型。value_type是节点的数据结构，它是一个std::pair，它含有属性名(first)和节点自身(second)，同时支持迭代器遍历。
 通常使用预定义的typedef类型，不直接适用basic_ptree。如ptree、wptree、iptree、wiptree。前缀i表示忽略大小写，前缀w表示支持宽字符。
 
文章是博主学习期间总结的学习笔记，刚开始学习，从源码逐行阅读，理解上可能有偏差，如果在阅读中发现错误或bug，可以随时联系博主或者留言，博主会第一时间进行修正。如果本文对你有帮助，请点赞支持，谢谢关注。

XmlDocument类的属性
 
 
属性
 
说明
 
Attributes
 
当前节点的属性集合
 
BaseURI
 
当前节点的基URI
 
ChildNodes
 
节点的所有子节点
 
DocumentElement
 
文档的根
 
DocumentType
 
DOCTYPE 声明的节点
 
FirstChild
 
节点的第一个子节点
 
HasChildNodes
 
是否有任何子节点
 
Implementation
 
获取当前文档的 XmlImplementation对象
 
InnerText
 
节点包含的所有文本内容
 
InnerXml
 
节点所包含的所有XML内容
 
IsReadOnly
 
当前节点是否是只读的
 
Item
 
获取指定的子元素
 
LastChild
 
最后一个子节点
 
LocalName
 
获取节点的本地名称
 
Name
 
获取节点的限定名
 
NamespaceURI
 
获取该节点的命名空间 URI
 
NameTable
 
获取与此实现关联的 XmlNameTable
 
NextSibling
 
获取紧接在该节点之后的节点
 
NodeType
 
获取当前节点的类型
 
OuterXml
 
获取表示此节点及其所有子节点的标记
 
OwnerDocument
 
获取当前节点所属的 XmlDocument
 
ParentNode
 
获取该节点（对于可以具有父级的节点）的父级
 
Prefix
 
获取或设置该节点的命名空间前缀
 
PreserveWhitespace
 
获取或设置一个值，该值指示是否在元素内容中保留空白
 
PreviousSibling
 
获取紧接在该节点之前的节点
 
SchemaInfo
 
返回节点的后架构验证信息集 (PSVI)
 
Schemas
 
获取或设置与此 XmlDocument 关联的 XmlSchemaSet 对象
 
Value
 
获取或设置节点的值
 
XmlResolver
 
设置 XmlResolver 以用于解析外部资源
 
 
XmlDocument类的方法
 
 
方法
 
说明
 
AppendChild
 
将指定的节点添加到该节点的子节点列表的末尾
 
CreateAttribute
 
创建具有指定名称的 XmlAttribute
 
CreateCDataSection
 
创建包含指定数据的 XmlCDataSection
 
CreateComment
 
创建包含指定数据的 XmlComment
 
CreateDocumentFragment
 
创建 XmlDocumentFragment
 
CreateDocumentType
 
返回新的 XmlDocumentType 对象
 
CreateElement
 
创建 XmlElement
 
CreateEntityReference
 
创建具有指定名称的 XmlEntityReference
 
CreateNavigator
 
创建一个用于导航此文档的新 XPathNavigator 对象
 
CreateNode
 
创建 XmlNode
 
CreateProcessingInstruction
 
创建一个具有指定名称和数据的 XmlProcessingInstruction
 
CreateSignificantWhitespace
 
创建一个 XmlSignificantWhitespace 节点
 
CreateTextNode
 
创建具有指定文本的 XmlText
 
CreateWhitespace
 
创建一个 XmlWhitespace 节点
 
CreateXmlDeclaration
 
创建一个具有指定值的 XmlDeclaration 节点
 
GetElementById
 
获取具有指定 ID 的 XmlElement
 
GetElementsByTagName
 
返回一个 XmlNodeList ，它包含与指定名称匹配的所有元素的列表
 
GetNamespaceOfPrefix 
 
查找当前节点范围内离给定的前缀最近的 xmlns 声明，并返回声明中的命名空间 URI
 
GetPrefixOfNamespace 
 
查找当前节点范围内离给定的命名空间 URI 最近的 xmlns 声明，并返回声明中定义的前缀
 
GetType
 
获取当前实例的 Type
 
ImportNode
 
将节点从另一个文档导入到当前文档
 
InsertAfter
 
将指定的节点紧接着插入指定的引用节点之后
 
InsertBefore
 
将指定的节点紧接着插入指定的引用节点之前
 
Load
 
加载指定的 XML 数据
 
LoadXml
 
从指定的字符串加载 XML 文档
 
Normalize 
 
将XmlText 节点都转换成“正常”形式
 
PrependChild 
 
将指定的节点添加到该节点的子节点列表的开头
 
ReadNode
 
根据 XmlReader 中的信息创建一个 XmlNode 对象。读取器必须定位在节点或属性上
 
RemoveAll 
 
移除当前节点的所有子节点和/或属性
 
RemoveChild 
 
移除指定的子节点
 
ReplaceChild 
 
用新节点替换旧节点
 
Save
 
将 XML 文档保存到指定的位置
 
SelectNodes 
 
选择匹配XPath 表达式的节点列表
 
SelectSingleNode 
 
选择匹配 XPath 表达式的第一个 XmlNode
 
Supports 
 
测试 DOM 实现是否实现特定的功能
 
Validate
 
验证 XmlDocument 是不是 Schemas 属性中包含的 XML 架构定义语言 (XSD) 架构。
 
WriteContentTo
 
将 XmlDocument 节点的所有子级保存到指定的 XmlWriter 中
 
WriteTo
 
将 XmlDocument 节点保存到指定的 XmlWriter
 
 
XmlDocument类的事件
 


 
 
事件
 
说明
 
NodeChanged
 
当属于该文档的节点的 Value已被更改时发生
 
NodeChanging
 
当属于该文档的节点的 Value 将被更改时发生
 
NodeInserted
 
当属于该文档的节点已被插入另一个节点时发生
 
NodeInserting
 
当属于该文档的节点将被插入另一个节点时发生
 
NodeRemoved
 
当属于该文档的节点已被从其父级移除时发生
 
NodeRemoving
 
当属于该文档的节点将被从文档中移除时发生