0.前言

TinyXML-2 是一个简单，小型，高效的 C ++ XML 解析器，可以轻松集成到其他程序中，直接引用源文件的话只需要包含两个文件（h 和 cpp，此外还有个测试文件里面带有 demo）。

TinyXML-2 解析 XML 文档，并以此为基础构建可读取，修改和保存的文档对象模型（DOM）。文档说，在解释 XML 时仅使用 UTF-8 ，假定所有 XML 为 UTF-8 （看了下使用 MSVC 编译器时生成的 XML 文件文本编码使用的本地编码）。该库还支持打印到文件或内存，使用 XMLPrinter 类。

GitHub 链接：https://github.com/leethomason/tinyxml2

（在线文档我的网访问不了，但是下载库 GitHub 上的项目后带有离线文档，用谷歌浏览器在线翻译即可）

1.基本使用

引入头文件：

#include "tinyxml2.h"

//tinyxml2的类在tinyxml2命名空间
using namespace tinyxml2;

使用 XMLDocument 加载和保存 XML 文件：

//构造一个xml文档类
XMLDocument doc;
//读取文件
//从磁盘加载XML文件。成功返回XML_SUCCESS（0），或者返回errorID。
XMLError error = doc.LoadFile(xmlPath);
//也可以解析字符串
//XMLError tinyxml2::XMLDocument::Parse(const char *xml,size_t nBytes = static_cast<size_t>(-1));
if (error != XMLError::XML_SUCCESS)
	return;
//存储到文件，参数2 compact紧凑默认false
doc.SaveFile(xmlPath);

可以借助 XMLDocument 生成节点（元素、属性、文本、注释等），也可以直接 new 生成对象，但还要使用 Insert 方法才能插入到结构中：

//元素
XMLElement * tinyxml2::XMLDocument::NewElement (const char *name)
//注释
XMLComment * tinyxml2::XMLDocument::NewComment (const char *comment)
//文本
XMLText * tinyxml2::XMLDocument::NewText (const char *text) 
//XML文件头描述
XMLDeclaration * tinyxml2::XMLDocument::NewDeclaration (const char *text=0)
//未知类型
XMLUnknown * tinyxml2::XMLDocument::NewUnknown (const char *text)

//插入到末尾
XMLNode * tinyxml2::XMLNode::InsertEndChild (XMLNode *addThis)
//插入到开头
XMLNode * tinyxml2::XMLNode::InsertFirstChild (XMLNode *addThis)
//插入到节点的下一个位置
XMLNode * tinyxml2::XMLNode::InsertAfterChild (XMLNode *afterThis, XMLNode *addThis)

删除子节点：

//删除所有子节点
void tinyxml2::XMLNode::DeleteChildren ()
//删除指定子节点
void tinyxml2::XMLNode::DeleteChild (XMLNode *node)

对于查找，可通过父子兄弟节点进行遍历：

//是否不包含子节点
bool tinyxml2::XMLNode::NoChildren () const
//第一个子节点
const XMLNode * tinyxml2::XMLNode::FirstChild () const
//第一个子元素 
const XMLElement * tinyxml2::XMLNode::FirstChildElement (const char *name=0) const
//最后一个子节点
const XMLNode * tinyxml2::XMLNode::LastChild () const
//最后一个子元素
const XMLElement * tinyxml2::XMLNode::LastChildElement (const char *name=0) const
//上一个兄弟节点 
const XMLNode * tinyxml2::XMLNode::PreviousSibling () const
//上一个兄弟元素 
const XMLElement * tinyxml2::XMLNode::PreviousSiblingElement (const char *name=0) const
//下一个兄弟节点
const XMLNode * tinyxml2::XMLNode::NextSibling () const
//下一个兄弟元素
const XMLElement * tinyxml2::XMLNode::NextSiblingElement (const char *name=0) const

如果要遍历整个文档，可从 XMLDocument 开始遍历，XXXChild + XXXSibling 遍历所有的子节点和兄弟节点。

2.简单的示例

第一生成的 XML 结构如下：

