TinyXml 操作XML 常用操作
 源代码下载:http://sourceforge.net/projects/tinyxml/files/
 如下是一个XML片段:
如下是一个XML片段: <Persons>
    <Persons> <Person ID="1">
        <Person ID="1"> <name>周星星</name>
            <name>周星星</name> <age>20</age>
            <age>20</age> </Person>
        </Person> <Person ID="2">
        <Person ID="2"> <name>白晶晶</name>
            <name>白晶晶</name> <age>18</age>
            <age>18</age> </Person>
        </Person> </Persons>
    </Persons> 在TinyXML中,根据XML的各种元素来定义了一些类:
    在TinyXML中,根据XML的各种元素来定义了一些类: TiXmlBase:整个TinyXML模型的基类。
        TiXmlBase:整个TinyXML模型的基类。 TiXmlAttribute:对应于XML中的元素的属性。
                TiXmlAttribute:对应于XML中的元素的属性。 TiXmlNode:对应于DOM结构中的节点。
                TiXmlNode:对应于DOM结构中的节点。 TiXmlComment:对应于XML中的注释。
                        TiXmlComment:对应于XML中的注释。 TiXmlDeclaration:对应于XML中的申明部分,即<?versiong="1.0" ?>。
                        TiXmlDeclaration:对应于XML中的申明部分,即<?versiong="1.0" ?>。 TiXmlDocument:对应于XML的整个文档。
                        TiXmlDocument:对应于XML的整个文档。 TiXmlElement:对应于XML的元素。
                        TiXmlElement:对应于XML的元素。 TiXmlText:对应于XML的文字部分。
                        TiXmlText:对应于XML的文字部分。 TiXmlUnknown:对应于XML的未知部分。
                        TiXmlUnknown:对应于XML的未知部分。  TiXmlHandler:定义了针对XML的一些操作。
        TiXmlHandler:定义了针对XML的一些操作。 那我们如何使用这些类以及他们的方法来操纵我们的XML呢?请看下面。
    那我们如何使用这些类以及他们的方法来操纵我们的XML呢?请看下面。 一、读取XML(假设我们的Xml文档中的内容与上面的Xml内容一样)
    一、读取XML(假设我们的Xml文档中的内容与上面的Xml内容一样) //创建一个XML的文档对象。
    //创建一个XML的文档对象。 TiXmlDocument *myDocument = new TiXmlDocument("填上你的Xml文件名");
    TiXmlDocument *myDocument = new TiXmlDocument("填上你的Xml文件名"); myDocument->LoadFile();
    myDocument->LoadFile(); //获得根元素,即Persons。
    //获得根元素,即Persons。 TiXmlElement *RootElement = myDocument.RootElement();
    TiXmlElement *RootElement = myDocument.RootElement(); //输出根元素名称,即输出Persons。
    //输出根元素名称,即输出Persons。 cout << RootElement->Value() << endl;
    cout << RootElement->Value() << endl; //获得第一个Person节点。
    //获得第一个Person节点。 TiXmlElement *FirstPerson = RootElement->FirstChildElement();
    TiXmlElement *FirstPerson = RootElement->FirstChildElement(); //获得第一个Person的name节点和age节点和ID属性。
    //获得第一个Person的name节点和age节点和ID属性。 TiXmlElement *NameElement = FirstPerson->FirstChildElement();
    TiXmlElement *NameElement = FirstPerson->FirstChildElement(); TiXmlElement *AgeElement = NameElement->NextSiblingElement();
    TiXmlElement *AgeElement = NameElement->NextSiblingElement(); TiXmlAttribute *IDAttribute = FirstPerson->FirstAttribute();
    TiXmlAttribute *IDAttribute = FirstPerson->FirstAttribute(); //输出第一个Person的name内容,即周星星;age内容,即20;ID属性,即1。
    //输出第一个Person的name内容,即周星星;age内容,即20;ID属性,即1。 cout << NameElement->FirstChild()->Value << endl;
    cout << NameElement->FirstChild()->Value << endl; cout << AgeElement->FirstChild()->Value << endl;
    cout << AgeElement->FirstChild()->Value << endl; cout << IDAttribute->Value() << endl;
    cout << IDAttribute->Value() << endl; 
     看,读取XML是不是很简单阿,和Java的XML解析库非常的相似,就是名字改了一下而已。
    看,读取XML是不是很简单阿,和Java的XML解析库非常的相似,就是名字改了一下而已。 二、生成XML内容
    二、生成XML内容 //创建一个XML的文档对象。
    //创建一个XML的文档对象。 TiXmlDocument *myDocument = new TiXmlDocument();
    TiXmlDocument *myDocument = new TiXmlDocument(); //创建一个根元素并连接。
    //创建一个根元素并连接。 TiXmlElement *RootElement = new TiXmlElement("Persons");
    TiXmlElement *RootElement = new TiXmlElement("Persons"); myDocument->LinkEndChild(RootElement);
    myDocument->LinkEndChild(RootElement); //创建一个Person元素并连接。
    //创建一个Person元素并连接。 TiXmlElement *PersonElement = new TiXmlElement("Person");
    TiXmlElement *PersonElement = new TiXmlElement("Person"); RootElement->LinkEndChild(PersonElement);
    RootElement->LinkEndChild(PersonElement); //设置Person元素的属性。
    //设置Person元素的属性。 PersonElement->SetAttribute("ID", "1");
    PersonElement->SetAttribute("ID", "1"); //创建name元素、age元素并连接。
    //创建name元素、age元素并连接。 TiXmlElement *NameElement = new TiXmlElement("name");
    TiXmlElement *NameElement = new TiXmlElement("name"); TiXmlElement *AgeElement = new TiXmlElement("age");
    TiXmlElement *AgeElement = new TiXmlElement("age"); PersonElement->LinkEndChild(NameElement);
    PersonElement->LinkEndChild(NameElement); PersonElement->LinkEndChild(AgeElement);
    PersonElement->LinkEndChild(AgeElement); //设置name元素和age元素的内容并连接。
    //设置name元素和age元素的内容并连接。 TiXmlText *NameContent = new TiXmlText("周星星");
    TiXmlText *NameContent = new TiXmlText("周星星"); TiXmlText *AgeContent = new TiXmlText("20");
    TiXmlText *AgeContent = new TiXmlText("20"); NameElement->LinkEndChild(NameContent);
    NameElement->LinkEndChild(NameContent); AgeElement->LinkEndChild(AgeContent);
    AgeElement->LinkEndChild(AgeContent); //保存到文件
    //保存到文件 myDocument->SaveFile("要保存的xml文件名");
    myDocument->SaveFile("要保存的xml文件名"); 这样,便创建了一个如下的xml文件:
    这样,便创建了一个如下的xml文件: <Persons>
    <Persons> <Person ID="1">
        <Person ID="1"> <name>周星星</name>
            <name>周星星</name> <age>20</age>
            <age>20</age> </Person>
        </Person> </Persons>
    </Persons>
