操作xml文件——解析xml文件

其一：TinyXML 用法：读/写配置文件

1. TinyXML 的主页：
http://www.grinninglizard.com/tinyxml/

下载路径：
http://sourceforge.net/projects/tinyxml/

// 我下载时的最新版本为：tinyxml_2_6_2.zip

2. 使用方法：
解压缩后，将这六个文件添加到c++工程中，分别是: tinystr.h、tinystr.cpp、tinyxml.h、tinyxml.cpp、tinyxmlerror.cpp、tinyxmlparser.cpp。
如果定义宏 TIXML_USE_STL，则 tinystr.h 和 tinystr.cpp 这两个文件可以不需要，我定义了这个宏。

3. 为了支持中文，需要生成 UTF-8 格式的文件，所以还需要将下载的 TinyXML 源代码修改一下，以写入 Windows 下 UTF-8 文件的 BOM 头：0xEF,0xBB,0xBF
在 tinyxml.h/tinyxml.cpp 中增加函数：

tinyxml.h

[cpp] view plaincopy

1. void SetMicrosoftBOM( bool bBOM );  

tinyxml.cpp

[cpp] view plaincopy

1. void TiXmlDocument::SetMicrosoftBOM( bool bBOM )  
2. {  
3.     useMicrosoftBOM = bBOM;  
4. }  

// 在外部调用 TiXmlDocument 的 SaveFile() 函数之前，调用 SetMicrosoftBOM( true )，即可在生成的 xml 文件头写入 BOM 头。

4. 下面举例说明，读写的配置文件内容如下：

<?xml version="1.0" encoding="UTF-8" ?>
<Config>
    <Database ip="192.168.1.33" port="3306" user="root" passwd="111111" dbname="mediadb" />
    <Channels>
        <Channel count="5">天龙八部</Channel>
        <Channel count="5">笑傲江湖</Channel>
    </Channels>
</Config>

 

5.  源码如下，(开始先得到 XML 文件的存取路径)：

[cpp] view plaincopy

1. BOOL CgenwebDlg::OnInitDialog()  
2. {  
3.     ...  
4.       
5.     ///////////////////////////////////////  
6.     //生成配置文件名，带全路径  
7.     CString strCurPath = _T("");  
8.     GetModuleFileName( NULL, strCurPath.GetBuffer(MAX_PATH), MAX_PATH );  
9.     strCurPath.ReleaseBuffer();  
10.     CString strPath = strCurPath.Left( strCurPath.ReverseFind(_T('\\')) + 1 );  
11.   
12.     CString strFile = strCurPath.Right( strCurPath.GetLength() - strCurPath.ReverseFind(_T('\\')) - 1 );  
13.     strFile = strFile.Left( strFile.ReverseFind(_T('.')) );  
14.     m_strProfile = strPath + strFile + _T(".xml");  
15. }  

// 读取 XML 配置文件

[cpp] view plaincopy

1. void CgenwebDlg::ReadConfigFile()  
2. {  
3.     TiXmlDocument* content = new TiXmlDocument();  
4.   
5.     content->LoadFile(m_strProfile.GetBuffer());  
6.     m_strProfile.ReleaseBuffer();  
7.   
8.     TiXmlHandle docHandle( content );  
9.   
10.     TiXmlAttribute * pAttr = 0;  
11.     TiXmlElement* pDatabase = docHandle.FirstChild("Config").FirstChild("Database").ToElement();  
12.     if( pDatabase )  
13.     {  
14.         m_etDB.SetWindowTextA( pDatabase->Attribute( "ip" ) );  
15.         m_etDBPort.SetWindowTextA( pDatabase->Attribute( "port" ) );  
16.         m_etUsername.SetWindowTextA( pDatabase->Attribute( "user" ) );  
17.         m_etPasswd.SetWindowTextA( pDatabase->Attribute( "passwd" ) );  
18.         m_etDBName.SetWindowTextA( pDatabase->Attribute( "dbname" ) );  
19.     }  
20.   
21.     int nIndex = 0;  
22.     int nItem = 0;  
23.     char *text, mbs[256] = {0};  
24.     TiXmlElement* pChannel = docHandle.FirstChild("Config").FirstChild("Channels").FirstChild("Channel").ToElement();  
25.     while( pChannel )  
26.     {  
27.         nIndex = m_listChannels.GetItemCount();  
28.         nItem = m_listChannels.InsertItem(nIndex, "");  
29.   
30.         text = (char *)pChannel->GetText();  
31.         if( UTF8ToMBS( mbs, 256, text ) > 0 )  
32.             m_listChannels.SetItemText( nItem, 0, mbs );  
33.         text = (char *)pChannel->Attribute( "count" );  
34.         m_listChannels.SetItemText( nItem, 1, text );  
35.   
36.         pChannel = pChannel->NextSiblingElement();  
37.     }  
38.   
39.     delete content;  
40. }  