<?xml version="1.0" encoding="UTF-8"?>
<ElementA Level="A" Value="1992">ElementA text<!--ElementA comment--><ElementB Level="B">ElementB text<!--ElementB comment--></ElementB>
</ElementA>

<!--My TinyXml2 Test... ...-->Some Test
<!Unknown>

第二次生成的 XML 结构如下：

<?xml version="1.0" encoding="UTF-8"?>
<Root>
    <GroupA Type="A">
        <Name>中文<Content>111111</Content>
        </Name>
        <Name>English<Content>222222</Content>
        </Name>
        <Name>123<Content>333333</Content>
        </Name>
    </GroupA>
    <GroupB Type="B"/>
    <GroupC Type="C"/>
</Root>

完整代码：

#include <iostream>
#include <string>

#include "tinyxml2.h"

//tinyxml2的类在tinyxml2命名空间
using namespace tinyxml2;

//测试生成xml
void create_xml(const char* xmlPath);
//测试解析xml
void parse_xml(const char* xmlPath);
//遍历xml node
void traversal_node(XMLNode* node);
//遍历xml element
void traversal_element(XMLNode* node, int level);
//生成预定格式xml
void create_xml2(const char* xmlPath);
//解析预定义格式xml
void parse_xml2(const char* xmlPath);

int main()
{
	const char* path = "./test.xml";
	create_xml(path);
	parse_xml(path);

	const char* path2 = "./test2.xml";
	create_xml2(path2);
	parse_xml2(path2);

	system("pause");
	return 0;
}

void create_xml(const char* xmlPath)
{
	std::cout << "\ncreate_xml:" << xmlPath << std::endl;
	//【】构造一个xml文档类
	XMLDocument doc;
	//【】操作文档相关接口
	//创建与此文档关联的新声明。对象的内存由文档管理。
	//如果'text'参数为null，则使用标准声明:
	//<?xml version="1.0" encoding="UTF-8"?>
	XMLDeclaration* declaration = doc.NewDeclaration();
	//创建与此文档关联的新元素。元素的内存由文档管理。
	XMLElement* element = doc.NewElement("ElementA");
	//创建与此文档关联的新注释。注释的内存由文档管理。
	XMLComment* comment = doc.NewComment("My TinyXml2 Test... ...");
	//创建与此文档关联的新文本。文本的存储由文档管理。
	XMLText* text = doc.NewText("Some Test");
	//创建与此文档关联的新的未知节点。对象的内存由文档管理。
	XMLUnknown* unknown = doc.NewUnknown("Unknown");
	//【】创建了节点还要插入文档中
	//添加一个子节点作为最后一个（右）子节点。如果子节点已经是文档的一部分，则将其从其旧位置移至新位置。
	//XMLNode* tinyxml2::XMLNode::InsertEndChild(XMLNode * addThis);
	//添加一个子节点作为第一个（左）子节点。如果子节点已经是文档的一部分，则将其从其旧位置移至新位置。
	//XMLNode* tinyxml2::XMLNode::InsertFirstChild(XMLNode* addThis);
	//在指定的子节点之后添加一个节点。如果子节点已经是文档的一部分，则将其从其旧位置移至新位置。
	//XMLNode* tinyxml2::XMLNode::InsertAfterChild(XMLNode * afterThis, XMLNode * addThis);
	doc.InsertFirstChild(declaration);
	doc.InsertAfterChild(declaration, element);
	doc.InsertEndChild(comment);
	doc.InsertEndChild(text);
	doc.InsertEndChild(unknown);

	//【】操作节点相关接口
	//将命名属性设置为对应类型的value
	element->SetAttribute("Level", "A");
	element->SetAttribute("Value", 1992);
	//设置文本
	element->SetText("ElementA text");
	//注释
	element->InsertNewComment("ElementA comment");
	//添加子节点，接口已经带insert功能了
	XMLElement* sub_element = element->InsertNewChildElement("ElementB");
	sub_element->SetAttribute("Level", "B");
	sub_element->SetText("ElementB text");
	sub_element->InsertNewComment("ElementB comment");


	//【】存储到文件，参数2 compact紧凑默认false
	//结构写的不规范，感觉应该拿一个根节点把那些注释，文本包起来
	//不然解析的时候没法访问啊
	doc.SaveFile(xmlPath);
}