TinyXML入门教程
 
 

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

 
 

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

 
 

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



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

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

 文档类
文档类
 
 

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

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

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

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

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

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

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

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

 <!--comment 注释-->
<!--comment 注释-->

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

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



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

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


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

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

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

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

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


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

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

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

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

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

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

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

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

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

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

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

 同级节点
同级节点

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

 在元素属性中,通常具有许多属性,你可以通过Next函数返回下一个属性对象的指针,也可以通过Previous函数获得上一个属性对象的指针。它们的函数声明如下:
在元素属性中,通常具有许多属性,你可以通过Next函数返回下一个属性对象的指针,也可以通过Previous函数获得上一个属性对象的指针。它们的函数声明如下:
 +TiXmlAttribute* Next()
+TiXmlAttribute* Next()
 +TiXmlAttribute* Previous()
+TiXmlAttribute* Previous()
 
 
 TinyXML入门教程 1
TinyXML入门教程 1 什么是XML? 1
什么是XML? 1 文档类 2
文档类 2 创建文档对象 3
创建文档对象 3 输出文档对象 3
输出文档对象 3 保存文档对象 4
保存文档对象 4 返回第一个根元素 5
返回第一个根元素 5 声明类 5
声明类 5 注释类 6
注释类 6 元素类 6
元素类 6 节点名 6
节点名 6 父节点 6
父节点 6 子节点 7
子节点 7 编辑子节点 7
编辑子节点 7 同级节点 7
同级节点 7 遍历元素 8
遍历元素 8 元素属性 8
元素属性 8 元素函数总结 9
元素函数总结 9 属性类 10
属性类 10
 
 
 什么是XML?
