TinyXML

main.h

#include <stdio.h>
#include <windows.h>
#include <iostream>
#include <tinyxml.h>
#pragma comment (lib,"tinyxmld.lib")
using namespace std;


bool build_simple_doc(TCHAR szFileName[]);           //建立xml文件
bool SetAttri(void);                                //创建和设置属性
int dump_attribs_to_stdout(TiXmlElement *pElement); //打印输出元素属性
void write_app_settings_doc(void);                  //创建XML文件test用  
void Students(void);

//读文件解析操作
void test1(void); //1.xml
void test2(void); //2.xml
void test3(void); //3.xml
void test4(void); //4.xml
void test5(void); //5.xml
void test6(void); //6.xml

//写文件操作
void test7(void); //7.xml
void test8(void); //8.xml
void test9(void); //9.xml

//修改文件操作
void test10(void); //10.xml

//测试用
void test11(void); //11.xml

/*
指针为NULL时，程序会异常。
*/

 

main.cpp

#include "main.h"


int main (void)
{
	
	test11();
	getchar();
	return 0;
}

//建立xml文件
bool build_simple_doc(TCHAR szFileName[])
{
    TiXmlDocument doc;
	TiXmlDeclaration *decl=new TiXmlDeclaration("1.0","UTF-8","yes");  //<?xml version="1.0"?>
	TiXmlElement * element = new TiXmlElement("hello");
	TiXmlText *text=new TiXmlText("World");
	element->LinkEndChild(text);
	doc.LinkEndChild(decl);
	doc.LinkEndChild(element);
	if (doc.SaveFile(szFileName))
       return true;
	else
	   return false;
	/*
	执行结果如下:
	<?xml version="1.0" encoding="UTF-8" standalone="true"?>
	<hello>World</hello>
	*/
}


//创建和设置属性
bool SetAttri( void )
{
	TiXmlDocument doc;
	TiXmlDeclaration *decl=new TiXmlDeclaration("1.0","","");  //<?xml version="1.0"?>
	TiXmlElement * Window = new TiXmlElement("Demo");
	Window->SetAttribute("name","Circle");
	Window->SetAttribute("x",5);
	Window->SetAttribute("y",5);
	Window->SetDoubleAttribute("radius",3.14159);
	doc.LinkEndChild(Window);
	dump_attribs_to_stdout(Window);
	if (doc.SaveFile(TEXT("123.xml")))
		return true;
	else
		return false;

	/*
    //执行结果如下:
	<?xml version="1.0"?>
	<Demo radius="3.141590" y="5" x="5" name="Circle"/>
	*/
}


//打印输出元素属性
int dump_attribs_to_stdout( TiXmlElement *pElement)
{
    assert(pElement);
	if (pElement==NULL)return false;
	
	int i=0;
	//const char* pIndent=getIndent(indent);
	TiXmlAttribute *pAttrib=pElement->FirstAttribute();  //访问元素第一个属性
	while (pAttrib)
	{
		printf("%s: %s\n",pAttrib->Name(),pAttrib->Value());  //返回属性的名称---返回属性的值
		i++;

		pAttrib=pAttrib->Next();  //获取在DOM下一个同级属性。返回null到底。
	}
    
	return i;
}