void parse_xml(const char* xmlPath)
{
	std::cout << "\nparse_xml:" << xmlPath << std::endl;
	//【】构造一个xml文档类
	XMLDocument doc;
	//【】读取文件
	//从磁盘加载XML文件。成功返回XML_SUCCESS（0），或者返回errorID。
	XMLError error = doc.LoadFile(xmlPath);
	//也可以解析字符串
	//从字符串解析XML文件。成功返回XML_SUCCESS（0），或者返回errorID。
	//XMLError tinyxml2::XMLDocument::Parse(const char *xml,size_t nBytes = static_cast<size_t>(-1));
	if (error != XMLError::XML_SUCCESS)
		return;
	//注意，实际解析时返回的指针记得判空，不然遇到解析失败异常就遭了

	//【】解析根元素
	//返回DOM的根元素。等效于FirstChildElement。要获取第一个节点，请使用FirstChild。
	XMLElement* root = doc.RootElement();
	std::cout << "RootElement name:" << root->Name() << std::endl;
	//获取第一个子元素，或者选择具有指定名称的第一个子元素。
	XMLElement* first = doc.FirstChildElement("ElementA");
	//给定一个属性名称，Attribute返回该名称的属性的值；如果不存在，则返回null。
	std::cout << "FirstChildElement Attr Level:" << first->Attribute("Level") << std::endl;
	std::cout << "FirstChildElement Attr Value:" << first->Attribute("Value") << std::endl;
	//如果'this'的第一个Child是XMLText，则GetText返回Text节点的字符串，否则返回null。
	std::cout << "FirstChildElement Text:" << first->GetText() << std::endl;

	//【】解析子元素
	XMLElement* sub = root->FirstChildElement("ElementB");
	std::cout << "SubElement Attr Level:" << sub->Attribute("Level") << std::endl;
	std::cout << "SubElement Text:" << sub->GetText() << std::endl;

	//【】
	//可使用FirstChild+NextSibling遍历子节点
	std::cout << "\ntraversal_xml:" << std::endl;
	traversal_node(&doc);
	//或者FirstChildElement+NextSiblingElement遍历子元素
	std::cout << "\ntraversal_element:" << std::endl;
	traversal_element(&doc, 0);
}

void traversal_node(XMLNode* node)
{
	if (!node)
		return;
	for (XMLNode* current = node->FirstChild(); current != nullptr; current = current->NextSibling())
	{
		XMLNode* temp = current;
		if (temp->Value() != nullptr)
			std::cout << temp->Value() << std::endl;
		if (!temp->NoChildren())
			traversal_node(temp);
	}
}

void traversal_element(XMLNode* node, int level)
{
	if (!node)
		return;
	for (XMLElement* current = node->FirstChildElement(); current != nullptr; current = current->NextSiblingElement())
	{
		XMLElement* temp = current;
		//这里我使用点号来表示层级缩进
		std::cout << std::string(level * 5, '.') << temp->Name() << std::endl;
		if (temp->GetText() != nullptr)
			std::cout << std::string(level * 5, '.') << "> Text" << ":" << temp->GetText() << std::endl;
		const XMLAttribute* attr = temp->FirstAttribute();
		if (attr != nullptr)
			std::cout << std::string(level * 5, '.') << "> Attr" << ":" << attr->Value() << std::endl;
		if (temp->FirstChildElement() != nullptr)
			traversal_element(temp, level + 1);
	}
}