什么是XML? XML全称EXtensible Markup Language,翻译为可扩展标记语言,简而言之就是你可以自定义数据的标识,以此来区分各种不同的数据,以便于进行数据交换,例如html就可以理解为一种简单的xml语言。XML文件通常就是一个文本文件,可以使用任何编码
XML全称EXtensible Markup Language,翻译为可扩展标记语言,简而言之就是你可以自定义数据的标识,以此来区分各种不同的数据,以便于进行数据交换,例如html就可以理解为一种简单的xml语言。XML文件通常就是一个文本文件,可以使用任何编码
 
 
 上图就是我系统中一个xml文件的图标,使用VC2005打开它,你可以看到如下内容:
上图就是我系统中一个xml文件的图标,使用VC2005打开它,你可以看到如下内容:


 XML也是有这几个对象组成了,一般来说我们经常使用的类如下:
XML也是有这几个对象组成了,一般来说我们经常使用的类如下: l TiXmlDocument:文档类,它代表了整个xml文件。
l TiXmlDocument:文档类,它代表了整个xml文件。 l TiXmlDeclaration:声明类,它表示文件的声明部分,如上图所示。
l TiXmlDeclaration:声明类,它表示文件的声明部分,如上图所示。 l TiXmlComment:注释类,它表示文件的注释部分,如上图所示。
l TiXmlComment:注释类,它表示文件的注释部分,如上图所示。 l TiXmlElement:元素类,它是文件的主要部分,并且支持嵌套结构,一般使用这种结构来分类的存储信息,它可以包含属性类和文本类,如上图所示。
l TiXmlElement:元素类,它是文件的主要部分,并且支持嵌套结构,一般使用这种结构来分类的存储信息,它可以包含属性类和文本类,如上图所示。 n TiXmlAttribute/TiXmlAttributeSet:元素属性,它一般嵌套在元素中,用于记录此元素的一些属性,如上图所示。
n TiXmlAttribute/TiXmlAttributeSet:元素属性,它一般嵌套在元素中,用于记录此元素的一些属性,如上图所示。 n TiXmlText:文本对象,它嵌套在某个元素内部,如上图所示。
n TiXmlText:文本对象,它嵌套在某个元素内部,如上图所示。
 TinyXml使用文档对象模型(DOM)来解析xml文件,这种模型的处理方式为在分析时,一次性的将整个XML文档进行分析,并在内存中形成对应的树结构,同时,向用户提供一系列的接口来访问和编辑该树结构。这种方式占用内存大,但可以给用户提供一个面向对象的访问接口,对用户更为友好,非常方便用户使用。下面我们依次来介绍各个类的用法。
TinyXml使用文档对象模型(DOM)来解析xml文件,这种模型的处理方式为在分析时,一次性的将整个XML文档进行分析,并在内存中形成对应的树结构,同时,向用户提供一系列的接口来访问和编辑该树结构。这种方式占用内存大,但可以给用户提供一个面向对象的访问接口,对用户更为友好,非常方便用户使用。下面我们依次来介绍各个类的用法。
 文档类
文档类 
 
 文档类代表一个XML文档,通过它,你可以保存,载入和打印输出文档。你可以通过以下方式载入xml文档到TiXmlDocument。
文档类代表一个XML文档,通过它,你可以保存,载入和打印输出文档。你可以通过以下方式载入xml文档到TiXmlDocument。
 创建文档对象
创建文档对象 l 创建一个空的文档对象,然后载入一个xml文档
l 创建一个空的文档对象,然后载入一个xml文档 使用到的函数原形如下:
使用到的函数原形如下: +TiXmlDocument();
+TiXmlDocument(); +bool LoadFile( const std::string& filename)
+bool LoadFile( const std::string& filename) 在程序中你可以如下使用:
在程序中你可以如下使用:
 //载入xml文档