void write_app_settings_doc( void )
{

   TiXmlDocument doc;
   TiXmlElement* msg;
   TiXmlDeclaration* decl= new TiXmlDeclaration("1.0","UTF-8","yes");
   doc.LinkEndChild(decl);

   TiXmlElement *root =new TiXmlElement("root");   //根节点
   doc.LinkEndChild(root);

   TiXmlComment *comment=new TiXmlComment();       //注释
   comment->SetValue("Settings for MyApp");
   root->LinkEndChild(comment);

   TiXmlElement *msgs=new TiXmlElement("Messages");
   root->LinkEndChild(msgs);

   msg=new TiXmlElement("Welcome");
   msg->LinkEndChild(new TiXmlText("Welcome to MyApp"));
   msgs->LinkEndChild(msg);


   msg=new TiXmlElement("Farewell");
   msg->LinkEndChild(new TiXmlText("Thank you for using MyApp"));
   msgs->LinkEndChild(msg);

   TiXmlElement* windows=new TiXmlElement("windows");
   root->LinkEndChild(windows);

   TiXmlElement *window=new TiXmlElement("window");
   windows->LinkEndChild(window);
   window->SetAttribute("name","MainFrame");
   window->SetAttribute("x",5);
   window->SetAttribute("y",5);
   window->SetAttribute("w",400);
   window->SetAttribute("h",250);
   
   
   TiXmlElement* cxn=new TiXmlElement("Connetion");
   root->LinkEndChild(cxn);
   cxn->SetAttribute("ip","192.168.0.1");
   cxn->SetDoubleAttribute("timeout",123.456);

   dump_attribs_to_stdout(window);

   doc.SaveFile("456.xml");



   return ;

}

void Students( void )
{
	TiXmlDocument* myDocument = new TiXmlDocument();
	myDocument->LoadFile("Students.xml");
	TiXmlElement* rootElement = myDocument->RootElement();  //获取根元素 - 文件 - 唯一的顶级元素。
	TiXmlElement* studentsElement = rootElement->FirstChildElement();  //Students
	TiXmlElement* studentElement = studentsElement->FirstChildElement();  //Student

	while (studentElement)
	{
		TiXmlAttribute* attributeOfStudent = studentElement->FirstAttribute();  //获得student的name属性
		while (attributeOfStudent)
		{
			std::cout<<attributeOfStudent->Name()<<" : "<<attributeOfStudent->Value()<<std::endl;
			attributeOfStudent = attributeOfStudent->Next();
		}
		TiXmlElement* phoneElement = studentElement->FirstChildElement();//第一个节点
		std::cout<<"phone"<<" : "<<phoneElement->GetText()<<std::endl;   //获取内容
		TiXmlElement* addressElement = phoneElement->NextSiblingElement(); //获取下一个节点
		std::cout<<"address"<<" : "<<phoneElement->GetText()<<std::endl;   //获取内容
		studentElement = studentElement->NextSiblingElement();
	}
	return ;

}

void test1( void )
{
	TiXmlDocument* myDocument = new TiXmlDocument();
	myDocument->LoadFile("1.xml");
	TiXmlElement* rootElement=myDocument->RootElement();    //获取根节点  root
	TiXmlElement* Messages=rootElement->FirstChildElement();//获取子节点  messages windows

	while(Messages)
	{
		TiXmlElement* MessageChild=Messages->FirstChildElement();    //获取子节点
		while(MessageChild)
		{
			cout<<MessageChild->GetText()<<endl;
			MessageChild=MessageChild->NextSiblingElement();
			cout<<MessageChild->GetText()<<endl;
			MessageChild=MessageChild->NextSiblingElement();
		}
		Messages=Messages->NextSiblingElement();
	}

    return;

}

void test2( void )
{
	TiXmlDocument* myDocument =new TiXmlDocument;
	myDocument->LoadFile("2.xml");
	TiXmlElement* root=myDocument->RootElement(); //跟节点root
	cout<<root->Value()<<endl;
	TiXmlElement* rootChild=root->FirstChildElement(); 
	while (rootChild)
	{
		cout<<rootChild->Value()<<" : "<<rootChild->GetText()<<endl;
		rootChild=rootChild->NextSiblingElement();
	}
	return ;
	/*
	XML文件结构
	<?xml version="1.0" encoding="UTF-8" standalone="yes" ?>
	<root>
	<centos>my name is centos mini 6.5</centos>
	<linux>my name is Readhat</linux>
	<windows>my name is windows 7</windows>
	</root>
	输出结果
	root
	centos : my name is centos mini 6.5
	linux : my name is Readhat
	windows : my name is windows 7
	*/



}