void create_xml2(const char* xmlPath)
{
	std::cout << "\ncreate_xml2:" << xmlPath << std::endl;
	//【】构造一个xml文档类
	XMLDocument doc;

	//【】构建我们的xml数据结构
	XMLDeclaration* declaration = doc.NewDeclaration();
	doc.InsertFirstChild(declaration);
	//创建与此文档关联的新元素。元素的内存由文档管理。
	XMLElement* root = doc.NewElement("Root");
	doc.InsertEndChild(root);
	//子节点
	XMLElement* group_a = root->InsertNewChildElement("GroupA");
	group_a->SetAttribute("Type", "A");
	XMLElement* a_1 = group_a->InsertNewChildElement("Name");
	a_1->SetText("中文");
	XMLElement* a_1_sub = a_1->InsertNewChildElement("Content");
	a_1_sub->SetText("111111");
	XMLElement* a_2 = group_a->InsertNewChildElement("Name");
	a_2->SetText("English");
	XMLElement* a_2_sub = a_2->InsertNewChildElement("Content");
	a_2_sub->SetText("222222");
	XMLElement* a_3 = group_a->InsertNewChildElement("Name");
	a_3->SetText("123");
	XMLElement* a_3_sub = a_3->InsertNewChildElement("Content");
	a_3_sub->SetText("333333");
	XMLElement* group_b = root->InsertNewChildElement("GroupB");
	group_b->SetAttribute("Type", "B");
	XMLElement* group_c = root->InsertNewChildElement("GroupC");
	group_c->SetAttribute("Type", "C");


	//【】存储到文件，参数2 compact紧凑默认false
	doc.SaveFile(xmlPath);
}

void parse_xml2(const char* xmlPath)
{
	std::cout << "\nparse_xml2:" << xmlPath << std::endl;
	//【】构造一个xml文档类
	XMLDocument doc;
	//【】读取文件
	//从磁盘加载XML文件。成功返回XML_SUCCESS（0），或者返回errorID。
	XMLError error = doc.LoadFile(xmlPath);
	//也可以解析字符串
	//从字符串解析XML文件。成功返回XML_SUCCESS（0），或者返回errorID。
	//XMLError tinyxml2::XMLDocument::Parse(const char *xml,size_t nBytes = static_cast<size_t>(-1));
	if (error != XMLError::XML_SUCCESS)
		return;
	//注意，实际解析时返回的指针记得判空，不然遇到解析失败异常就遭了

	//【】解析根节点
	//返回DOM的根元素。等效于FirstChildElement。要获取第一个节点，请使用FirstChild。
	XMLElement* root = doc.RootElement();
	//【】查找
	XMLElement* find_ele = root->FirstChildElement("GroupA");
	if (find_ele) {
		std::cout << find_ele->Name() << std::endl;
		const XMLAttribute* attr = find_ele->FindAttribute("Type");
		if (attr) {
			std::cout << attr->Name() << ":" << attr->Value() << std::endl;
		}
		XMLElement* find_sub = find_ele->FirstChildElement("Name");
		if (find_sub && find_sub->GetText()) {
			std::cout << find_sub->GetText() << std::endl;
		}
	}

	//【】遍历
	std::cout << "\ntraversal_element:" << std::endl;
	traversal_element(&doc, 0);
}

TinyXML2是一个开源、简单、小巧、高效的C++ XML解析器，它只有一个.h文件和一个.cpp文件组成，可以轻松集成到其它程序中。它解析XML文档并从中构建可以读取、修改和保存的文档对象模型(Document Object Model, DOM)。它不能解析DTD(Document Type Definitions, 文档类型定义)或XSL(eXtensible Stylesheet Language, 扩展样式表语言)。在TinyXML2中，XML数据被解析为可以浏览和操作的C++对象，然后写入磁盘和其它输出流。它不依赖于C++的STL。

TinyXML2的license为ZLib，可以商用，它的源码在https://github.com/leethomason/tinyxml2 ，最新发布版本为7.1.0。

关于XML的介绍可以参考：https://blog.csdn.net/fengbingchun/article/details/38978591

以下是测试代码(test_tinyxml2.cpp)：创建XML(test_tinyxml2_create)和解析XML(test_tinyxml2_parse)

#include "funset.hpp"
#include <iostream>
#include "tinyxml2.h"