//载入xml文档 TiXmlDocument doc();
TiXmlDocument doc(); doc.LoadFile("tutorial.xml");
doc.LoadFile("tutorial.xml");
 l 2、在构造函数中传入文档的名称,然后调用load函数完成解析载入
l 2、在构造函数中传入文档的名称,然后调用load函数完成解析载入 使用到的函数原形如下:
使用到的函数原形如下: +TiXmlDocument( const std::string& documentName );
+TiXmlDocument( const std::string& documentName ); +bool LoadFile();
+bool LoadFile(); 在程序中你可以如下使用:
在程序中你可以如下使用:
 //载入xml文档
//载入xml文档 TiXmlDocument doc("tutorial.xml");
TiXmlDocument doc("tutorial.xml"); doc.LoadFile();
doc.LoadFile(); 
 输出文档对象
输出文档对象 文档类提供了Print()函数用于在控制台输出当前的文档内容,这个函数的原形如下:
文档类提供了Print()函数用于在控制台输出当前的文档内容,这个函数的原形如下: +void Print() const
+void Print() const 在程序中你可以如下使用:
在程序中你可以如下使用:
 //载入xml文档
//载入xml文档 TiXmlDocument doc("tutorial.xml");
TiXmlDocument doc("tutorial.xml"); doc.LoadFile();
doc.LoadFile(); doc.Print(); //输出文档
doc.Print(); //输出文档  tutorial.xml的内容如下:
tutorial.xml的内容如下:
 <?xml version="1.0" standalone="yes" encoding="utf-8"?>
<?xml version="1.0" standalone="yes" encoding="utf-8"?>
 <!--comment 注释-->
<!--comment 注释-->
 <element attribute="this a attribute(这是一个属性)" int= "1" float = "3.14">
<element attribute="this a attribute(这是一个属性)" int= "1" float = "3.14"> <subelement1>
<subelement1> This a text(这是一个文本)
   This a text(这是一个文本) </subelement1>
</subelement1> <subelement2/>
<subelement2/> <subelement3/>
<subelement3/> <subelement4/>
<subelement4/>  </element>
</element>  在控制台中你可以得到如下输出:
在控制台中你可以得到如下输出:
 由于文件使用UTF-8编码,而Windows下的控制台默认使用gb2312编码,因此会生成乱码。
由于文件使用UTF-8编码,而Windows下的控制台默认使用gb2312编码,因此会生成乱码。


 保存文档对象
保存文档对象 当然你也可以使用SaveFile()函数来进行另存为,这个函数的原形如下:
当然你也可以使用SaveFile()函数来进行另存为,这个函数的原形如下: bool SaveFile( const std::string& filename ) const
bool SaveFile( const std::string& filename ) const 在程序中你可以如下使用:
在程序中你可以如下使用:
 //载入xml文档
//载入xml文档 TiXmlDocument doc("tutorial.xml");
TiXmlDocument doc("tutorial.xml"); doc.LoadFile();
doc.LoadFile(); doc.Print(); //输出文档
doc.Print(); //输出文档 cout<<endl;
cout<<endl; doc.SaveFile("tutorial.txt");
doc.SaveFile("tutorial.txt");  使用记事本打开tutorial.txt,你可以看到如下内容。
使用记事本打开tutorial.txt,你可以看到如下内容。

 返回第一个根元素
返回第一个根元素 另外文档对象还提供了一个实用的函数用于返回第一个根对象,它可以让你方便的遍历整个文档结构,查找自己需要的数据。函数原形如下:
另外文档对象还提供了一个实用的函数用于返回第一个根对象,它可以让你方便的遍历整个文档结构,查找自己需要的数据。函数原形如下: +TiXmlElement* RootElement()
+TiXmlElement* RootElement() 我们在介绍元素类的时候再详细介绍它的使用。
我们在介绍元素类的时候再详细介绍它的使用。
 声明类
声明类 在标准的XML文件中,声明为文件的第一项,例如<?xml version="1.0" standalone="yes"?>,声明对象具有三个属性值,版本,编码和独立文件声明
在标准的XML文件中,声明为文件的第一项,例如<?xml version="1.0" standalone="yes"?>,声明对象具有三个属性值,版本,编码和独立文件声明 一般来说文档的第一行就是声明对象,你可以把文档对象的第一个子节点转换为声明对象。
一般来说文档的第一行就是声明对象,你可以把文档对象的第一个子节点转换为声明对象。
 //使用TinyXml的声明对象