void test3( void )
{
	TiXmlDocument *doc=new TiXmlDocument;
	doc->LoadFile("3.xml");
	TiXmlElement* Demo=doc->FirstChildElement();
	TiXmlAttribute* Attribute=Demo->FirstAttribute();
	while(Attribute)
	{
		cout<<Attribute->Name()<<" : "<<Attribute->Value()<<endl;
		Attribute=Attribute->Next();
	}
	/*
	文件结构
	<Demo name="Circle" x="5" y="5" radius="3.141590" />
	//输出结果
	name : Circle
	x : 5
	y : 5
	radius : 3.141590
	*/

	
	return ;


}

void test4( void )
{
	TiXmlDocument *doc=new TiXmlDocument;
	doc->LoadFile("4.xml");
	TiXmlElement* root=doc->RootElement();
	TiXmlElement* rootChild=root->FirstChildElement();
	TiXmlElement* windows=rootChild->FirstChildElement();

	
	while(windows)
	{
		TiXmlAttribute* window=windows->FirstAttribute();
		while(window)
		{
			cout<<window->Name()<<" : "<<window->Value()<<endl;
			window=window->Next();
		}
		windows=windows->NextSiblingElement();
	}

	TiXmlElement* Linux=rootChild->NextSiblingElement();
	TiXmlElement* Linuxx=Linux->FirstChildElement();
	while(Linuxx)
	{
		cout<<Linuxx->Value()<<" : "<<Linuxx->GetText()<<endl;
		Linuxx=Linuxx->NextSiblingElement();
	}

	TiXmlElement* ddosip=Linux->NextSiblingElement();
	TiXmlAttribute* ddos=ddosip->FirstAttribute();
	while(ddos)
	{
		cout<<ddos->Name()<<" : "<<ddos->Value()<<endl;
		ddos=ddos->Next();
	}

	TiXmlElement* ConnetionIP=ddosip->NextSiblingElement();
	TiXmlAttribute* Connetion=ConnetionIP->FirstAttribute();
	while(Connetion)
	{
		cout<<Connetion->Name()<<" : "<<Connetion->Value()<<endl;
		Connetion=Connetion->Next();
	}

	/*
	文件结构
	<?xml version="1.0" encoding="UTF-8" standalone="yes" ?>
	<root>
	<windows>
	<window name="MainFrame" x="5" y="5" w="400" h="250" />
	<server name="2003" x="1" y="2" w="3" h="4" />
	</windows>
	<linux>
	<centos>my name is centos mini 6.5</centos>
	<readhat>my name is readhat</readhat>
	<windowsxp>my name is windows xp</windowsxp>
	<windows7>my name is windows 7</windows7>
	<windows8>my name is windows 8</windows8>		
	</linux>
	<ddosip ip="192.168.1.1" time="12345678"  />
	<Connetion ip="192.168.0.1" timeout="123.456000" />
	</root>

	输出结果
	name : MainFrame
	x : 5
	y : 5
	w : 400
	h : 250
	name : 2003
	x : 1
	y : 2
	w : 3
	h : 4
	centos : my name is centos mini 6.5
	readhat : my name is readhat
	windowsxp : my name is windows xp
	windows7 : my name is windows 7
	windows8 : my name is windows 8
	ip : 192.168.1.1
	time : 12345678
	ip : 192.168.0.1
	timeout : 123.456000
	*/

   return ;
}