[cpp] view plaincopy

1. // 写入 XML 配置文件  

[cpp] view plaincopy

1. void CgenwebDlg::WriteConfigFile()  
2. {  
3.     TiXmlDocument *pDoc = new TiXmlDocument;  
4.     assert( pDoc );  
5.   
6.     TiXmlDeclaration *pDeclaration = new TiXmlDeclaration(_T("1.0"),_T("UTF-8"),_T(""));    
7.     assert( pDeclaration );  
8.     pDoc->LinkEndChild(pDeclaration);  
9.   
10.     TiXmlElement *pRootEle = new TiXmlElement(_T("Config"));    
11.     assert( pRootEle );  
12.     pDoc->LinkEndChild(pRootEle);    
13.   
14.     TiXmlElement *pDatabase = new TiXmlElement(_T("Database"));    
15.     assert( pDatabase );  
16.     pRootEle->LinkEndChild(pDatabase);    
17.   
18.     char config[256] = {0};  
19.       
20.     m_etDB.GetWindowTextA( config, sizeof(config)-1 );  
21.     pDatabase->SetAttribute(_T("ip"), config);  
22.   
23.     m_etDBPort.GetWindowTextA( config, sizeof(config)-1 );  
24.     pDatabase->SetAttribute(_T("port"), config);  
25.   
26.     m_etUsername.GetWindowTextA( config, sizeof(config)-1 );  
27.     pDatabase->SetAttribute(_T("user"), config);  
28.   
29.     m_etPasswd.GetWindowTextA( config, sizeof(config)-1 );  
30.     pDatabase->SetAttribute(_T("passwd"), config);  
31.   
32.     m_etDBName.GetWindowTextA( config, sizeof(config)-1 );  
33.     pDatabase->SetAttribute(_T("dbname"), config);  
34.   
35.     TiXmlElement *pChannels = new TiXmlElement(_T("Channels"));    
36.     assert( pChannels );  
37.     pRootEle->LinkEndChild(pChannels);    
38.   
39.     char utf8[256] = {0};  
40.     int count = m_listChannels.GetItemCount();  
41.     for( int i=0; i<count; i++)  
42.     {  
43.         TiXmlElement *pChannel = new TiXmlElement(_T("Channel"));  
44.         assert( pChannel );  
45.         pChannels->LinkEndChild(pChannel);  
46.   
47.         m_listChannels.GetItemText( i, 0, config, sizeof(config)-1 );  
48.         if( MBSToUTF8( utf8, sizeof(utf8), config ) > 0 )  
49.         {  
50.             TiXmlText * pName = new TiXmlText(utf8);  
51.             pChannel->LinkEndChild( pName );  
52.         }  
53.   
54.         m_listChannels.GetItemText( i, 1, config, sizeof(config)-1 );  
55.         pChannel->SetAttribute(_T("count"), config);  
56.     }  
57.   
58.     pDoc->SetMicrosoftBOM( true );  
59.     pDoc->SaveFile(m_strProfile);  
60.   
61.     delete pDoc;  
62.     return;    
63. }  

 

6.  以上函数用到的 UTF8 和 MultiBytes 字符串互转函数如下：

[cpp] view plaincopy