//使用TinyXml的声明对象 TiXmlDeclaration *decl;
TiXmlDeclaration *decl; decl = doc.FirstChild()->ToDeclaration();
decl = doc.FirstChild()->ToDeclaration();  然后就可以使用它的功能了,它可以让你返回当前的版本,编码等信息,函数原形如下:
然后就可以使用它的功能了,它可以让你返回当前的版本,编码等信息,函数原形如下: +const char *Version() const
+const char *Version() const +const char *Encoding() const
+const char *Encoding() const +const char *Standalone() const
+const char *Standalone() const
 在程序中你可以如下使用:
在程序中你可以如下使用:
 //使用TinyXml的声明对象
//使用TinyXml的声明对象 TiXmlDeclaration *decl;
TiXmlDeclaration *decl; decl = doc.FirstChild()->ToDeclaration();
decl = doc.FirstChild()->ToDeclaration(); cout<<"使用TinyXml的声明对象(TiXmlDeclaration)"<<endl;
cout<<"使用TinyXml的声明对象(TiXmlDeclaration)"<<endl; //输出声明对象对应的xml内容
//输出声明对象对应的xml内容 decl->Print(0,4,&str);
decl->Print(0,4,&str); cout<<str<<endl;
cout<<str<<endl; //分别输出声明对象的属性
//分别输出声明对象的属性 cout<<"版本:"<<decl->Version()<<" 是否为对立文件:"<<decl->Standalone()<<" 编码方式:"<<decl->Encoding()<<endl;
cout<<"版本:"<<decl->Version()<<" 是否为对立文件:"<<decl->Standalone()<<" 编码方式:"<<decl->Encoding()<<endl; cout<<endl;
cout<<endl;  

 注释类
注释类 这个类一般为xml数据提供解释说明,在程序中一般不使用它,因此,这里就不介绍了。
这个类一般为xml数据提供解释说明,在程序中一般不使用它,因此,这里就不介绍了。
 元素类
元素类 元素为一个容器类,它具有元素名称,并可以包含其它元素,文本,注释和未知节点,这些对象统称为元素的节点,即节点可以为元素、文本、注释和未知节点类型。元素也可以包含任意个数的属性。
元素为一个容器类,它具有元素名称,并可以包含其它元素,文本,注释和未知节点,这些对象统称为元素的节点,即节点可以为元素、文本、注释和未知节点类型。元素也可以包含任意个数的属性。 我们还是以如下的XML代码来说明这个类的功能。
我们还是以如下的XML代码来说明这个类的功能。
 <element attribute="this a attribute(这是一个属性)" int= "1" float = "3.14">
<element attribute="this a attribute(这是一个属性)" int= "1" float = "3.14"> <subelement1>
<subelement1> This a text(这是一个文本)
   This a text(这是一个文本) </subelement1>
</subelement1> <subelement2/>
<subelement2/> <subelement3/>
<subelement3/> <subelement4/>
<subelement4/>  </element>
</element>
 节点名
节点名 在上方元素的代码中,element为根元素的名称,你可以通过如下的函数来设置和返回它。
在上方元素的代码中,element为根元素的名称,你可以通过如下的函数来设置和返回它。 +const std::string& ValueStr() const
+const std::string& ValueStr() const +void SetValue( const std::string& _value )
+void SetValue( const std::string& _value )
 父节点
父节点 subelement1,subelement2,subelement3,subelement4都是element的子元素,如果当前元素对象的指针指向subelement1,subelement2,subelement3,subelement4,你可以通过Parent()函数来返回指向element对象的指针,Parent()函数的声明如下:
subelement1,subelement2,subelement3,subelement4都是element的子元素,如果当前元素对象的指针指向subelement1,subelement2,subelement3,subelement4,你可以通过Parent()函数来返回指向element对象的指针,Parent()函数的声明如下: +TiXmlNode* Parent()
+TiXmlNode* Parent()
 子节点