void test5( void )
{
	TiXmlDocument *doc=new TiXmlDocument;
	doc->LoadFile("5.xml");
	TiXmlElement* root=doc->RootElement();  //获取跟节点root
	TiXmlElement* MessageChild=root->FirstChildElement();//获取root下面的第一个节点 Messages
	TiXmlElement* Connetion=MessageChild->NextSiblingElement();
	TiXmlElement* ConnetionA=Connetion->NextSiblingElement();
	


	//Messages Farewell
	while (MessageChild)
	{
		cout<<MessageChild->Value()<<endl;
		TiXmlElement* Child=MessageChild->FirstChildElement(); 
		while (Child)
		{
			cout<<Child->Value()<<" : "<<Child->GetText()<<endl;
			Child=Child->NextSiblingElement();
		}
		MessageChild=MessageChild->NextSiblingElement();
		cout<<endl;
	}


   while (ConnetionA)
   {
		TiXmlAttribute* ConnetionAttribute=ConnetionA->FirstAttribute();
		while (ConnetionAttribute)
		{
			cout<<ConnetionAttribute->Name()<<" : "<<ConnetionAttribute->Value()<<endl;
			ConnetionAttribute=ConnetionAttribute->Next();
		}
		Connetion=Connetion->NextSiblingElement();
		ConnetionA=ConnetionA->NextSiblingElement();
   }

	return;
}

void test6( void )
{
	TiXmlDocument *doc=new TiXmlDocument;
	doc->LoadFile("6.xml");
	TiXmlElement* root=doc->RootElement();
	cout<<root->Value()<<endl;
	TiXmlAttribute* rootAttribule=root->FirstAttribute();
	cout<<rootAttribule->Name()<<" : "<<rootAttribule->Value()<<endl<<endl;

	TiXmlElement *Students=root->FirstChildElement();
	TiXmlElement *Student=Students->FirstChildElement();

	while (Student)
	{
		TiXmlAttribute* StudentAttribute=Student->FirstAttribute();
		while (StudentAttribute)
		{
			cout<<StudentAttribute->Name()<<" : "<<StudentAttribute->Value()<<endl;
			StudentAttribute=StudentAttribute->Next();
		}
		TiXmlElement* phone=Student->FirstChildElement();
		cout<<phone->Value()<<" : "<<phone->GetText()<<endl;
		TiXmlElement* address=phone->NextSiblingElement();
		cout<<address->Value()<<" : "<<address->GetText()<<endl;
		Student=Student->NextSiblingElement();
		cout<<endl;
	}


	return;

}

void test7( void )
{
	TiXmlDocument doc;
	TiXmlDeclaration* decl=new TiXmlDeclaration("1.0","UTF-8","yes");
	doc.LinkEndChild(decl);
	TiXmlElement* hello=new TiXmlElement("hello");
	TiXmlText*    world=new TiXmlText("world");
	hello->LinkEndChild(world);
	doc.LinkEndChild(hello);
	doc.SaveFile("7.xml");
	/*
	<?xml version="1.0" encoding="UTF-8" standalone="yes" ?>
	<hello>world</hello>
	*/

    return;
}

void test8( void )
{
	TiXmlDocument doc;
	TiXmlDeclaration* decl=new TiXmlDeclaration("1.0","GB2312","yes");
	doc.LinkEndChild(decl);

	TiXmlElement* root=new TiXmlElement("root");   //root
	doc.LinkEndChild(root);

	TiXmlComment* Note=new TiXmlComment("Settings for MyApp");    //<!--Settings for MyApp-->
	root->LinkEndChild(Note);

	TiXmlElement* Messages=new TiXmlElement("Messages");
	root->LinkEndChild(Messages);

	TiXmlElement* Welcome=new TiXmlElement("Welcome");            //<Welcome>Welcome to MyApp</Welcome>
	Messages->LinkEndChild(Welcome);
	TiXmlText* WelcomeText=new TiXmlText("Welcome to MyApp");
	Welcome->LinkEndChild(WelcomeText);

	TiXmlElement* Farewell=new TiXmlElement("Farewell");         //<Farewell>Thank you for using MyApp</Farewell>
    Messages->LinkEndChild(Farewell);
	TiXmlText* FarewellText=new TiXmlText("Thank you for using MyApp");
	Farewell->LinkEndChild(FarewellText);
    
	TiXmlElement* Windows=new TiXmlElement("Windows");      //<windows>
	root->LinkEndChild(Windows);

	TiXmlComment *windowname=new TiXmlComment("<window name=\"MainFrame\" x=\"5\" y=\"5\" w=\"400\" h=\"250\" />");
	Windows->LinkEndChild(windowname);

    TiXmlElement* hello=new TiXmlElement("hello");          //<hello>hello world!</hello>
	Windows->LinkEndChild(hello);
	TiXmlText *helloText=new TiXmlText("hello world");
	hello->LinkEndChild(helloText);

	TiXmlElement* visualc=new TiXmlElement("visualc");      //<visualc>centos</visualc>
	Windows->LinkEndChild(visualc);
	TiXmlText *visualcText=new TiXmlText("centos");
	visualc->LinkEndChild(visualcText);

	doc.Print();
	doc.SaveFile("8.xml");
	return;

}