int test_tinyxml2_create()
{
	const char* declaration = "<?xml version=\"1.0\" encoding=\"UTF-8\"?>";
	tinyxml2::XMLDocument doc;
	tinyxml2::XMLError ret = doc.Parse(declaration);
	if (ret != 0) {
		fprintf(stderr, "fail to parse xml file: %s\n", declaration);
		return -1;
	}

	tinyxml2::XMLComment* comment = doc.NewComment("this is a xml test file");
	doc.InsertEndChild(comment);

	tinyxml2::XMLElement* root = doc.NewElement("Root");
	doc.InsertEndChild(root);

	// User
	tinyxml2::XMLElement* user = doc.NewElement("User");
	user->SetAttribute("Name", "fengbingchun");
	root->InsertEndChild(user);

	tinyxml2::XMLElement* blog = doc.NewElement("Blog");
	tinyxml2::XMLText* text1 = doc.NewText("CSDN");
	blog->InsertEndChild(text1);
	user->InsertEndChild(blog);
	
	tinyxml2::XMLElement* code = doc.NewElement("Code");
	tinyxml2::XMLText* text2 = doc.NewText("GitHub");
	code->InsertEndChild(text2);
	user->InsertEndChild(code);
	
	// Blog
	tinyxml2::XMLElement* blog2 = doc.NewElement("Blog");
	blog2->SetAttribute("Name", "CSDN");
	root->InsertEndChild(blog2);

	tinyxml2::XMLElement* addr = doc.NewElement("Address");
	tinyxml2::XMLText* text3 = doc.NewText("https://blog.csdn.net/fengbingchun");
	addr->InsertEndChild(text3);
	blog2->InsertEndChild(addr);
	
	tinyxml2::XMLElement* id = doc.NewElement("ID");
	tinyxml2::XMLText* text4 = doc.NewText("fengbingchun");
	id->InsertEndChild(text4);
	blog2->InsertEndChild(id);

	// Code
	tinyxml2::XMLElement* code2 = doc.NewElement("Code");
	code2->SetAttribute("Name", "GitHub");
	root->InsertEndChild(code2);

	tinyxml2::XMLElement* addr2 = doc.NewElement("Address");
	tinyxml2::XMLText* text5 = doc.NewText("https://github.com//fengbingchun");
	addr2->InsertEndChild(text5);
	code2->InsertEndChild(addr2);
	
	tinyxml2::XMLElement* repositories = doc.NewElement("Repositories");
	tinyxml2::XMLText* text6 = doc.NewText("27");
	repositories->InsertEndChild(text6);
	code2->InsertEndChild(repositories);

#ifdef _MSC_VER
	const char* file_name = "E:/GitCode/Messy_Test/testdata/test.xml"; 
#else
	const char* file_name = "testdata/test.xml";
#endif

	ret = doc.SaveFile(file_name);
	if (ret != 0) {
		fprintf(stderr, "fail to save xml file: %s\n", file_name);
		return -1;
	}

	return 0;
}

int test_tinyxml2_parse()
{
#ifdef _MSC_VER
	const char* file_name = "E:/GitCode/Messy_Test/testdata/test_tinyxml2.xml"; 
#else
	const char* file_name = "testdata/test_tinyxml2.xml";
#endif

	tinyxml2::XMLDocument doc;
	tinyxml2::XMLError ret = doc.LoadFile(file_name);
	if (ret != 0) {
		fprintf(stderr, "fail to load xml file: %s\n", file_name);
		return -1;
	}

	tinyxml2::XMLElement* root = doc.RootElement();
	fprintf(stdout, "root element name: %s\n", root->Name());

	// User
	tinyxml2::XMLElement* user = root->FirstChildElement("User");
	if (!user) {
		fprintf(stderr, "no child element: User\n");
		return -1;
	}
	fprintf(stdout, "user name: %s\n", user->Attribute("Name"));

	tinyxml2::XMLElement* blog = user->FirstChildElement("Blog");
	if (!blog) {
		fprintf(stderr, "no child element: Blog, in User\n");
		return -1;
	}
	fprintf(stdout, "blog value: %s\n", blog->GetText());
	fprintf(stdout, "code value: %s\n\n", user->FirstChildElement("Code")->GetText());
	
	// Blog
	tinyxml2::XMLElement* blog2 = root->FirstChildElement("Blog");
	if (!blog2) {
		fprintf(stderr, "no child element: Blog\n");
		return -1;
	}
	fprintf(stdout, "blog name: %s\n", blog2->Attribute("Name"));

	tinyxml2::XMLElement* addr = blog2->FirstChildElement("Address");
	if (!addr) {
		fprintf(stderr, "no child element: Address, in Blog\n");
		return -1;
	}
	fprintf(stdout, "address value: %s\n", addr->GetText());
	fprintf(stdout, "id value: %s\n\n", blog2->FirstChildElement("ID")->GetText());
	
	// Code
	tinyxml2::XMLElement* code = root->FirstChildElement("Code");
	if (!code) {
		fprintf(stderr, "no child element: Code\n");
		return -1;
	}
	fprintf(stdout, "code name: %s\n", code->Attribute("Name"));

	tinyxml2::XMLElement* addr2 = code->FirstChildElement("Address");
	if (!addr2) {
		fprintf(stderr, "no child element: Address, in Code\n");
		return -1;
	}
	fprintf(stdout, "address value: %s\n", addr2->GetText());
	fprintf(stdout, "repositories value: %s\n\n", code->FirstChildElement("Repositories")->GetText());

	return 0;
}