1. // MBSToUTF8: string convert functions, convert MBS string to UTF8 string.  
2. // @param utf8: utf8 string converted to.  
3. // @param size: the size of utf8 buffer passed.  
4. // @param mbs: mbs string that need to be converted.  
5. // @return: the length of result string.  
6. int MBSToUTF8( char * utf8, int size, const char* mbs )  
7. {     
8.     if( !utf8 || !mbs )  
9.         return NULL;  
10.   
11.     UINT nACP = GetACP();  
12.   
13.     int dwNum = MultiByteToWideChar( nACP, 0, mbs, -1, NULL, 0 );       // CP_ACP  
14.     if( dwNum <= 0 )  
15.         return NULL;  
16.   
17.     wchar_t* pwText = NULL;  
18.     pwText = new wchar_t[dwNum+1];  
19.     if( !pwText )  
20.     {  
21.         delete [] pwText;  
22.         return NULL;  
23.     }  
24.     memset( pwText, 0, dwNum*2+2 );  
25.     if( MultiByteToWideChar( nACP, 0, mbs, -1, pwText, dwNum ) == 0 )   // CP_ACP  
26.     {  
27.         delete [] pwText;  
28.         return NULL;  
29.     }  
30.   
31.     int dwCount = WideCharToMultiByte( CP_UTF8, 0, pwText, -1, NULL, 0, NULL, NULL );  
32.     if( dwCount <= 0 )  
33.     {  
34.         delete [] pwText;  
35.         return NULL;  
36.     }  
37.   
38.     if( size < dwCount+1 )  
39.     {  
40.         delete [] pwText;  
41.         return NULL;  
42.     }  
43.     memset( utf8, 0, dwCount+1 );  
44.     if( WideCharToMultiByte( CP_UTF8, 0, pwText, -1, utf8, dwCount, NULL, NULL ) == 0 )  
45.     {  
46.         delete [] pwText;  
47.         return NULL;  
48.     }  
49.   
50.     delete [] pwText;  
51.   
52.     return dwCount;  
53. }  

 

[cpp] view plaincopy

1. // UTF8ToMBS: string convert functions, convert UTF8 string to MBS string.  
2. // @param mbs: mbs string converted to.  
3. // @param size: the size of mbs buffer passed.  
4. // @param utf8: utf8 string that need to be converted.  
5. // @return: the length of result string.  
6. int UTF8ToMBS( char * mbs, int size, const char* utf8 )  
7. {  
8.     if( !utf8 || !mbs )  
9.         return NULL;  
10.   
11.     int dwNum = MultiByteToWideChar( CP_UTF8, 0, utf8, -1, NULL, 0 );  
12.     if( dwNum <= 0 )  
13.         return NULL;  
14.   
15.     wchar_t* pwText = NULL;  
16.     pwText = new wchar_t[dwNum+1];  
17.     if( !pwText )  
18.     {  
19.         delete [] pwText;  
20.         return NULL;  
21.     }  
22.     memset( pwText, 0, dwNum*2+2 );  
23.     if( MultiByteToWideChar( CP_UTF8, 0, utf8, -1, pwText, dwNum ) == 0 )  
24.     {  
25.         delete [] pwText;  
26.         return NULL;  
27.     }  
28.   
29.     UINT nACP = GetACP();  
30.   
31.     int dwCount = WideCharToMultiByte( nACP, 0, pwText, -1, NULL, 0, NULL, NULL );  // CP_ACP  
32.     if( dwCount <= 0 )  
33.     {  
34.         delete [] pwText;  
35.         return NULL;  
36.     }  
37.   
38.     if( size < dwCount+1 )  
39.     {  
40.         delete [] pwText;  
41.         return NULL;  
42.     }  
43.     memset( mbs, 0, dwCount+1 );  
44.     if( WideCharToMultiByte( nACP, 0, pwText, -1, mbs, dwCount, NULL, NULL ) == 0 ) // CP_ACP  
45.     {  
46.         delete [] pwText;  
47.         return NULL;  
48.     }  
49.   
50.     delete [] pwText;  
51.   
52.     return dwCount;  
53. }  

如下是一个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" ?>。
                        TiXmlDocument：对应于XML的整个文档。
                        TiXmlElement：对应于XML的元素。
                        TiXmlText：对应于XML的文字部分。
                        TiXmlUnknown：对应于XML的未知部分。 
        TiXmlHandler：定义了针对XML的一些操作。
    那我们如何使用这些类以及他们的方法来操纵我们的XML呢？请看下面。
    一、读取XML(假设我们的Xml文档中的内容与上面的Xml内容一样)
    //创建一个XML的文档对象。
    TiXmlDocument *myDocument = new TiXmlDocument("填上你的Xml文件名");
    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内容，即20；ID属性，即1。
    cout << NameElement->FirstChild()->Value << endl;
    cout << AgeElement->FirstChild()->Value << endl;
    cout << IDAttribute->Value() << endl;
    
    看，读取XML是不是很简单阿，和Java的XML解析库非常的相似，就是名字改了一下而已。
    二、生成XML内容
    //创建一个XML的文档对象。
    TiXmlDocument *myDocument = new TiXmlDocument();
    //创建一个根元素并连接。
    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("20");
    NameElement->LinkEndChild(NameContent);
    AgeElement->LinkEndChild(AgeContent);
    //保存到文件
    myDocument->SaveFile("要保存的xml文件名");
    这样，便创建了一个如下的xml文件：
    <Persons>
        <Person ID="1">
            <name>周星星</name>
            <age>20</age>
        </Person>
    </Persons>

