来源：http://www.blogjava.net/wxb_nudt/archive/2007/11/18/161340.html
这篇文章很详细的介绍了Libxml2操作XML文档的使用方法，很是有用，转帖收藏了，谢谢作者。
文章如下：
写这篇文章的原因有如下几点： 1)C++ 标准库中没有操作 XML 的方法，用 C++ 操作 XML 文件必须熟悉一种函数库， LIBXML2 是其中一种很优秀的 XML 库，而且它同时支持多种编程语言； 2)LIBXML2 库的 Tutorial 写得不太好，尤其是编码转换的部分，不适用于中文编码的转换； 3) 网上的大多数关于 Libxml2 的介绍仅仅是翻译了自带的资料，没有详细介绍如何在 windows 平台下进行编程，更很少提到如何解决中文问题。
基于以上几点原因，决定写一个在 Windows 平台下，使用 C/C++ 语言，应用 LibXml2 库来进行 xml 文档操作，同时使用 ICONV 库进行中文编码转换的文档。其中还涉及了 Makefile 、 XPATH 等相关内容。本文中所有的源代码在 http://www.blogjava.net/Files/wxb_nudt/xml_src.rar 。
1. 下载与安装 LIBXML2 和 ICONV
Libxml2 是一个 C 语言的 XML 程序库，可以简单方便的提供对 XML 文档的各种操作，并且支持 XPATH 查询，以及部分的支持 XSLT 转换等功能。 Libxml2 的下载地址是 http://xmlsoft.org/ ，完全版的库是开源的，并且带有例子程序和说明文档。最好将这个库先下载下来，因为这样可以查看其中的文档和例子。
windows 版本的的下载地址是 http://www.zlatkovic.com/libxml.en.html ；这个版本只提供了头文件、库文件和 dll ，不包含源代码、例子程序和文档。在文本中，只需要下载 libxml2 库、 iconv 库和 zlib 库就行了（注意， libxml2 库依赖 iconv 和 zlib 库，本文中重点关注 libxml2 和 iconv ， zlib 不介绍），我使用的版本是 libxml2-2.6.30.win32.zip 、 zlib-1.2.3.win32.zip 和 iconv-1.9.2.win32.zip 。
在编程的时候，我们使用 windows 版本的 libxml2 、 zlib 和 iconv ，将其解压缩到指定文件夹，例如 D:"libxml2-2.6.30.win32 ， D:"zlib-1.2.3.win32 以及 D:"iconv-1.9.2.win32 。事实上，我们知道在 windows 下面使用头文件、库文件和 dll 是不需要安装的，它又没有使用任何需要注册的组件或者数据库，只需要告诉编译器和链接器这些资源的位置就可以了。
注意：要在 path 变量中加上 D:"iconv-1.9.2.win32"bin;D:"zlib-1.2.3.win32"bin;D:"libxml2-2.6.30.win32"bin 这三个地址，否则在执行的时候就找不到。或者使用更简单的方法，把其中的三个 dll 到拷贝到 system32 目录中。
有两种方法来编译链接基于 libxml2 的程序，第一种是在 VC 环境中设置 lib 和 include 路径，并在 link 设置中添加 libxml2.lib 和 iconv.lib ；第二种是用编译器选项告诉编译器 cl.exe 头文件的位置，并用链接器选项告诉链接器 link.exe 库文件的位置，同时在 windows 环境变量 path 中添加 libxml2 中 bin 文件夹的位置，以便于程序运行时可以找到 dll （也可以将 dll 拷贝到 system32 目录下）。显然我选择了第二种，那么编译链接一个名为 CreateXmlFile.cpp 源文件的命令如下：
cl /c /I D:"iconv-1.9.2.win32"include /I D:"libxml2-2.6.30.win32"include CreateXmlFile.cpp
link /libpath:D:"iconv-1.9.2.win32"lib /libpath:D:"libxml2-2.6.30.win32"lib CreateXmlFile.obj iconv.lib libxml2.lib
显然这样很费时，那么再不用 makefile 就显得矫情了，于是，一个典型的使用 nmake.exe （ VC 自带的 makefile 工具）的文件如下： MAKEFILE
#
# 本目录下所有源代码的 makefile ，使用方法是 nmake TARGET_NAME= 源代码文件名字（不加后缀）
# 例如 nmake TARGET_NAME=CreateXmlFile
# Author: Wang Xuebin
#
# Flags - 编译 debug 版本
#
# 指定要使用的库的路径 , 需要用户修改的变量一般放在 makefile 文件的最上面
LIBXML2_HOME = D:"libxml2-2.6.30.win32
ICONV_HOME = D:"iconv-1.9.2.win32
# 指定编译器选项 ,/c 表明 cl 命令只编译不链接 ;/MTd 表明使用多线程 debug 库 ;/Zi 表明产生完整的调试信息 ;
#/Od 表明关闭编译优化 ;/D _DEBUG 表明定义一个名为 _DEBUG 的宏
CPP_FLAGS=/c /MTd /Zi /Od /D _DEBUG
# 链接选项 ,/DEBUG 表明创建 Debug 信息
EXE_LINK_FLAGS=/DEBUG
# 指定链接的库
LIBS=iconv.lib libxml2.lib
# 指定编译路径选项 , 链接路径选项
INCLUDE_FLAGS= /I $(LIBXML2_HOME)"include /I $(ICONV_HOME)"include
LIB_PATH_FLAGS = /libpath:$(ICONV_HOME)"lib /libpath:$(LIBXML2_HOME)"lib
#################################################
#
# Targets 目标
#
$(TARGET_NAME) : $(TARGET_NAME).exe
clean : $(TARGET_NAME).exe
$(TARGET_NAME).obj : $(TARGET_NAME).cpp
cl $(CPP_FLAGS) $(INCLUDE_FLAGS) $(TARGET_NAME).cpp
$(TARGET_NAME).exe : $(TARGET_NAME).obj
link $(EXE_LINK_FLAGS) $(LIB_PATH_FLAGS) $(TARGET_NAME).obj $(LIBS)
clean : $(TARGET_NAME).exe
del $(TARGET_NAME).exe
del $(TARGET_NAME).obj
del $(TARGET_NAME).ilk
del $(TARGET_NAME).pdb
本文不准备介绍 makefile 的写法，但后续例子程序的编译链接依葫芦画瓢都没有问题，执行编译链接的命令如下：
nmake TARGET_NAME=CreateXmlFile
执行清理的命令如下：
nmake TARGET_NAME=CreateXmlFile clean
2. Libxml2 中的数据类型和函数
一个函数库中可能有几百种数据类型以及几千个函数，但是记住大师的话， 90% 的功能都是由 30% 的内容提供的。对于 libxml2 ，我认为搞懂以下的数据类型和函数就足够了。
2.1 内部字符类型 xmlChar
xmlChar 是 Libxml2 中的字符类型，库中所有字符、字符串都是基于这个数据类型。事实上它的定义是： xmlstring.h
typedef unsigned char xmlChar;
使用 unsigned char 作为内部字符格式是考虑到它能很好适应 UTF-8 编码，而 UTF-8 编码正是 libxml2 的内部编码，其它格式的编码要转换为这个编码才能在 libxml2 中使用。
还经常可以看到使用 xmlChar* 作为字符串类型，很多函数会返回一个动态分配内存的 xmlChar* 变量，使用这样的函数时记得要手动删除内存。
2.2 xmlChar 相关函数
如同标准 c 中的 char 类型一样， xmlChar 也有动态内存分配、字符串操作等相关函数。例如 xmlMalloc 是动态分配内存的函数； xmlFree 是配套的释放内存函数； xmlStrcmp 是字符串比较函数等等。
基本上 xmlChar 字符串相关函数都在 xmlstring.h 中定义；而动态内存分配函数在 xmlmemory.h 中定义。
2.3 xmlChar* 与其它类型之间的转换
另外要注意，因为总是要在 xmlChar* 和 char* 之间进行类型转换，所以定义了一个宏 BAD_CAST ，其定义如下： xmlstring.h
#define BAD_CAST (xmlChar *)
原则上来说， unsigned char 和 char 之间进行强制类型转换是没有问题的。
2.4 文档类型 xmlDoc 、指针 xmlDocPtr
xmlDoc 是一个 struct ，保存了一个 xml 的相关信息，例如文件名、文档类型、子节点等等； xmlDocPtr 等于 xmlDoc* ，它搞成这个样子总让人以为是智能指针，其实不是，要手动删除的。
xmlNewDoc 函数创建一个新的文档指针。
xmlParseFile 函数以默认方式读入一个 UTF-8 格式的文档，并返回文档指针。
xmlReadFile 函数读入一个带有某种编码的 xml 文档，并返回文档指针；细节见 libxml2 参考手册。
xmlFreeDoc 释放文档指针。 特别注意，当你调用 xmlFreeDoc 时，该文档所有包含的节点内存都被释放，所以一般来说不需要手动调用 xmlFreeNode 或者 xmlFreeNodeList 来释放动态分配的节点内存，除非你把该节点从文档中移除了。一般来说，一个文档中所有节点都应该动态分配，然后加入文档，最后调用 xmlFreeDoc 一次释放所有节点申请的动态内存，这也是为什么我们很少看见 xmlNodeFree 的原因。
xmlSaveFile 将文档以默认方式存入一个文件。
xmlSaveFormatFileEnc 可将文档以某种编码 / 格式存入一个文件中。
2.5 节点类型 xmlNode 、指针 xmlNodePtr
节点应该是 xml 中最重要的元素了， xmlNode 代表了 xml 文档中的一个节点，实现为一个 struct ，内容很丰富： tree.h
typedef struct _xmlNode xmlNode;
typedef xmlNode *xmlNodePtr;
struct _xmlNode {
void *_private;/* application data */
xmlElementType type; /* type number, must be second ! */
const xmlChar *name; /* the name of the node, or the entity */
struct _xmlNode *children; /* parent->childs link */
struct _xmlNode *last; /* last child link */
struct _xmlNode *parent;/* child->parent link */
struct _xmlNode *next; /* next sibling link */
struct _xmlNode *prev; /* previous sibling link */
struct _xmlDoc *doc;/* the containing document */
/* End of common part */
xmlNs *ns; /* pointer to the associated namespace */
xmlChar *content; /* the content */
struct _xmlAttr *properties;/* properties list */
xmlNs *nsDef; /* namespace definitions on this node */
void *psvi;/* for type/PSVI informations */
unsigned short line; /* line number */
unsigned short extra; /* extra data for XPath/XSLT */
};
可以看到，节点之间是以链表和树两种方式同时组织起来的， next 和 prev 指针可以组成链表，而 parent 和 children 可以组织为树。同时还有以下重要元素：
l 节点中的文字内容： content ；
l 节点所属文档： doc ；
l 节点名字： name ；
l 节点的 namespace ： ns ；
l 节点属性列表： properties ；
Xml 文档的操作其根本原理就是在节点之间移动、查询节点的各项信息，并进行增加、删除、修改的操作。
xmlDocSetRootElement 函数可以将一个节点设置为某个文档的根节点，这是将文档与节点连接起来的重要手段，当有了根结点以后，所有子节点就可以依次连接上根节点，从而组织成为一个 xml 树。
2.6 节点集合类型 xmlNodeSet 、指针 xmlNodeSetPtr
节点集合代表一个由节点组成的变量，节点集合只作为 Xpath 的查询结果而出现（ XPATH 的介绍见后面），因此被定义在 xpath.h 中，其定义如下：
/*
* A node-set (an unordered collection of nodes without duplicates).
*/
typedef struct _xmlNodeSet xmlNodeSet;
typedef xmlNodeSet *xmlNodeSetPtr;
struct _xmlNodeSet {
int nodeNr; /* number of nodes in the set */
int nodeMax; /* size of the array as allocated */
xmlNodePtr *nodeTab;/* array of nodes in no particular order */
/* @@ with_ns to check wether namespace nodes should be looked at @@ */
};
可以看出，节点集合有三个成员，分别是节点集合的节点数、最大可容纳的节点数，以及节点数组头指针。对节点集合中各个节点的访问方式很简单，如下：
xmlNodeSetPtr nodeset = XPATH 查询结果 ;
for (int i = 0; i < nodeset->nodeNr; i++)
{
nodeset->nodeTab[i];
}
注意， libxml2 是一个 c 函数库，因此其函数和数据类型都使用 c 语言的方式来处理。如果是 c++ ，我想我宁愿用 STL 中的 vector 来表示一个节点集合更好，而且没有内存泄漏或者溢出的担忧。
3. 简单 xml 操作例子
了解以上基本知识之后，就可以进行一些简单的 xml 操作了。当然，还没有涉及到内码转换（使得 xml 中可以处理中文）、 xpath 等较复杂的操作。
3.1 创建 xml 文档
有了上面的基础，创建一个 xml 文档显得非常简单，其流程如下：
l 用 xmlNewDoc 函数创建一个文档指针 doc ；
l 用 xmlNewNode 函数创建一个节点指针 root_node ；
l 用 xmlDocSetRootElement 将 root_node 设置为 doc 的根结点；
l 给 root_node 添加一系列的子节点，并设置子节点的内容和属性；
l 用 xmlSaveFile 将 xml 文档存入文件；
l 用 xmlFreeDoc 函数关闭文档指针，并清除本文档中所有节点动态申请的内存。
注意，有多种方式可以添加子节点：第一是用 xmlNewTextChild 直接添加一个文本子节点；第二是先创建新节点，然后用 xmlAddChild 将新节点加入上层节点。
源代码文件是 CreateXmlFile.cpp ，如下：
/********************************************************************
created: 2007/11/09
created: 9:11:2007 15:34
filename: CreateXmlFile.cpp
author: Wang xuebin
depend: libxml2.lib
build: nmake TARGET_NAME=CreateXmlFile
purpose: 创建一个 xml 文件
*********************************************************************/
#include <stdio.h>
#include <libxml/parser.h>
#include <libxml/tree.h>
#include <iostream.h>
int main()
{
// 定义文档和节点指针
xmlDocPtr doc = xmlNewDoc(BAD_CAST"1.0");
xmlNodePtr root_node = xmlNewNode(NULL,BAD_CAST"root");
// 设置根节点
xmlDocSetRootElement(doc,root_node);
// 在根节点中直接创建节点
xmlNewTextChild(root_node, NULL, BAD_CAST "newNode1", BAD_CAST "newNode1 content");
xmlNewTextChild(root_node, NULL, BAD_CAST "newNode2", BAD_CAST "newNode2 content");
xmlNewTextChild(root_node, NULL, BAD_CAST "newNode3", BAD_CAST "newNode3 content");
// 创建一个节点，设置其内容和属性，然后加入根结点
xmlNodePtr node = xmlNewNode(NULL,BAD_CAST"node2");
xmlNodePtr content = xmlNewText(BAD_CAST"NODE CONTENT");
xmlAddChild(root_node,node);
xmlAddChild(node,content);
xmlNewProp(node,BAD_CAST"attribute",BAD_CAST "yes");
// 创建一个儿子和孙子节点
node = xmlNewNode(NULL, BAD_CAST "son");
xmlAddChild(root_node,node);
xmlNodePtr grandson = xmlNewNode(NULL, BAD_CAST "grandson");
xmlAddChild(node,grandson);
xmlAddChild(grandson, xmlNewText(BAD_CAST "This is a grandson node"));
// 存储 xml 文档
int nRel = xmlSaveFile("CreatedXml.xml",doc);
if (nRel != -1)
{
cout<<" 一个 xml 文档被创建 , 写入 "<<nRel<<" 个字节 "<<endl;
}
// 释放文档内节点动态申请的内存
xmlFreeDoc(doc);
return 1;
}
编译链接命令如下：
nmake TARGET_NAME=CreateXmlFile
然后执行可执行文件 CreateXmlFile.exe ，会生成一个 xml 文件 CreatedXml.xml ，打开后如下所示：
<?xml version="1.0"?>
< root >
< newNode1 > newNode1 content </ newNode1 >
< newNode2 > newNode2 content </ newNode2 >
< newNode3 > newNode3 content </ newNode3 >
< node2 attribute =" yes "> NODE CONTENT </ node2 >
< son >
< grandson > This is a grandson node </ grandson >
</ son >
</ root >
最好使用类似 XMLSPY 这样的工具打开，因为这些工具可以自动整理 xml 文件的栅格，否则很有可能是没有任何换行的一个 xml 文件，可读性较差。
3.2 解析 xml 文档
解析一个 xml 文档，从中取出想要的信息，例如节点中包含的文字，或者某个节点的属性，其流程如下：
l 用 xmlReadFile 函数读出一个文档指针 doc ；
l 用 xmlDocGetRootElement 函数得到根节点 curNode ；
l curNode->xmlChildrenNode 就是根节点的子节点集合；
l 轮询子节点集合，找到所需的节点，用 xmlNodeGetContent 取出其内容；
l 用 xmlHasProp 查找含有某个属性的节点；
l 取出该节点的属性集合，用 xmlGetProp 取出其属性值；
l 用 xmlFreeDoc 函数关闭文档指针，并清除本文档中所有节点动态申请的内存。
注意：节点列表的指针依然是 xmlNodePtr ，属性列表的指针也是 xmlAttrPtr ，并没有 xmlNodeList 或者 xmlAttrList 这样的类型。看作列表的时候使用它们的 next 和 prev 链表指针来进行轮询。只有在 Xpath 中有 xmlNodeSet 这种类型，其使用方法前面已经介绍了。
源代码如下： ParseXmlFile.cpp
/********************************************************************
created: 2007/11/15
created: 15:11:2007 11:47
filename: ParseXmlFile.cpp
author: Wang xuebin
depend: libxml2.lib
build: nmake TARGET_NAME=ParseXmlFile
purpose: 解析 xml 文件
*********************************************************************/
#include <libxml/parser.h>
#include <iostream.h>
int main(int argc, char* argv[])
{
xmlDocPtr doc; // 定义解析文档指针
xmlNodePtr curNode; // 定义结点指针 ( 你需要它为了在各个结点间移动 )
xmlChar *szKey; // 临时字符串变量
char *szDocName;
if (argc <= 1)
{
printf("Usage: %s docname"n", argv[0]);
return(0);
}
szDocName = argv[1];
doc = xmlReadFile(szDocName,"GB2312",XML_PARSE_RECOVER); // 解析文件
// 检查解析文档是否成功，如果不成功， libxml 将指一个注册的错误并停止。
// 一个常见错误是不适当的编码。 XML 标准文档除了用 UTF-8 或 UTF-16 外还可用其它编码保存。
// 如果文档是这样， libxml 将自动地为你转换到 UTF-8 。更多关于 XML 编码信息包含在 XML 标准中 .
if (NULL == doc)
{
fprintf(stderr,"Document not parsed successfully. "n");
return -1;
}
curNode = xmlDocGetRootElement(doc); // 确定文档根元素
/* 检查确认当前文档中包含内容 */
if (NULL == curNode)
{
fprintf(stderr,"empty document"n");
xmlFreeDoc(doc);
return -1;
}
/* 在这个例子中，我们需要确认文档是正确的类型。“ root ”是在这个示例中使用文档的根类型。 */
if (xmlStrcmp(curNode->name, BAD_CAST "root"))
{
fprintf(stderr,"document of the wrong type, root node != root");
xmlFreeDoc(doc);
return -1;
}
curNode = curNode->xmlChildrenNode;
xmlNodePtr propNodePtr = curNode;
while(curNode != NULL)
{
// 取出节点中的内容
if ((!xmlStrcmp(curNode->name, (const xmlChar *)"newNode1")))
{
szKey = xmlNodeGetContent(curNode);
printf("newNode1: %s"n", szKey);
xmlFree(szKey);
}
// 查找带有属性 attribute 的节点
if (xmlHasProp(curNode,BAD_CAST "attribute"))
{
propNodePtr = curNode;
}
curNode = curNode->next;
}
// 查找属性
xmlAttrPtr attrPtr = propNodePtr->properties;
while (attrPtr != NULL)
{
if (!xmlStrcmp(attrPtr->name, BAD_CAST "attribute"))
{
xmlChar* szAttr = xmlGetProp(propNodePtr,BAD_CAST "attribute");
cout<<"get attribute = "<<szAttr<<endl;
xmlFree(szAttr);
}
attrPtr = attrPtr->next;
}
xmlFreeDoc(doc);
return 0;
}
编译链接命令如下：
nmake TARGET_NAME=ParseXmlFile
执行命令如下，使用第一次创建的 xml 文件作为输入：
ParseXmlFile.exe CreatedXml.xml
观察源代码可发现，所有以查询方式得到的 xmlChar* 字符串都必须使用 xmlFree 函数手动释放。否则会造成内存泄漏。
3.3 修改 xml 文档
有了上面的基础，修改 xml 文档的内容就很简单了。首先打开一个已经存在的 xml 文档，顺着根结点找到需要添加、删除、修改的地方，调用相应的 xml 函数对节点进行增、删、改操作。源代码见 ChangeXmlFile ，编译链接方法如上。执行下面的命令：
ChangeXmlFile.exe CreatedXml.xml
可以得到一个修改后的 xml 文档 ChangedXml.xml ，如下：
<?xml version="1.0"?>
< root >
< newNode2 > content changed </ newNode2 >
< newNode3 newAttr =" YES "> newNode3 content </ newNode3 >
< node2 attribute =" no "> NODE CONTENT </ node2 >
< son >
< grandson > This is a grandson node </ grandson >
< newGrandSon > new content </ newGrandSon >
</ son >
</ root >
需要注意的是，并没有 xmlDelNode 或者 xmlRemoveNode 函数，我们删除节点使用的是以下一段代码：
if (!xmlStrcmp(curNode->name, BAD_CAST "newNode1"))
{
xmlNodePtr tempNode;
tempNode = curNode->next;
xmlUnlinkNode(curNode);
xmlFreeNode(curNode);
curNode = tempNode;
continue;
}
即将当前节点从文档中断链（ unlink ），这样本文档就不会再包含这个子节点。这样做需要使用一个临时变量来存储断链节点的后续节点，并记得要手动删除断链节点的内存。
3.4 使用 XPATH 查找 xml 文档
简而言之， XPATH 之于 xml ，好比 SQL 之于关系数据库。要在一个复杂的 xml 文档中查找所需的信息， XPATH 简直是必不可少的工具。 XPATH 语法简单易学，并且有一个很好的官方教程，见 http://www.zvon.org/xxl/XPathTutorial/Output_chi/introduction.html 。这个站点的XML各种教程齐全，并且有包括中文在内的各国语言版本，真是让我喜欢到非常！
使用 XPATH 之前，必须首先熟悉几个数据类型和函数，它们是使用 XPATH 的前提。在 libxml2 中使用 Xpath 是非常简单的，其流程如下：
l 定义一个 XPATH 上下文指针 xmlXPathContextPtr context ，并且使用 xmlXPathNewContext 函数来初始化这个指针；
l 定义一个 XPATH 对象指针 xmlXPathObjectPtr result ，并且使用 xmlXPathEvalExpression 函数来计算 Xpath 表达式，得到查询结果，将结果存入对象指针中；
l 使用 result->nodesetval 得到节点集合指针，其中包含了所有符合 Xpath 查询结果的节点；
l 使用 xmlXPathFreeContext 释放上下文指针；
l 使用 xmlXPathFreeObject 释放 Xpath 对象指针；
具体的使用方法可以看 XpathForXmlFile.cpp 的这一段代码，其功能是查找符合某个 Xpath 语句的对象指针：
xmlXPathObjectPtr getNodeSet(xmlDocPtr doc, const xmlChar *szXpath)
{
xmlXPathContextPtr context; //XPATH 上下文指针
xmlXPathObjectPtr result; //XPATH 对象指针，用来存储查询结果
context = xmlXPathNewContext(doc); // 创建一个 XPath 上下文指针
if (context == NULL)
{
printf("context is NULL"n");
return NULL;
}
result = xmlXPathEvalExpression(szXpath, context); // 查询 XPath 表达式，得到一个查询结果
xmlXPathFreeContext(context); // 释放上下文指针
if (result == NULL)
{
printf("xmlXPathEvalExpression return NULL"n");
return NULL;
}
if (xmlXPathNodeSetIsEmpty(result->nodesetval)) // 检查查询结果是否为空
{
xmlXPathFreeObject(result);
printf("nodeset is empty"n");
return NULL;
}
return result;
}
一个完整的使用 Xpath 的例子在代码 XpathForXmlFile.cpp 中，它查找一个 xml 文件中符合 "/root/node2[@attribute='yes']" 语句的结果，并且将找到的节点的属性和内容打印出来。编译链接命令如下：
nmake TARGET_NAME=XpathForXmlFile
执行方式如下：
XpathForXmlFile.exe CreatedXml.xml
观察结果可以看出找到了一个节点，即 root 下面 node2 节点，它的 attribute 属性值正好等于 yes 。更多关于 Xpath 的内容可以参考 XPATH 官方手册。只有掌握了 XPATH ，才掌握了使用大型 XML 文件的方法，否则每寻找一个节点都要从根节点找起，会把人累死。
4. 用 ICONV 解决 XML 中的中文问题
Libxml2 中默认的内码是 UTF-8 ，所有使用 libxml2 进行处理的 xml 文件，必须首先显式或者默认的转换为 UTF-8 编码才能被处理。
要在 xml 中使用中文，就必须能够在 UTF-8 和 GB2312 内码（较常用的一种简体中文编码）之间进行转换。 Libxml2 提供了默认的内码转换机制，并且在 libxml2 的 Tutorial 中有一个例子，事实证明这个例子并不适合用来转换中文。
所以需要我们显式的使用 ICONV 来进行内码转换， libxml2 本身也是使用 ICONV 进行转换的。 ICONV 是一个专门用来进行编码转换的库，基本上支持目前所有常用的编码。它是 glibc 库的一个部分，常常被用于 UNIX 系统中。当然，在 windows 下面使用也没有任何问题。前面已经提到了 ICONV 的安装和使用方法，这里主要讲一下编程相关问题。
本节其实和 xml 以及 libxml2 没有太大关系，你可以把它简单看作是一个编码转换方面的专题。我们仅仅需要学会使用两个函数就可以了，即从 UTF-8 转换到 GB2312 的函数 u2g ，以及反向转换的函数 g2u ，源代码在 wxb_codeConv.c 中：
/********************************************************************
created: 2007/11/15
created: 15:11:2007 10:30
filename: wxb_codeConv.c
author: Wang xuebin
depend: iconv.lib
build: 不需要 build ，被包含到其它源代码中
purpose: 提供从 UTF-8 到 GB2312 的内码转换，以及反向的转换
*********************************************************************/
#include "iconv.h"
#include <string.h>
// 代码转换 : 从一种编码转为另一种编码
int code_convert(char* from_charset, char* to_charset, char* inbuf,
int inlen, char* outbuf, int outlen)
{
iconv_t cd;
char** pin = &inbuf;
char** pout = &outbuf;
cd = iconv_open(to_charset,from_charset);
if(cd == 0)
return -1;
memset(outbuf,0,outlen);
if(iconv(cd,(const char**)pin,(unsigned int *)&inlen,pout,(unsigned int*)&outlen)
== -1)
return -1;
iconv_close(cd);
return 0;
}
//UNICODE 码转为 GB2312 码
// 成功则返回一个动态分配的 char* 变量，需要在使用完毕后手动 free ，失败返回 NULL
char* u2g(char *inbuf)
{
int nOutLen = 2 * strlen(inbuf) - 1;
char* szOut = (char*)malloc(nOutLen);
if (-1 == code_convert("utf-8","gb2312",inbuf,strlen(inbuf),szOut,nOutLen))
{
free(szOut);
szOut = NULL;
}
return szOut;
}
//GB2312 码转为UNICODE码
// 成功则返回一个动态分配的 char* 变量，需要在使用完毕后手动 free ，失败返回 NULL
char* g2u(char *inbuf)
{
int nOutLen = 2 * strlen(inbuf) - 1;
char* szOut = (char*)malloc(nOutLen);
if (-1 == code_convert("gb2312","utf-8",inbuf,strlen(inbuf),szOut,nOutLen))
{
free(szOut);
szOut = NULL;
}
return szOut;
}
使用的时候将这个 c 文件 include 到其它源文件中。 include 一个 c 文件并不奇怪，在 c 语言的年代我们常常这么干，唯一的害处的编译链接出来的可执行程序体积变大了。当然这时因为我们这段代码很小的原因，再大一点我就要用 dll 了。
从 UTF-8 到 GB2312 的一个典型使用流程如下：
l 得到一个 UTF-8 的字符串 szSrc ；
l 定义一个 char* 的字符指针 szDes ，并不需要给他动态审判内存；
l szDes = u2g(szSrc) ，这样就可以得到转换后的 GB2312 编码的字符串；
l 使用完这个字符串后使用 free(szDes) 来释放内存。
本文并不准备讲述 iconv 中的函数细节，因为那几个函数以及数据类型都非常简单，我们还是重点看一下如何在 libxml2 中使用编码转换来处理带有中文的 xml 文件。下面是使用以上方法来创建一个带有中文的 XML 文件的例子程序 CreateXmlFile_cn.cpp ，源代码如下：
/********************************************************************
created: 2007/11/17
created: 9:11:2007 15:34
filename: CreateXmlFile.cpp
author: Wang xuebin
depend: libxml2.lib iconv.lib
build: nmake TARGET_NAME=CreateXmlFile_cn
purpose: 创建一个 xml 文件，其中包含中文
*********************************************************************/
#include <stdio.h>
#include <libxml/parser.h>
#include <libxml/tree.h>
#include <iostream.h>
#include "wxb_codeConv.c" // 自己写的编码转换函数
int main(int argc, char **argv)
{
// 定义文档和节点指针
xmlDocPtr doc = xmlNewDoc(BAD_CAST"1.0");
xmlNodePtr root_node = xmlNewNode(NULL,BAD_CAST"root");
// 设置根节点
xmlDocSetRootElement(doc,root_node);
// 一个中文字符串转换为 UTF-8 字符串，然后写入
char* szOut = g2u(" 节点 1 的内容 ");
// 在根节点中直接创建节点
xmlNewTextChild(root_node, NULL, BAD_CAST "newNode1", BAD_CAST "newNode1 content");
xmlNewTextChild(root_node, NULL, BAD_CAST "newNode2", BAD_CAST "newNode2 content");
xmlNewTextChild(root_node, NULL, BAD_CAST "newNode3", BAD_CAST "newNode3 content");
xmlNewChild(root_node, NULL, BAD_CAST "node1",BAD_CAST szOut);
free(szOut);
// 创建一个节点，设置其内容和属性，然后加入根结点
xmlNodePtr node = xmlNewNode(NULL,BAD_CAST"node2");
xmlNodePtr content = xmlNewText(BAD_CAST"NODE CONTENT");
xmlAddChild(root_node,node);
xmlAddChild(node,content);
szOut = g2u(" 属性值 ");
xmlNewProp(node,BAD_CAST"attribute",BAD_CAST szOut);
free(szOut);
// 创建一个中文节点
szOut = g2u(" 中文节点 ");
xmlNewChild(root_node, NULL, BAD_CAST szOut,BAD_CAST "content of chinese node");
free(szOut);
// 存储 xml 文档
int nRel = xmlSaveFormatFileEnc("CreatedXml_cn.xml",doc,"GB2312",1);
if (nRel != -1)
{
cout<<" 一个 xml 文档被创建 , 写入 "<<nRel<<" 个字节 "<<endl;
}
xmlFreeDoc(doc);
return 1;
}
编译链接命令如下：
nmake TARGET_NAME=CreateXmlFile_cn
完成后执行 CreateXmlFile_cn.exe 可以生成一个 xml 文件 CreatedXml_cn.xml ，其内容如下：
<?xml version="1.0" encoding="GB2312"?>
< root >
< newNode1 > newNode1 content </ newNode1 >
< newNode2 > newNode2 content </ newNode2 >
< newNode3 > newNode3 content </ newNode3 >
< node1 > 节点 1 的内容 </ node1 >
< node2 attribute =" 属性值 "> NODE CONTENT </ node2 >
< 中文节点 > content of chinese node </ 中文节点 >
</ root >
观察可知，节点的名称、内容、属性都可以使用中文了。在解析、修改和查找 XML 文档时都可以使用上面的方法，只要记住，进入 xml 文档之前将中文编码转换为 UTF-8 编码；从 XML 中取出数据时，不管三七二十一都可以转换为 GB2312 再用，否则你很有可能见到传说中的乱码！
5. 用 XML 来做点什么
有了以上的基础，相信已经可以顺利的在 c/c++ 程序中使用 XML 文档了。那么，我们到底要用 XML 来做什么呢？我随便说一说自己的想法：
第一，可以用来作为配置文件。例如很多组件就是用 XML 来做配置文件；当然，我们知道用 INI 做配置文件更简单，只要熟悉两个函数就可以了；不过，复杂一点的配置文件我还是建议采用 XML ；
第二，可以用来作为在程序之间传送数据的格式，这样的话最好给你的 xml 先定义一个 XML Schema ，这样的数据首先可以做一个良构校验，还可以来一个 Schema 校验，如此的话出错率会比没有格式的数据小得多。目前 XML 已经广泛作为网络之间的数据格式了；
第三，可以用来作为你自定义的数据存储格式，例如对象持久化之类的功能；
最后，可以用来显示你的技术很高深，本来你要存储一个 1 ，结果你这样存储了：
<?xml version="1.0" encoding="GB2312"?>
< root >
< My_Program_Code content =" 1 "></ My_Program_Code >
</ root >
然后再用 libxml2 取出来，最好还来几次编码转换，是不是让人觉得你很牛呢，哈哈！说笑了，千万不要这么做。