void test9( void )
{
	TiXmlDocument doc;
	TiXmlDeclaration *decl=new TiXmlDeclaration("1.0","gb2312","yes");
	doc.LinkEndChild(decl);

	TiXmlElement* Demo=new TiXmlElement("Demo");
	doc.LinkEndChild(Demo);
	Demo->SetAttribute("name","Circle");
	Demo->SetAttribute("x","5");
	Demo->SetAttribute("y","5");
	Demo->SetDoubleAttribute("radius",1234);
	
	doc.Print();
	doc.SaveFile("9.xml");
	return;

}

void test10( void )
{

		TiXmlDocument *doc=new TiXmlDocument;
		doc->LoadFile("9.xml");
		TiXmlElement* Demo=doc->FirstChildElement();
		Demo->SetAttribute("name","呵呵");
		Demo->SetAttribute("x","10");
		Demo->SetDoubleAttribute("y",10);
		Demo->SetDoubleAttribute("radius",12345);

		TiXmlAttribute* Attribute=Demo->FirstAttribute();
		while(Attribute)
		{
			cout<<Attribute->Name()<<" : "<<Attribute->Value()<<endl;
			Attribute=Attribute->Next();
		}
		doc->SaveFile("10.xml");
		return ;

}

void test11( void )
{

	TiXmlDocument *doc=new TiXmlDocument;
	doc->LoadFile("9.xml");
	TiXmlElement* Demo=doc->FirstChildElement();
	const char* szText=new char[32];
	//szText=Demo->Attribute("radius");





	
	return ;


}