TinyXML入门教程
 

TinyXML入门教程 1
什么是XML？ 1
文档类 2
创建文档对象 3
输出文档对象 3
保存文档对象 4
返回第一个根元素 5
声明类 5
注释类 6
元素类 6
节点名 6
父节点 6
子节点 7
编辑子节点 7
同级节点 7
遍历元素 8
元素属性 8
元素函数总结 9
属性类 10

 

什么是XML？
XML全称EXtensible Markup Language，翻译为可扩展标记语言，简而言之就是你可以自定义数据的标识,以此来区分各种不同的数据,以便于进行数据交换,例如html就可以理解为一种简单的xml语言。XML文件通常就是一个文本文件,可以使用任何编码

 

上图就是我系统中一个xml文件的图标，使用VC2005打开它，你可以看到如下内容：



XML也是有这几个对象组成了，一般来说我们经常使用的类如下：
l TiXmlDocument：文档类，它代表了整个xml文件。
l TiXmlDeclaration：声明类，它表示文件的声明部分，如上图所示。
l TiXmlComment：注释类，它表示文件的注释部分，如上图所示。
l TiXmlElement：元素类，它是文件的主要部分，并且支持嵌套结构，一般使用这种结构来分类的存储信息，它可以包含属性类和文本类，如上图所示。
n TiXmlAttribute/TiXmlAttributeSet：元素属性，它一般嵌套在元素中，用于记录此元素的一些属性，如上图所示。
n TiXmlText：文本对象，它嵌套在某个元素内部，如上图所示。

TinyXml使用文档对象模型（DOM）来解析xml文件，这种模型的处理方式为在分析时，一次性的将整个XML文档进行分析，并在内存中形成对应的树结构，同时，向用户提供一系列的接口来访问和编辑该树结构。这种方式占用内存大，但可以给用户提供一个面向对象的访问接口，对用户更为友好，非常方便用户使用。下面我们依次来介绍各个类的用法。

文档类
 

文档类代表一个XML文档，通过它，你可以保存,载入和打印输出文档。你可以通过以下方式载入xml文档到TiXmlDocument。

创建文档对象
l 创建一个空的文档对象，然后载入一个xml文档
使用到的函数原形如下：
+TiXmlDocument();
+bool LoadFile( const std::string& filename)
在程序中你可以如下使用：

//载入xml文档
TiXmlDocument doc();
doc.LoadFile("tutorial.xml");

l 2、在构造函数中传入文档的名称，然后调用load函数完成解析载入
使用到的函数原形如下：
+TiXmlDocument( const std::string& documentName );
+bool LoadFile();
在程序中你可以如下使用：

//载入xml文档
TiXmlDocument doc("tutorial.xml");
doc.LoadFile(); 

输出文档对象
文档类提供了Print()函数用于在控制台输出当前的文档内容，这个函数的原形如下：
+void Print() const
在程序中你可以如下使用：

//载入xml文档
TiXmlDocument doc("tutorial.xml");
doc.LoadFile();
doc.Print(); //输出文档 
tutorial.xml的内容如下：

<?xml version="1.0" standalone="yes" encoding="utf-8"?>

<!--comment 注释-->

<element attribute="this a attribute(这是一个属性)" int= "1" float = "3.14">
<subelement1>
   This a text(这是一个文本)
</subelement1>
<subelement2/>
<subelement3/>
<subelement4/> 
</element> 
在控制台中你可以得到如下输出：

由于文件使用UTF-8编码，而Windows下的控制台默认使用gb2312编码，因此会生成乱码。



保存文档对象
当然你也可以使用SaveFile()函数来进行另存为，这个函数的原形如下：
bool SaveFile( const std::string& filename ) const
在程序中你可以如下使用：

//载入xml文档
TiXmlDocument doc("tutorial.xml");
doc.LoadFile();
doc.Print(); //输出文档
cout<<endl;
doc.SaveFile("tutorial.txt"); 
使用记事本打开tutorial.txt，你可以看到如下内容。


返回第一个根元素
另外文档对象还提供了一个实用的函数用于返回第一个根对象，它可以让你方便的遍历整个文档结构，查找自己需要的数据。函数原形如下：
+TiXmlElement* RootElement()
我们在介绍元素类的时候再详细介绍它的使用。