创建xml文件的执行结果如下：

<?xml version="1.0" encoding="UTF-8"?>
<!--this is a xml test file-->
<Root>
    <User Name="fengbingchun">
        <Blog>CSDN</Blog>
        <Code>GitHub</Code>
    </User>
    <Blog Name="CSDN">
        <Address>https://blog.csdn.net/fengbingchun</Address>
        <ID>fengbingchun</ID>
    </Blog>
    <Code Name="GitHub">
        <Address>https://github.com//fengbingchun</Address>
        <Repositories>27</Repositories>
    </Code>
</Root>

解析以上xml文件输出结果如下：

GitHub：https://github.com/fengbingchun/Messy_Test

1.概述

tinyxml2 github地址
本文涵盖了日常编码中会使用tinyxml2库进行的一些操作，包括：解析xml文件或者xml格式内容的字符串、获取xml节点属性与内容、增加节点或属性、删除节点或属性、将doc对象保存为xml文件或者字符串、从一个文档拷贝节点到另一个文档中等。
本文以类似svg内容存储的数据来进行实例操作，以下为实例操作涉及到的数据。

<?xml version="1.0" encoding="UTF-8"?>
<draw width="200" height="100" version="1" original="true" author="FabianD" createtime="2021-04-08">
    <geometry id="1">
        <line x1="5" y1="5" x2="5" y2="10"/>
        <circle cx="5" cy="5" r="5"/>
    </geometry>
    <remark>势均力敌，才能生生不息</remark>
</draw>

2.构造数据并创建xml文件

 using namespace tinyxml2;
 XMLDocument doc;//定义doc对象
    
 //<1.增加xml文档声明
 //方式1
const char* declaration="<?xml version=\"1.0\" encoding=\"UTF-8\"?>";
XMLError result = doc.Parse(declaration);
//方式2，生成的内容同上
XMLDeclaration* declarationElement = doc.NewDeclaration();
doc.InsertFirstChild(declarationElement);

 //<2.添加节点
XMLElement* drawElement = doc.NewElement("draw");
doc.InsertEndChild(drawElement);

//<3.添加属性并设置属性值
drawElement->SetAttribute("width", 200.0);//double类型
drawElement->SetAttribute("height", 100.0);//double类型
drawElement->SetAttribute("version", 1);//int类型
drawElement->SetAttribute("original", true);//bool类型
std::string author = "FabianD";
drawElement->SetAttribute("author", author.c_str());//const char*类型
drawElement->SetAttribute("createtime", "2021-04-08");//const char*类型

//<4.添加子节点
XMLElement* geometryElement = doc.NewElement("");//暂不设置节点名称
geometryElement->SetName("geometry");//通过SetName函数设置节点名称
geometryElement->SetAttribute("id", 1);
drawElement->InsertEndChild(geometryElement);

 //添加直线节点至geometryElement
XMLElement* lineElement = doc.NewElement("line");
lineElement->SetAttribute("x1", 5);
lineElement->SetAttribute("y1", 5);
lineElement->SetAttribute("x2", 5);
lineElement->SetAttribute("y2", 10);
geometryElement->InsertEndChild(lineElement);