子节点 通过父节点的指针,你可以遍历所有的子节点。
通过父节点的指针,你可以遍历所有的子节点。 +TiXmlNode* FirstChild()
+TiXmlNode* FirstChild() +TiXmlNode* FirstChild( const std::string& _value )
+TiXmlNode* FirstChild( const std::string& _value ) 上面两个函数用于返回第一个子节点对象的指针,带参数名的那个函数表示返回第一个名为_value的子节点。
上面两个函数用于返回第一个子节点对象的指针,带参数名的那个函数表示返回第一个名为_value的子节点。
 +TiXmlNode* LastChild()
+TiXmlNode* LastChild() +TiXmlNode* LastChild( const std::string& _value )
+TiXmlNode* LastChild( const std::string& _value ) 上面的两个函数用于返回最后一个节点对象的指针,带参数名的那个函数表示返回最后一个名为_value的子节点。
上面的两个函数用于返回最后一个节点对象的指针,带参数名的那个函数表示返回最后一个名为_value的子节点。
 你也可以使用IterateChildren()函数来依次遍历所有的节点,它们的函数声明如下:
你也可以使用IterateChildren()函数来依次遍历所有的节点,它们的函数声明如下: +TiXmlNode* IterateChildren( const TiXmlNode* previous )
+TiXmlNode* IterateChildren( const TiXmlNode* previous ) +TiXmlNode* IterateChildren( const std::string& _value, const TiXmlNode* previous )
+TiXmlNode* IterateChildren( const std::string& _value, const TiXmlNode* previous ) 带参数名的那个函数表示只遍历同名的节点。
带参数名的那个函数表示只遍历同名的节点。
 编辑子节点
编辑子节点 你可以插入、删除替换所有的子节点。
你可以插入、删除替换所有的子节点。 +TiXmlNode* InsertEndChild( const TiXmlNode& addThis );
+TiXmlNode* InsertEndChild( const TiXmlNode& addThis ); +TiXmlNode* InsertBeforeChild( TiXmlNode* beforeThis, const TiXmlNode& addThis );
+TiXmlNode* InsertBeforeChild( TiXmlNode* beforeThis, const TiXmlNode& addThis ); +TiXmlNode* InsertAfterChild( TiXmlNode* afterThis, const TiXmlNode& addThis );
+TiXmlNode* InsertAfterChild( TiXmlNode* afterThis, const TiXmlNode& addThis ); 上面三个函数用于插入节点,InsertEndChild函数让你把新节点插入到末尾,InsertBeforeChild和InsertAfterChild函数允许你在指定的节点位置前后插入节点。
上面三个函数用于插入节点,InsertEndChild函数让你把新节点插入到末尾,InsertBeforeChild和InsertAfterChild函数允许你在指定的节点位置前后插入节点。
 +TiXmlNode* ReplaceChild( TiXmlNode* replaceThis, const TiXmlNode& withThis );
+TiXmlNode* ReplaceChild( TiXmlNode* replaceThis, const TiXmlNode& withThis ); ReplaceChild函数用于替换指定的节点。
ReplaceChild函数用于替换指定的节点。
 +bool RemoveChild( TiXmlNode* removeThis );
+bool RemoveChild( TiXmlNode* removeThis ); RemoveChild函数让你删除指定的节点。
RemoveChild函数让你删除指定的节点。 void Clear();
void Clear(); Clear函数会删除本节点的所有子节点(包括子节点包含的从子节点),但不会修改本节点。
Clear函数会删除本节点的所有子节点(包括子节点包含的从子节点),但不会修改本节点。
 同级节点
同级节点
 <element attribute="this a attribute(这是一个属性)" int= "1" float = "3.14">
<element attribute="this a attribute(这是一个属性)" int= "1" float = "3.14"> <subelement1>
<subelement1> This a text(这是一个文本)
   This a text(这是一个文本) </subelement1>
</subelement1> <subelement2/>
<subelement2/> <subelement3/>
<subelement3/> <subelement4/>
<subelement4/>  </element>
</element>  在上面的xml代码中,subelement1、subelement2、subelement3、subelement4都属于同级节点,我们也提供了相关的函数用于在这些同级节点中遍历。
在上面的xml代码中,subelement1、subelement2、subelement3、subelement4都属于同级节点,我们也提供了相关的函数用于在这些同级节点中遍历。
 +TiXmlNode* PreviousSibling()