/*
TiXmlDocument：表示整个XML文档，不对应其中某个特定的节点。
TiXmlDeclaration：表示声明
TiXmlElement：表示元素节点，可以包含子节点和TiXmlAttribute
TiXmlText：表示文本节点
TiXmlComment：表示注释
TiXmlUnknown：表示未知节点，通常是出错了
TiXmlAttribute：表示一个元素的属性
TiXmlBase：其他类的基类，是个抽象类
TiXmlNode：表示一个节点，包含节点的一般方法，如访问子节点、兄弟节点、编辑自身、编辑子节点


*/
/*
TiXmlNode

const char *  Value ()             //返回char*类型元素
const std::string &  ValueStr ()   //返回string类型元素
SetValue (const char *_value)      //改变节点的值char*类型
SetValue (const string _value)     //改变节点的值string类型
Clear()                            //删除节点索引元素
TiXmlNode *  Parent ()             //返回父？
TiXmlNode *  FirstChild ()         //返回该节点的一个元素
TiXmlNode *  FirstChild (const char *value)  //该节点的匹配“价值”的第一个元素。将为空，如果没有找到。
TiXmlNode *  LastChild ()                    //该节点的最后一个孩子。如果没有孩子会是空的。
TiXmlNode *  LastChild (const char *_value)  //这个节点匹配'价值'的最后一个孩子。如果没有孩子会是空的

const TiXmlNode *  IterateChildren (const TiXmlNode *previous)  //另一种方式来走一个节点的孩子。
TiXmlNode *  InsertEndChild (const TiXmlNode &addThis)          //添加新节点
TiXmlNode *  LinkEndChild (TiXmlNode *addThis)                  //添加新节点

TiXmlNode *  InsertBeforeChild (TiXmlNode *beforeThis, const TiXmlNode &addThis)   //添加新的节点
TiXmlNode *  InsertAfterChild (TiXmlNode *afterThis, const TiXmlNode &addThis) 

TiXmlNode *  ReplaceChild (TiXmlNode *replaceThis, const TiXmlNode &withThis)      //改换节点
bool  RemoveChild (TiXmlNode *removeThis)                //删除节点
TiXmlNode *  PreviousSibling ()                          //返回到同级节点
TiXmlNode *  PreviousSibling (const char *)              
TiXmlNode *  PreviousSibling (const string)
TiXmlNode *  PreviousSibling (string)                  
 
TiXmlNode *  NextSibling (const std::string &_value)     //返回到同级节点
TiXmlNode *  NextSibling (char *_value) 
TiXmlNode *  NextSibling () 


TiXmlElement *  NextSiblingElement ()                   //返回下一个节点
TiXmlElement *  NextSiblingElement (char*)
TiXmlElement *  NextSiblingElement (string)

TiXmlElement *  FirstChildElement ()                          //获取第一个节点
TiXmlElement *  FirstChildElement (const char *_value)        //查找节点
TiXmlElement *  FirstChildElement (const std::string &_value) //查找节点

int Type()   //查询节点的类型

TiXmlDocument *  GetDocument ()    //返回改节点的主文档
bool  NoChildren ()                //如果这个节点没有孩子返回true。
virtual TiXmlNode *  Clone ()      //创建该节点的副本

转换为更明确的类型。如果请求的类型不是将返回null。
virtual const TiXmlDocument *  ToDocument () const 
virtual const TiXmlElement *  ToElement () const 
virtual const TiXmlComment *  ToComment () const 
virtual const TiXmlUnknown *  ToUnknown () const 
virtual const TiXmlText *  ToText () const 
virtual const TiXmlDeclaration *  ToDeclaration () const 
virtual TiXmlDocument *  ToDocument () 
virtual TiXmlElement *  ToElement () 
virtual TiXmlComment *  ToComment () 
virtual TiXmlUnknown *  ToUnknown () 
virtual TiXmlText *  ToText () 
virtual TiXmlDeclaration *  ToDeclaration () 













TiXmlNode *  FirstChild (const char *_value) 









--------------------------------------------------------------------------------
TiXmlElement   节点

TiXmlElement(char*)   //构造一个新节点
TiXmlElement(string)

int QueryIntAttribute()     //查询int元素返回int
int QueryDoubleAttribute()  //查询double元素返回int
int QueryFloatAttribute()   //查询float元素返回int
int QueryStringAttribute()  //查询string元素返回int
  
SetAttribute(char*,char*)   //设置的名称到一个给定值的属性char类型。
SetAttribute(string,string) //设置的名称到一个给定值的属性string类型。
SetDoubleAttribute(char*, double value) //设置的名称到一个给定值的属性double类型
RemoveAttribute(char *name)    //删除指定名称的属性
RemoveAttribute(string name)   //删除指定名称的属性
TiXmlAttribute* FirstAttribute()  //访问在此元素的第一个属性
TiXmlAttribute*  LastAttribute()  //在访问该元素的最后一个属性
const char * GetText()            //访问一个元素中的文本
TiXmlNode *  Clone ()             //创建一个新的元素，并返回它 - 返回元素的副本。
virtual void  Print (FILE *cfile, int depth) 
TiXmlElement *  ToElement ()     //返回this

QueryValueAttribute()       //它会试图读取属性为指定类型的模板形式。


Attribute(char*);         //节点名称，返回元素值
Attribute(string);         //节点名称，返回元素值
//用法
TiXmlDocument *doc=new TiXmlDocument;
doc->LoadFile("9.xml");
TiXmlElement* Demo=doc->FirstChildElement();
const char* szText=new char[32];
szText=Demo->Attribute("radius");
---------------------------------------------------------------

------------------------------------------------------------------------
TiXmlDeclaration  声明

TiXmlDeclaration ()                        //空的声明
TiXmlDeclaration (string,string,string )   //参数一 版本，参数二 编码 参数三 是否独立
TiXmlDeclaration (char,char,char)

Version()       //返回版本
Encoding()      //返回编码
Standalone()    //是否独立

ToDeclaration()  //返回this 

Print(); 
TIXML_STRING str;
TiXmlDocument doc;
doc.LoadFile("Students.XML");
doc.Print();
TiXmlDeclaration *dec;
dec=doc.FirstChild()->ToDeclaration();
dec->Print(0,4,&str);
cout<<dec->Version()<<endl;
cout<<dec->Standalone()<<endl;
cout<<dec->Encoding()<<endl;

TiXmlNode * Clone ()  
---------------------------------------------------------------------------------



---------------------------------------------------------------------------------
TiXmlDocument xml文档

TiXmlDocument ()       //空白文档
TiXmlDocument (char*)  //创建一个名称的文件。该文件的名称也是XML的文件名。
TiXmlDocument (string) //创建一个名称的文件。该文件的名称也是XML的文件名。

TiXmlElement *RootElement()  //获取根元素 - 文件 - 唯一的顶级元素。

Print()                      //打印输出文件 
TiXmlDocument doc;
doc.LoadFile("Students.XML");
doc.Print();

ToDocument()                 //返回this
TiXmlNode *  Clone ()        

Error()                //如果发生错误，错误将被设置为真。
char * ErrorDesc ()    //包含错误的文字（英文）说明如果发生。
int ErrorId()          //通常情况下，你可能想要的错误字符串
int ErrorRow ()        //返回错误的位置
int ErrorCol ()        //当发生错误的列
SetTabSize(int )       //允许错误报告功能（ErrorRow（）和ErrorCol（））来报告为行和列的正确值。
ClearError()           //如果已处理的错误，它可被复位以这个呼叫。


LoadFile()             //加载文件
LoadFile(char*)
LoadFile(FILE *)
LoadFile(string)

Parse(const char *p)   //解析XML数据给出空终止块
---------------------------------------------------------------------------


---------------------------------------------------------
TiXmlComment   注释

TiXmlComment ()       //构造一个空的注释
TiXmlComment (char*)  //构建从文字注释
TiXmlComment()        //返回this

------------------------------------------------------------

-----------------------------------------------------------------
TiXmlText      文本元素

TiXmlText (char*)    //构造函数文本元素。
TiXmlText (string)   //构造函数文本元素。
CDATA()              //询问这是否代表着使用CDATA段文字。
SetCDATA (bool)      //打开或者关闭CBDATA
ToText()             //返回this
---------------------------------------------------------------------


--------------------------------------------------------------------
TiXmlBase         //抽象基类

//virtual
Row()      //返回该节点或属性的位置，原来的源文件
Column()   //返回行
SetUserData(void *user) //设置一个指针任意用户数据。
GetUserData()   //得到指向任意用户的数据

--------------------------------------------------------------------



------------------------------------------------------------------------
TiXmlAttribute      //元素属性

Name()              //返回属性的名称  char
Value()             //返回属性的值    char
ValueStr()          //返回属性的值    string
IntValue()          //返回属性的值    int
DoubleValue()       //返回属性的值    double

QueryIntValue(int*)       //查询字符串的值  返回int
QueryDoubleValue(double*) //查询字符串的值  返回double

SetName(char*)            //设置元素的名称
SetValue(char*)           //设置元素的值
SetName(string) 
SetValue(string) 

SetIntValue(int)          //设置一个int值
SetIntValue(double)       //设置一个double值

TiXmlAttribute * Next()     //获取在DOM下一个同级属性。返回null底。
TiXmlAttribute * Previous() //获取在DOM前一个同级属性。返回null的开始。
virtual Print (FILE *cfile, int depth)
-----------------------------------------------------------------------------------
*/