//添加圆节点至geometryElement
XMLElement* circleElement = doc.NewElement("circle");
circleElement->SetAttribute("cx", 5);
circleElement->SetAttribute("cy", 5);
circleElement->SetAttribute("r", 5);
geometryElement->InsertEndChild(circleElement);

//添加remarkElement至根节点
XMLElement* remarkElement = doc.NewElement("remark");
remarkElement->SetText("势均力敌，才能生生不息");//设置节点内容
drawElement->InsertEndChild(remarkElement);

//<5.保存至文件中
result = doc.SaveFile("Draw.xml");//会清除原来文件中的内容    

3.解析xml文件并读取数据

using namespace tinyxml2;
XMLDocument doc;
XMLError result;
//<1.加载解析文件
result = doc.LoadFile("Draw.xml");
if (result == XML_SUCCESS) {
    //<2.获取根节点
    XMLElement* drawElement = doc.RootElement();//获取根节点
    if (drawElement) {
        //<3.获取属性值
        //方式1
        double width = 0;
        result = drawElement->QueryDoubleAttribute("width", &width);
        if (result == XML_SUCCESS) {
            std::cout << "Width:" << width << std::endl;
        }else {
            std::cout << "根节点没有width属性" << std::endl;
        }
        //方式2
        const char* heightPtr = drawElement->Attribute("height");
        if (heightPtr) {
            double height = std::stod(heightPtr);//stod为新特性下的函数
            std::cout << "Height:" << height << std::endl;
        }else {
            std::cout << "根节点没有height属性" << std::endl;
        }
        //方式3
        int version = drawElement->IntAttribute("version", 0);//第二个参数为默认返回值，这种方式在找不到属性时会返回默认值，适合确定有属性存在的情况
        std::cout << "Version:" << version << std::endl;
        //获取其他类型属性值
        bool original = false;
        result = drawElement->QueryBoolAttribute("original", &original);
        if (result == XML_SUCCESS) {
            std::cout << "Original:" << original << std::endl;
        }
        const char* authorPtr = drawElement->Attribute("author");
        if (authorPtr) {
            std::cout << "Author:" << authorPtr << std::endl;
        }
        
        //<4.获取子节点
        XMLElement* geometryElement = drawElement->FirstChildElement("geometry");//传入节点名称
        if (geometryElement) {
            XMLElement* childElement = geometryElement->FirstChildElement();//不传入节点名称，返回第一个子节点
            //遍历获取子节点
        	while (childElement) {
	            if (!std::strcmp(childElement->Name(), "line")) {
	                //获取直线节点相关属性
	                double x1 = childElement->DoubleAttribute("x1");
	                double y1 = childElement->DoubleAttribute("y1");
	                std::cout << "LineX1:" << x1 << std::endl;
	                //...
	             }else if (!std::strcmp(childElement->Name(), "circle")) {
	                //获取圆节点相关属性
	                double cx = childElement->DoubleAttribute("cx");
	                double cy = childElement->DoubleAttribute("cy");
	                std::cout << "CircleCx:" << cx << std::endl;
	                //...
	            }
	            childElement = childElement->NextSiblingElement();//获取同一级的下一节点
    	   }
	  	}
      	//获取remark子节点
       XMLElement* remarkElement = drawElement->FirstChildElement("remark");
       if (remarkElement) {
          const char* remark = remarkElement->GetText();//获取节点内容
          std::cout << "Remark:" << remark << std::endl;
       }

       //<5.修改节点
       //修改节点属性值及内容
       if (remarkElement) {
          remarkElement->SetText("至死不渝");
          remarkElement->SetAttribute("type", "love");
       }
       //删除属性及节点
       drawElement->DeleteAttribute("version");//删除version属性
       geometryElement->DeleteChild(geometryElement->FirstChildElement("line"));//删除line节点
       //geometryElement->DeleteChildren();//删除所有子节点
       doc.SaveFile("Draw.xml");//重新保存
       }else {
        std::cout << "文件没有根节点" << std::endl;
      }
}else { 
    std::cout << "解析失败：" << result << std::endl;
}