声明类
在标准的XML文件中，声明为文件的第一项，例如<?xml version="1.0" standalone="yes"?>,声明对象具有三个属性值，版本，编码和独立文件声明
一般来说文档的第一行就是声明对象，你可以把文档对象的第一个子节点转换为声明对象。

//使用TinyXml的声明对象
TiXmlDeclaration *decl;
decl = doc.FirstChild()->ToDeclaration(); 
然后就可以使用它的功能了，它可以让你返回当前的版本，编码等信息，函数原形如下：
+const char *Version() const
+const char *Encoding() const
+const char *Standalone() const

在程序中你可以如下使用：

//使用TinyXml的声明对象
TiXmlDeclaration *decl;
decl = doc.FirstChild()->ToDeclaration();
cout<<"使用TinyXml的声明对象(TiXmlDeclaration)"<<endl;
//输出声明对象对应的xml内容
decl->Print(0,4,&str);
cout<<str<<endl;
//分别输出声明对象的属性
cout<<"版本："<<decl->Version()<<" 是否为对立文件："<<decl->Standalone()<<" 编码方式："<<decl->Encoding()<<endl;
cout<<endl;  


注释类
这个类一般为xml数据提供解释说明，在程序中一般不使用它，因此，这里就不介绍了。

元素类
元素为一个容器类，它具有元素名称，并可以包含其它元素，文本，注释和未知节点，这些对象统称为元素的节点，即节点可以为元素、文本、注释和未知节点类型。元素也可以包含任意个数的属性。
我们还是以如下的XML代码来说明这个类的功能。

<element attribute="this a attribute(这是一个属性)" int= "1" float = "3.14">
<subelement1>
   This a text(这是一个文本)
</subelement1>
<subelement2/>
<subelement3/>
<subelement4/> 
</element>

节点名
在上方元素的代码中，element为根元素的名称，你可以通过如下的函数来设置和返回它。
+const std::string& ValueStr() const
+void SetValue( const std::string& _value )

父节点
subelement1，subelement2，subelement3，subelement4都是element的子元素，如果当前元素对象的指针指向subelement1，subelement2，subelement3，subelement4，你可以通过Parent()函数来返回指向element对象的指针，Parent()函数的声明如下：
+TiXmlNode* Parent()

子节点
通过父节点的指针，你可以遍历所有的子节点。
+TiXmlNode* FirstChild()
+TiXmlNode* FirstChild( const std::string& _value )
上面两个函数用于返回第一个子节点对象的指针，带参数名的那个函数表示返回第一个名为_value的子节点。

+TiXmlNode* LastChild()
+TiXmlNode* LastChild( const std::string& _value )
上面的两个函数用于返回最后一个节点对象的指针，带参数名的那个函数表示返回最后一个名为_value的子节点。

你也可以使用IterateChildren()函数来依次遍历所有的节点，它们的函数声明如下：
+TiXmlNode* IterateChildren( const TiXmlNode* previous )
+TiXmlNode* IterateChildren( const std::string& _value, const TiXmlNode* previous )
带参数名的那个函数表示只遍历同名的节点。

编辑子节点
你可以插入、删除替换所有的子节点。
+TiXmlNode* InsertEndChild( const TiXmlNode& addThis );
+TiXmlNode* InsertBeforeChild( TiXmlNode* beforeThis, const TiXmlNode& addThis );
+TiXmlNode* InsertAfterChild( TiXmlNode* afterThis, const TiXmlNode& addThis );
上面三个函数用于插入节点，InsertEndChild函数让你把新节点插入到末尾，InsertBeforeChild和InsertAfterChild函数允许你在指定的节点位置前后插入节点。

+TiXmlNode* ReplaceChild( TiXmlNode* replaceThis, const TiXmlNode& withThis );
ReplaceChild函数用于替换指定的节点。

+bool RemoveChild( TiXmlNode* removeThis );
RemoveChild函数让你删除指定的节点。
void Clear();
Clear函数会删除本节点的所有子节点（包括子节点包含的从子节点），但不会修改本节点。

同级节点

<element attribute="this a attribute(这是一个属性)" int= "1" float = "3.14">
<subelement1>
   This a text(这是一个文本)
</subelement1>
<subelement2/>
<subelement3/>
<subelement4/> 
</element> 
在上面的xml代码中，subelement1、subelement2、subelement3、subelement4都属于同级节点，我们也提供了相关的函数用于在这些同级节点中遍历。