+TiXmlNode* PreviousSibling() +TiXmlNode* PreviousSibling( const std::string& _value )
+TiXmlNode* PreviousSibling( const std::string& _value ) 可以根据当前的节点,返回上一个节点的指针。带参数名的那个函数表示返回上一个名为_value的节点。
可以根据当前的节点,返回上一个节点的指针。带参数名的那个函数表示返回上一个名为_value的节点。
 当然你也可以根据当前的节点,返回下一个节点的指针。带参数名的那个函数表示返回下一个名为_value的节点。
当然你也可以根据当前的节点,返回下一个节点的指针。带参数名的那个函数表示返回下一个名为_value的节点。 +TiXmlNode* NextSibling()
+TiXmlNode* NextSibling() +TiXmlNode* NextSibling( const std::string& _value)
+TiXmlNode* NextSibling( const std::string& _value)
 遍历元素
遍历元素 元素是一种特殊的节点,以’<’为开始字符,后接元素名称。函数NextSiblingElement用于返回下一个同级元素,而忽略其它类型的节点。它们的函数声明如下:
元素是一种特殊的节点,以’<’为开始字符,后接元素名称。函数NextSiblingElement用于返回下一个同级元素,而忽略其它类型的节点。它们的函数声明如下: +TiXmlElement* NextSiblingElement()
+TiXmlElement* NextSiblingElement() +TiXmlElement* NextSiblingElement( const std::string& _value)
+TiXmlElement* NextSiblingElement( const std::string& _value) 带参数名的那个函数表示返回下一个名为_value的同级元素。
带参数名的那个函数表示返回下一个名为_value的同级元素。
 本类也提供了相关的函数,让你返回第一个子元素。
本类也提供了相关的函数,让你返回第一个子元素。 +TiXmlElement* FirstChildElement()
+TiXmlElement* FirstChildElement() +TiXmlElement* FirstChildElement( const std::string& _value )
+TiXmlElement* FirstChildElement( const std::string& _value ) 带参数名的那个函数表示返回下一个名为_value的子元素。
带参数名的那个函数表示返回下一个名为_value的子元素。
 元素属性
元素属性 属性一般保存在元素中,它们为使用“=”号连接的两个字符串,左边的表示属性名,等号右边的表示属性值,通常使用字符串、整数和浮点数等数据类型表示。例如,pi = 3.14。
属性一般保存在元素中,它们为使用“=”号连接的两个字符串,左边的表示属性名,等号右边的表示属性值,通常使用字符串、整数和浮点数等数据类型表示。例如,pi = 3.14。 你可以通过如下的函数,返回属性值。
你可以通过如下的函数,返回属性值。 +const std::string* Attribute( const std::string& name ) const;
+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, int* i ) const; +const std::string* Attribute( const std::string& name, double* d ) const;
+const std::string* Attribute( const std::string& name, double* d ) const; 在上面3个函数中,第一个函数使用字符串保存返回的属性值,第二个函数把属性值转换为整数然后返回,第三个函数把属性值转换为浮点数然后返回。不过,第二、三个函数都会以字符串的形式记录属性值,并作为函数的返回值返回。
在上面3个函数中,第一个函数使用字符串保存返回的属性值,第二个函数把属性值转换为整数然后返回,第三个函数把属性值转换为浮点数然后返回。不过,第二、三个函数都会以字符串的形式记录属性值,并作为函数的返回值返回。 另外,你也可以使用模板函数:
另外,你也可以使用模板函数: +template< typename T > int QueryValueAttribute( const std::string& name, T* outValue ) const
+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, const std::string& _value ); +void SetAttribute( const std::string& name, int _value );
+void SetAttribute( const std::string& name, int _value ); +void SetDoubleAttribute( const char * name, double value );
+void SetDoubleAttribute( const char * name, double value );
 FirstAttribute和LastAttribute可以让你返回第一个和最后一个属性,它们的函数声明如下:
FirstAttribute和LastAttribute可以让你返回第一个和最后一个属性,它们的函数声明如下: +TiXmlAttribute* FirstAttribute()
+TiXmlAttribute* FirstAttribute() +TiXmlAttribute* LastAttribute()
+TiXmlAttribute* LastAttribute()  RemoveAttribute函数可以让你删除指定名称的属性,它的函数声明如下:
RemoveAttribute函数可以让你删除指定名称的属性,它的函数声明如下: +void RemoveAttribute( const std::string& name )
+void RemoveAttribute( const std::string& name )
 元素函数总结
元素函数总结 ValueStr     //返回元素名称
ValueStr     //返回元素名称 SetValue     //设置元素名称
SetValue     //设置元素名称 Parent     //返回父节点对象
Parent     //返回父节点对象
 FirstChild    //返回第一个子节点
FirstChild    //返回第一个子节点 LastChild     //返回最后一个子节点
LastChild     //返回最后一个子节点 IterateChildren   //返回下一个子节点
IterateChildren   //返回下一个子节点
 InsertEndChild   //在最后一个子节点后插入子节点
InsertEndChild   //在最后一个子节点后插入子节点 InsertBeforeChild   //在指定的子节点前插入子节点
InsertBeforeChild   //在指定的子节点前插入子节点 InsertAfterChild   //在指定的子节点后插入子节点
InsertAfterChild   //在指定的子节点后插入子节点 ReplaceChild    //替换指定的子节点
ReplaceChild    //替换指定的子节点 RemoveChild    //删除指定的子节点
RemoveChild    //删除指定的子节点 Clear     //删除所有的子节点
Clear     //删除所有的子节点
 PreviousSibling   //返回同级中前一个节点
PreviousSibling   //返回同级中前一个节点 NextSibling    //返回同级中后一个节点
NextSibling    //返回同级中后一个节点
 NextSiblingElement   //返回同级中后一个元素
NextSiblingElement   //返回同级中后一个元素 FirstChildElement   //返回第一个子元素节点
FirstChildElement   //返回第一个子元素节点 Attribute     //返回元素中的属性值
Attribute     //返回元素中的属性值 QueryValueAttribute //返回元素中的属性值
QueryValueAttribute //返回元素中的属性值 SetAttribute    //设置元素中的属性值
SetAttribute    //设置元素中的属性值 FirstAttribute   //返回元素中第一个属性对象
FirstAttribute   //返回元素中第一个属性对象 LastAttribute    //返回元素中最后一个属性对象
LastAttribute    //返回元素中最后一个属性对象 RemoveAttribute   //删除元素中指定的属性对象
RemoveAttribute   //删除元素中指定的属性对象
 属性类
属性类 属性为名称="值"对,元素可以具有属性值,但名称必须唯一。
属性为名称="值"对,元素可以具有属性值,但名称必须唯一。 你可以通过
你可以通过 +const std::string& NameTStr() const
+const std::string& NameTStr() const 返回属性名称
返回属性名称
 也可以通过下面三个函数返回属性值:
也可以通过下面三个函数返回属性值: +const std::string& ValueStr() const
+const std::string& ValueStr() const +int     IntValue() const;
+int     IntValue() const; +double    DoubleValue() const;
+double    DoubleValue() const;
 当然你也可以设置属性值,它们的函数声明如下:
当然你也可以设置属性值,它们的函数声明如下: +void SetName( const std::string& _name )
+void SetName( const std::string& _name ) +void SetIntValue( int _value );
+void SetIntValue( int _value );  +void SetDoubleValue( double _value );
+void SetDoubleValue( double _value ); +void SetValue( const std::string& _value )
+void SetValue( const std::string& _value ) 以上函数与元素类中的相关函数类似,这里不重复介绍了。
以上函数与元素类中的相关函数类似,这里不重复介绍了。
 在元素属性中,通常具有许多属性,你可以通过Next函数返回下一个属性对象的指针,也可以通过Previous函数获得上一个属性对象的指针。它们的函数声明如下:
在元素属性中,通常具有许多属性,你可以通过Next函数返回下一个属性对象的指针,也可以通过Previous函数获得上一个属性对象的指针。它们的函数声明如下: +TiXmlAttribute* Next()
+TiXmlAttribute* Next() +TiXmlAttribute* Previous()
+TiXmlAttribute* Previous() 
                    
                     
                    
                 
                    
                
 
 
                
            
         
         浙公网安备 33010602011771号
浙公网安备 33010602011771号