4.其他一些操作

using namespace tinyxml2;
XMLDocument doc;
XMLError result = doc.LoadFile("Draw.xml");
if (result == XML_SUCCESS) {
    //<1.读取xml文件内容至const char*中
    XMLPrinter printer;
    doc.Print(&printer);
    const char* contentPtr = printer.CStr();
    std::cout << "xml content:" << contentPtr << std::endl;

    //<2.解析字符串内容
    XMLDocument docx;
    result = docx.Parse(contentPtr);
    if(result==XML_SUCCESS){
        if (docx.RootElement()) {
            std::cout << docx.RootElement()->Name();
        }
    }

    //<3.复制doc中的节点到另一个doc中
    XMLDocument docTarget;
    result = docTarget.LoadFile("Draw.xml");
    if (result == XML_SUCCESS) {
        XMLElement* drawElementSource = doc.RootElement();
        XMLElement* drawElementTarget = docTarget.RootElement();
        if (drawElementTarget) {
            XMLElement* geometryElementTarget = drawElementTarget->FirstChildElement("geometry");
            if (geometryElementTarget) {
                XMLNode* geometryElementSource = geometryElementTarget->DeepClone(&doc);//复制节点到新doc中
                drawElementSource->InsertFirstChild(geometryElementSource);//执行插入操作
                result = doc.SaveFile("Draw.xml");
            }
        }
    }
}

5.总结

tinyxml2经常用到的几个对象：

1.tinyxml2::XMLNode：XMLDocment、XMLElement的基类

• XMLNode* InsertFirstChild(XMLNode* node)： 在对象(文档/节点)最前面插入节点node。
• XMLNode* InsertEndChild(XMLNode* node)： 在对象(文档/节点)最后面插入节点node。
• XMLNode* InsertAfterChild(XMLNode* afterNode,XMLNode* node)： 在节点afterNode后面插入节点node。
• void DeleteChild(XMLNode*)： 删除子节点node。
• void DeleteChildren()： 删除所有子节点。
• static void DeleteChild(XMLNode*)： 删除节点node。
• XMLNode* DeepClone(XMLDocument* target)： 拷贝一份数据到target文档中，返回有同样数据的XMLNode*。
• XMLElement* FirstChildElement(const char* name==NULL)： 获取对象(文档/节点)下节点名称为name的第一个子节点。
• XMLElement* LastChildElement(const char* name==NULL)： 获取对象(文档/节点)下节点名称为name的最后一个子节点。
• XMLNode* Parent()： 获取(文档/节点)的父节点。
• XMLElement* NextSiblingElement(const char* name==NULL)： 获取对象(文档/节点)同级中往后名称为name的节点。
• XMLElement* PreviousSiblingElement(const char* name==NULL)： 获取对象(文档/节点)同级中往前名称为name的节点。

2.tinyxml2::XMLDocument：

• XMLError LoadFile(const char*)： 用来加载解析xml文件。
• XMLError SaveFile(const char*)： 用来保存数据至xml文件。
• XMLError Parse(const char*)： 用来解析字符串内容。
• XMLDeclaration* NewDeclaration()： 用来创建doc的文档声明，创建后，还需要将其插入XMLDocument对象中才有作用。
• XMLElement* NewElement()： 用来创建doc的节点，创建后，还需要将其插入XMLDocument对象中才有作用。

3.tinyxml2::XMLElement：

• void SetAttribute(const char*, T value)： 设置属性，T可以是任意基础类型。
• void SetName( const char* str, bool staticMem=false )： 设置节点名称。
• XMLError QueryIntAttribute( const char* name, int* value )： 获取名称为name，type为int的属性的值，如果该值不是int类型，返回值将不是XML_SUCCESS。同类型的函数还有：QueryDoubleAttribute、QueryBoolAttribute等。
• const char* XMLElement::Attribute( const char* name, const char* value )： 获取名称为name的属性值，如果没有该属性，则返回默认值value。
• int IntAttribute(const char* name, int defaultValue)： 获取名称为name的属性值，如果没有该属性，则返回默认值defaultValue。