+TiXmlNode* PreviousSibling()
+TiXmlNode* PreviousSibling( const std::string& _value )
可以根据当前的节点，返回上一个节点的指针。带参数名的那个函数表示返回上一个名为_value的节点。

当然你也可以根据当前的节点，返回下一个节点的指针。带参数名的那个函数表示返回下一个名为_value的节点。
+TiXmlNode* NextSibling()
+TiXmlNode* NextSibling( const std::string& _value)

遍历元素
元素是一种特殊的节点，以’<’为开始字符，后接元素名称。函数NextSiblingElement用于返回下一个同级元素，而忽略其它类型的节点。它们的函数声明如下：
+TiXmlElement* NextSiblingElement()
+TiXmlElement* NextSiblingElement( const std::string& _value)
带参数名的那个函数表示返回下一个名为_value的同级元素。

本类也提供了相关的函数，让你返回第一个子元素。
+TiXmlElement* FirstChildElement()
+TiXmlElement* FirstChildElement( const std::string& _value )
带参数名的那个函数表示返回下一个名为_value的子元素。

元素属性
属性一般保存在元素中，它们为使用“=”号连接的两个字符串，左边的表示属性名，等号右边的表示属性值，通常使用字符串、整数和浮点数等数据类型表示。例如，pi = 3.14。
你可以通过如下的函数，返回属性值。
+const std::string* Attribute( const std::string& name ) const;
+const std::string* Attribute( const std::string& name, int* i ) const;
+const std::string* Attribute( const std::string& name, double* d ) const;
在上面3个函数中，第一个函数使用字符串保存返回的属性值，第二个函数把属性值转换为整数然后返回，第三个函数把属性值转换为浮点数然后返回。不过，第二、三个函数都会以字符串的形式记录属性值，并作为函数的返回值返回。
另外，你也可以使用模板函数：
+template< typename T > int QueryValueAttribute( const std::string& name, T* outValue ) const
来返回特点的属性值，它会根据你传入的参数，自动选择合适数据类型。

另外，本类也提供了如下三个函数让你设置属性，参数的类型和返回函数类似。
+void SetAttribute( const std::string& name, const std::string& _value );
+void SetAttribute( const std::string& name, int _value );
+void SetDoubleAttribute( const char * name, double value );

FirstAttribute和LastAttribute可以让你返回第一个和最后一个属性，它们的函数声明如下：
+TiXmlAttribute* FirstAttribute()
+TiXmlAttribute* LastAttribute() 
RemoveAttribute函数可以让你删除指定名称的属性，它的函数声明如下：
+void RemoveAttribute( const std::string& name )

元素函数总结
ValueStr     //返回元素名称
SetValue     //设置元素名称
Parent     //返回父节点对象

FirstChild    //返回第一个子节点
LastChild     //返回最后一个子节点
IterateChildren   //返回下一个子节点

InsertEndChild   //在最后一个子节点后插入子节点
InsertBeforeChild   //在指定的子节点前插入子节点
InsertAfterChild   //在指定的子节点后插入子节点
ReplaceChild    //替换指定的子节点
RemoveChild    //删除指定的子节点
Clear     //删除所有的子节点

PreviousSibling   //返回同级中前一个节点
NextSibling    //返回同级中后一个节点

NextSiblingElement   //返回同级中后一个元素
FirstChildElement   //返回第一个子元素节点
Attribute     //返回元素中的属性值
QueryValueAttribute //返回元素中的属性值
SetAttribute    //设置元素中的属性值
FirstAttribute   //返回元素中第一个属性对象
LastAttribute    //返回元素中最后一个属性对象
RemoveAttribute   //删除元素中指定的属性对象

属性类
属性为名称="值"对，元素可以具有属性值，但名称必须唯一。
你可以通过
+const std::string& NameTStr() const
返回属性名称

也可以通过下面三个函数返回属性值：
+const std::string& ValueStr() const
+int     IntValue() const;
+double    DoubleValue() const;

当然你也可以设置属性值，它们的函数声明如下：
+void SetName( const std::string& _name )
+void SetIntValue( int _value ); 
+void SetDoubleValue( double _value );
+void SetValue( const std::string& _value )
以上函数与元素类中的相关函数类似，这里不重复介绍了。

在元素属性中，通常具有许多属性，你可以通过Next函数返回下一个属性对象的指针，也可以通过Previous函数获得上一个属性对象的指针。它们的函数声明如下：
+TiXmlAttribute* Next()
+TiXmlAttribute* Previous()