[trac]有用的插件

[trac]有用的插件

trac终于在公司内部使用起来. 现在列一下我认为比较好用的插件.

1. WebAdmin: 这个肯定要装, 用这个 进行管理权限很方便

2. AccountManagerPlugin : 提供以web界面的方式登录. trac默认的登录方式切换用户比较麻烦.

3. TracBlogPlugin : 写blog, 这个我主要用来写开发日志. 依赖TracTags 插件.

4. TracDown : 列出项目释放出来的所有版本, 提供下载.

5. AddCommentMacro : 允许其他人对某个wiki添加评论. 依赖MacroPostPlugin插件.

6. Trac-CC : 显示CruiseControl 自动构建报告 .

7. ThemeEnginePlugin: 如果你想为trac换皮肤, 就要装这个插件

8. OpenOfficeToTracWikiScript : 这个不是trac的插件. 但这个脚本对不会写wiki的人来说很有用. 它是把openoffice文档转换成trac wiki语法格式.

附:

http://trac.edgewall.org/wiki/PluginList 列出常用的插件

http://trac-hacks.org/ trac所有的插件

C/C++跨平台ini文件读写API (已更新)

C/C++跨平台ini文件读写API (已更新)

Posted on 2006-01-24 16:37 天下无双 阅读(1933) 评论(15) 编辑 收藏 引用 所属分类: C/C++

昨 天写了个一组ini文件读写函数。提供大家使用，已经在XP+VC7.1和FC6+GCC4.1,ARM9+arm-linux-gcc3.3中测试过 了，可以跨平台使用。使用标准C写得，支持C++。源程序可以到:http: //www.cppblog.com/Files/dyj057/inifile.zip下载。

/* *
*@file inifile.h
*@cpright (C)2007 GEC
*@auther dengyangjun
*@email dyj057@gmail.com
*@version 0.1
*@create 2007-1-14
*@modify 2007-1-14
*@brief declare ini file operation
*@note
*@history
*/

#ifndef INI_FILE_H_
#define INI_FILE_H_

#ifdef __cplusplus
extern " C "
{
#endif

int read_profile_string( const char * section, const char * key, char * value, int size, const char * file);
int read_profile_int( const char * section, const char * key, int default_value, const char * file);

int write_profile_string( const char * section, const char * key, const char * value, const char * file);

#ifdef __cplusplus
}; // end of extern "C" {
#endif

#endif // end of INI_FILE_H_

/* *
*@file inifile.c
*@cpright (C)2007 GEC
*@auther dengyangjun
*@email dyj057@gmail.com
*@version 0.1
*@create 2007-1-14
*@modify 2007-1-14
*@brief implement ini file operation
*@note
*@history
*/
#include < stdio.h >
#include < stdlib.h >
#include < assert.h >
#include < string .h >
#include < ctype.h >

#include " inifile.h "

#ifdef __cplusplus
extern " C "
{
#endif

#define MAX_FILE_SIZE 8096

#define LEFT_BRACE '['
#define RIGHT_BRACE ']'

static int load_ini_file( const char * file, char * buf, int * file_size)
{
FILE * in = NULL;
int i = 0 ;
* file_size = 0 ;

assert(file != NULL);
assert(buf != NULL);

in = fopen(file, " r " );
if ( NULL == in ) {
return 0 ;
}

// load initialization file
while ((buf[i] = fgetc( in )) != EOF) {
i ++ ;
assert( i < MAX_FILE_SIZE); // file too big
}

buf[i] = ' \0 ' ;
* file_size = i;

fclose( in );
return 1 ;
}

/*
*

* Result of the addtion(int)
*
*
*/

static int isnewline( char c)
{
return ( ' \n ' == c || ' \r ' == c ) ? 1 : 0 ;
}
static int isend( char c)
{
return ' \0 ' == c ? 1 : 0 ;
}
static int isleftbarce( char c)
{
return LEFT_BRACE == c ? 1 : 0 ;
}
static int isrightbrace( char c )
{
return RIGHT_BRACE == c ? 1 : 0 ;
}
static int parse_file( const char * section, const char * key, const char * buf, int * sec_s, int * sec_e,
int * key_s, int * key_e, int * value_s, int * value_e)
{
const char * p = buf;
int i = 0 ;

assert(buf != NULL);
assert(section != NULL && strlen(section));
assert(key != NULL && strlen(key));

* sec_e = * sec_s = * key_e = * key_s = * value_s = * value_e = - 1 ;

while ( ! isend(p[i]) )
{
// find the section
if ( ( 0 == i || isnewline(p[i - 1 ]) ) && isleftbarce(p[i]) )
{
int section_start = i + 1 ;

// find the ']'
do
{
i ++ ;
} while ( ! isrightbrace(p[i]) && ! isend(p[i]));

if ( 0 == strncmp(p + section_start,section, i - section_start))
{
int newline_start = 0 ;

i ++ ;

// Skip over space char after ']'
while (isspace(p[i]))
{
i ++ ;
}

// find the section
* sec_s = section_start;
* sec_e = i;

while ( ! (isnewline(p[i - 1 ]) && isleftbarce(p[i])) && ! isend(p[i]) )
{
int j = 0 ;
// get a new line
newline_start = i;

while ( ! isnewline(p[i]) && ! isend(p[i]) )
{
i ++ ;
}
// now i is equal to end of the line

j = newline_start;

if ( ' ; ' != p[j]) // skip over comment
{
while (j < i && p[j] != ' = ' )
{
j ++ ;
if ( ' = ' == p[j])
{
if (strncmp(key,p + newline_start,j - newline_start) == 0 )
{
// find the key ok
* key_s = newline_start;
* key_e = j - 1 ;

* value_s = j + 1 ;
* value_e = i;

return 1 ;
}
}
}
}

i ++ ;
}
}
}
else
{
i ++ ;
}
}
return 0 ;
}

/* *
* @brief read_profile_string retrieves a string from the specified section in an initialization file.
* @param section const char * name of the section containing the key name.
* @param key const char * the name of the key whose associated string is to be retrieved.
* @param value char * pointer to the buffer that receives the retrieved string.
* @return int 1 : read success; 0 : read fail.
*/
int read_profile_string( const char * section, const char * key, char * value, int size, const char * file)
{
char buf[MAX_FILE_SIZE] = { 0 };
int file_size;
int sec_s,sec_e,key_s,key_e, value_s, value_e;

// check parameters
assert(section != NULL && strlen(section));
assert(key != NULL && strlen(key));
assert(value != NULL);
assert(size > 0 );
assert(file != NULL && strlen(key));

if ( ! load_ini_file(file,buf, & file_size))
return 0 ;

if ( ! parse_file(section,key,buf, & sec_s, & sec_e, & key_s, & key_e, & value_s, & value_e))
{
return 0 ; // not find the key
}
else
{
int cpcount = value_e - value_s;

if ( size - 1 < cpcount)
{
cpcount = size - 1 ;
}

memset(value, 0 , size);
memcpy(value,buf + value_s, cpcount );
value[cpcount] = ' \0 ' ;

return 1 ;
}
}


int read_profile_int( const char * section, const char * key, int default_value, const char * file)
{
char value[ 32 ] = { 0 };
if ( ! read_profile_string(section,key,value, sizeof (value),file))
{
return default_value;
}
else
{
return atoi(value);
}
}

int write_profile_string( const char * section, const char * key, const char * value, const char * file)
{
char buf[MAX_FILE_SIZE] = { 0 };
char w_buf[MAX_FILE_SIZE] = { 0 };
int sec_s,sec_e,key_s,key_e, value_s, value_e;
int value_len = ( int )strlen(value);
int file_size;
FILE * out ;

// check parameters
assert(section != NULL && strlen(section));
assert(key != NULL && strlen(key));
assert(value != NULL);
assert(file != NULL && strlen(key));

if (!load_ini_file(file,buf, & file_size))
{
sec_s = - 1 ;
}
else
{
parse_file(section,key,buf, & sec_s, & sec_e, & key_s, & key_e, & value_s, & value_e);
}

if ( - 1 == sec_s)
{

if ( 0 == file_size)
{
sprintf(w_buf + file_size, " [%s]\n%s=%s\n " ,section,key,value);
}
else
{
// not find the section, then add the new section at end of the file
memcpy(w_buf,buf,file_size);
sprintf(w_buf + file_size, " \n[%s]\n%s=%s\n " ,section,key,value);
}


}
else if ( - 1 == key_s)
{
// not find the key, then add the new key & value at end of the section
memcpy(w_buf,buf,sec_e);
sprintf(w_buf + sec_e, " %s=%s\n " ,key,value);
sprintf(w_buf + sec_e + strlen(key) + strlen(value) + 2 ,buf + sec_e, file_size - sec_e);
}
else
{
// update value with new value
memcpy(w_buf,buf,value_s);
memcpy(w_buf + value_s,value, value_len);
memcpy(w_buf + value_s + value_len, buf + value_e, file_size - value_e);
}

out = fopen(file, " w " );
if (NULL == out )
{
return 0 ;
}

if ( - 1 == fputs(w_buf, out ) )
{
fclose( out );
return 0 ;
}

fclose( out );

return 1 ;
}


#ifdef __cplusplus
}; // end of extern "C" {
#endif

#include < stdio.h >
#include " inifile.h "

// main.c
#define BUF_SIZE 256
int main()
{
const char * file = " myconfig.ini " ;
const char * section = " Db " ;
const char * key = " XX2 " ;

char value[BUF_SIZE] = { 0 };

printf( " test get profile string\n " );

if ( ! read_profile_string(section, key, value, BUF_SIZE, file))
{

printf( " read ini file fail\n " );
}
else
{
int x = read_profile_int(section,key, 0 ,file);
printf( " XX2=%d\n " , x);
printf( " read: [%s] = [%s]\n " ,key,value);
}

if ( ! write_profile_string(section, " XX2 " , " 2writeOK " ,file))
{
printf( " write ini file fail\n " );
}
else
{
printf( " write ini file ok\n " );
}

return 0 ;
}

C++解析XML -- TinyXml

C++解析XML -- TinyXml

2007-05-21 16:53:34
大 中 小
zz from Internet


一、 TinyXml的特点

TinyXml是一个基于DOM模型的、非验证的轻量级C++解释器。

1. SAX和DOM

目前XML的解析主要有两大模型：SAX和DOM。

其中SAX是基于事件的，其基本工作流程是分析XML文档，当发现了一个新的元素时，产生一个对应事件，并调用相应的用户处理函数。这种方式占用内存少，速度快，但用户程序相应得会比较复杂。

而DOM（文档对象模型），则是在分析时，一次性的将整个XML文档进行分析，并在内存中形成对应的树结构，同时，向用户提供一系列的接口来访问和编辑该树结构。这种方式占用内存大，速度往往慢于SAX，但可以给用户提供一个面向对象的访问接口，对用户更为友好。



2. 验证和非验证

对于一个特定的XML文档而言，其正确性分为两个层次。首先是其格式应该符合 XML的基本格式要求，比如第一行要有声明，标签的嵌套层次必须前后一致等等，符合这些要求的文件，就是一个合格的XML文件，称作well- formatted。但除此之外，一个XML文档因其内容的不同还必须在语义上符合相应的标准，这些标准由相应的DTD文件或者Schema文件来定义，符合了这些定义要求的XML文件，称作valid。

因此，解析器也分为两种，一种是验证的，即会跟据XML文件中的声明，用相应的DTD文件对XML文件进行校验，检查它是否满足DTD文件的要求。另一种是忽略DTD文件，只要基本格式正确，就可以进行解析。

就我所知，验证的解析器通常都是比较重量级的。TinyXml不支持验证，但是体积很小，用在解析格式较为简单的XML文件，比如配置文件时，特别的合适。



二、 TinyXml的构建和使用
1. 获取

TinyXml首页在http://www.grinninglizard.com/tinyxml/index.html，从这里可以找到最新版本的源代码，目前的版本是 2.4.3 (截至2006.5.17).

2. 构建

TinyXml在构建时可以选择是否支持STL，选择的话，则可以使用std:: string，所以通常应在Windows上，TinyXml的源码包里提供了VC6的工程文件，直接用它就可以生成两个静该打开这个选项。态库（带 STL和不带STL），非常容易。唯一需要注意的是，默认生成的库是单线程的，如果用在多线程的项目中，需要改动一下配置，生成相应的多线程库。

在Unix平台上，TinyXml的源码包里只提供了一个Makefile，对于典型的Linux系统，或装了gcc和gmake的其他Unix，这个Makefile足够用了，我在RH9和RHEL4上测试，简单的make就成功了。需要注意的有以下几点：默认的编译是不支持STL的，可以通过编辑Makefile的TINYXML_USE_STL := NO那一行，把NO改成YES就可以支持STL了；还有默认只生成了一个测试程序，没有生成任何库，如果要生成静态库的话，可以用ar命令，将生成的几个目标文件打包就行了，如果要生成动态库，则需要加上-fpic参数重新编译。

3. 使用

构建了相应的库之后，在使用了它们的工程中，只要在连接时把他们连上就行了。需要注意的是，如果需要STL支持，在编译用到了TinyXml的文件时，需要定义一个宏TIXML_USE_STL，对gcc，可以使用参数- DTIXML_USE_STL，对cl.exe（VC），可以使用参数/DTIXML_USE_STL，如果嫌麻烦，可以直接定义在 tinyxml.h文件里。



三、 TinyXml的编程模型

1.类之间的关系

TinyXml实现的时DOM访问模型，因此提供了一系列的类对应XML文件中的各个节点。主要类间的关系如下图所示：

TiXmlBase：其它类的基类，是个抽象类

TiXmlNode：表示一个节点，包含节点的一般方法，如访问自节点、兄弟节点、编辑自身、编辑子节点

TiXmlDocument：表示整个XML文档，不对应其中某个特定的节点。

TiXmlElement：表示元素节点，可以包含子节点和TiXmlAttribute

TiXmlComment：表示注释

TiXmlDeclaration：表示声明

TiXmlText：表示文本节点

TiXmlUnknown：表示未知节点，通常是出错了

TiXmlAttribute：表示一个元素的属性

下面是一个简单的例子：







TinyXml How To

20

Some words…





整个文档，对应TiXmlDocument

book,name,price, description，都对应TiXmlElement

第一行对应一个TiXmlDeclaration

第二行对应一个TiXmlComment

“TinyXml How To”对应一个TiXmlText

unit则是price的一个TiXmlAttribute

这些类与XML文件中的相应元素都有很好的对应关系，因此相信参照TinyXml的文档，可以很容易的掌握各个方法的使用。



2. 需要注意的问题

各类之间的转换



由于各个节点类都从TiXmlNode继承，在使用时常常需要将 TiXmlNode*类型的指针转换为其派生类的指针，在进行这种转换时，应该首先使用由TiXmlNode类提供的一系列转换函数，如 ToElement(void)，而不是c++的dynamic_cast



检查返回值

由于TinyXml是一个非校验的解析器，因此当解析一个文件时，很可能文件并不包含我们预期的某个节点，在这种情况下，TinyXml将返回空指针。因此，必须要对返回值进行检查，否则将很容易出现内存访问的错误。



如何重头建立一个XML文件

先建立一个TiXmlDocument对象，然后，载入某个模板，或者直接插入一个节点作为根节点，接着就可以像打开一个已有的XML文件那样对它进行操作了。



四、总结

TinyXml最大的特点就是它很小，可以很方便的静态连接到程序里。对于像配置文件、简单的数据文件这类文件的解析，它很适合。但是由于它是非验证的，因此需要在程序里做许多检查工做，加重了程序编写的负担。因此对于复杂的XML文件，我觉得最好还是用验证的解析器来处理。

解析XML的利器-TinyXML

解析XML的利器-TinyXML

happykevins



l TinyXML简介

TinyXML是目前非常流行的一款基于DOM模型的XML解析器，简单易用且小巧玲珑，非常适合存储简单数据，配置文件，对象序列化等数据量不是很大的操作，尤其适用于游戏开发，在Nebula2，CEGUI等开源项目中都有使用。本文的目的就是把这个好东东分享给大家：）



l 关于DOM和SAX

DOM - Document Object Model

将整篇XML文档一次性解析并读入内存，保存为一个对象供用户访问。

SAX - Simple API for XML

SAX的XML解析方式是基于事件回调的，解析器在每遇到一个XML元素时都会产生一个事件，并执行由用户提供的处理函数。



l TinyXML类结构



[TiXmlBase] 所有TinyXML类的基类，保存该结点或属性在XML原文中的信息。

[TiXmlAttribute] XML结点属性，一个键值对

[TiXmlNode] XML结点的基类，封装了对XML文档树形结构进行操作和维护的方法

[TiXmlComment] XML注释结点

[TiXmlDeclaration] XML声明结点

[TiXmlDocument] XML文档结点（一般为一篇XML文档的根结点）

[TiXmlElement] XML结点

[TiXmlText] XML文本结点

[TiXmlUnknown] 含有未知标签的XML结点

[TiXmlHandle] 封装了一个结点的指针，在对该指针进行查询时将自动进行空指针交验

[TiXmlVisitor] 遍历器接口，描述了每个节点的处理方法，由子类实现

[TiXmlPrinter] Printer遍历器



l 读取XML文件

TiXmlDocument doc("test.xml");

doc.LoadFile("test.xml");



l 写入XML文件

TiXmlDocument doc;

……

doc.SaveFile("test.xml");



l 遍历XML文档

首先以FirstChild获得第一个自节点，然后以NextSibling获取下个兄弟节点；如此递归遍历所有节点即可。

TiXmlNode::FirstChild();

TiXmlNode::NextSibling();



l 构造XML文档

将指定节点插入当前节点子节点队列的末尾

TiXmlNode::LinkEndChild();

设置指定节点的属性

TiXmlElement::SetAttribute();

TiXmlElement::SetDoubleAttribute();





由于TinyXML本身就是以简单著称，所以我也不啰哩吧嗦介绍太多了，如果需要更多资料就去以下网址找吧：）



官方主页：

http://www.grinninglizard.com/tinyxml/

在线文档：

http://www.grinninglizard.com/tinyxmldocs/index.html

TinyXml在游戏中的作用

TinyXml在游戏中的作用

TinyXml在游戏中的作用

作者：akinggw

前言

假如我们要在客户端连接拥有不同IP地址的游戏服务器，我们应该怎样做呢？《传奇》中是使用一个INI文件来定义。这是一个好的办法，我们每次使用时从外部导入我们的数据，而不用每次修改时都编程一次。而我们今天在这里要讲解的是用XML文件来设置，关于什么是XML，请参考其它文章。
许多人将 XML用到很多需要活动设置的应用，比如服务器参数的设置，玩家数据的管理（最近才发现的，原来以为是在数据库中进行管理的，后来发现XML文件也能管理玩家数据，并且比操作数据库要方便的多）。还有人甚至用XML文件来设置窗口界面。看来掌握XML是非常有意义的。

TinyXml

我在这里并不是要讲解如何使用XML，或在网页中使用它。而是要在C/C++中使用它。详细一点就是在C/C++嵌套使用XML文件。
要在C/C++中使用XML文件，你就必须需要一个能分析XML文件的函数库。在这方面有很多，比如libxml2,tinxml,expat等等很多。而我使用的是tinyxml，为什么要使用它呢？因为它很小巧，只有两个头文件和四个CPP文件。正如作者在tinyxml官方文件中所说的，如果你不是想在浏览器中使用XML，那么tinyxml非常适合你。

我们下面来看一下tinyxml是如何在C/C++中建立XML文件的。

char floader[200],buffer[200];

TiXmlDocument* m_xmlDoc = new TiXmlDocument();

TiXmlElement xElement("player");
sprintf(buffer,"%d", 1);
xElement.SetAttribute("admin", buffer);

TiXmlElement xPos("pos");

sprintf(buffer,"%d",2);
xPos.SetAttribute("x", buffer);

sprintf(buffer,"%d",3);
xPos.SetAttribute("y", buffer);

sprintf(buffer,"%d",4);
xPos.SetAttribute("zone", buffer);

xElement.InsertEndChild(xPos);
m_xmlDoc->InsertEndChild(xElement);

sprintf(floader,"%s.xml", "antking");
m_xmlDoc->SaveFile(floader);

delete m_xmlDoc;

这段简单的代码的作用就是将用户数据保存在XML文件中。不同的是我对其做了一些简化。

这段代码的作用就是先建立一个XML文件句柄。

TiXmlDocument* m_xmlDoc = new TiXmlDocument();

然后建立一个成员。

TiXmlElement xElement("player");
sprintf(buffer,"%d", 1);
xElement.SetAttribute("admin", buffer);

然后再建立一个成员。

TiXmlElement xPos("pos");

sprintf(buffer,"%d",2);
xPos.SetAttribute("x", buffer);

sprintf(buffer,"%d",3);
xPos.SetAttribute("y", buffer);

sprintf(buffer,"%d",4);
xPos.SetAttribute("zone", buffer);

这个成员包含3个属性。

接下来是将这个成员连接成上一个成员的子结点。

xElement.InsertEndChild(xPos);

然后再把上一个结点连接成为XML文件的子结点。

m_xmlDoc->InsertEndChild(xElement);

最后保存这个文件。
sprintf(floader,"%s.xml", "antking");
m_xmlDoc->SaveFile(floader);

释放句柄。

delete m_xmlDoc;

这就是创建XML文件的过程。这段代码将产生一个文件，文件内容如下：





它产生的结构可以用一棵树来表示，见下图：



接下来，我们看一下如何从上面这个XML文件中读出数据。

char floader[200],buffer[200];

TiXmlDocument* m_xmlDoc;
int admin1,x1,y1,z1;

sprintf(floader,"%s.xml", "antking");

m_xmlDoc = new TiXmlDocument(floader);

if (m_xmlDoc->LoadFile())
{
TiXmlElement *xPlayer = 0;
xPlayer = m_xmlDoc->FirstChildElement("player");

if (xPlayer)
{
if (xPlayer->Attribute("admin"))
admin1= (bool)atoi(xPlayer->Attribute("admin"));

TiXmlElement *xZone = 0;
xZone = xPlayer->FirstChildElement("pos");

x1 = (int)atoi(xZone->Attribute("x"));
y1 = (int)atoi(xZone->Attribute("y"));
z1 = (int)atoi(xZone->Attribute("zone"));
}
}

delete m_xmlDoc;
printf("%d,%d,%d,%d",admin1,x1,y1,z1);

这段代码的意思就是，先建立一个文件句柄，如果句柄建立成功就打开一个XML文件。XML文件打开后，先得到它的第一个子结点，如果子结点存在，得到这个结点的属性。然后又打开这个结点的第一个子结点，读出其中的数据。最后关闭文件句柄。

关于更多内容请访问金桥科普网站（ http://popul.jqcq.com ; ）游戏开发栏目，如果你需要游戏开发方面的书籍请参考金桥书城游戏频道（http://book.jqcq.com/category/1_70_740.html ;）。 如果你在阅读本篇文章时有什么好的建议请来信给我，我的E_mail: akinggw@126.com. 如果你在使用SDL时有什么问题，请到金桥科普网站（http://popul.jqcq.com ; ）游戏开发栏目，我将详细地为你解答。

有关TinyXML使用的简单总结

有关TinyXML使用的简单总结

这次使用了TinyXML后，觉得这个东西真是不错，于是将使用方法坐下总结来和大家分享。
该解析库在开源网站（http://sourceforge.net ）上有下载，在本Blog也提供下载（下载TinyXML）
TinyXML是一个开源的解析XML的解析库，能够用于C++，能够在Windows或Linux中编译。这个解析库的模型通过解析XML文件，然后在内存中生成DOM模型，从而让我们很方便的遍历这课XML树。
注：DOM模型即文档对象模型，是将整个文档分成多个元素（如书、章、节、段等），并利用树型结构表示这些元素之间的顺序关系以及嵌套包含关系（理解html语言的读者会很容易理解这种树状模型）。
如下是一个XML片段：


周星星
20


白晶晶
18


在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 <<>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 <<>FirstChild()->Value << endl;
cout <<>FirstChild()->Value << endl;
cout <<>Value() <<>

看，读取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文件：


周星星
20



是不是很简单啊？在这里我只是简单的对TinyXml的使用作了介绍，欢迎各位提问留言，我会尽力解答各位的问题。

如何监测内存泄漏

如何监测内存泄漏

作者：未知 点击：0 　　西部数码-全国虚拟主机10强！20余项虚拟主机管理功能,全国领先!第6代双线路虚拟主机,南北访问畅通无阻!虚拟主机可在线rar解压,自动数据恢复设置虚拟目录等.虚拟主机免费赠送访问统计,企业邮局.Cn域名注册58元/年,空间150元起,免费试用7天,满意再付款!P4主机租用799元/月.月付免压金!

文章页数：[1]

版权申明 本文可以被自由转载，但是必须遵循如下版权约定： 1、保留本约定，并保留在文章的开头部分。 2、不能任意修改文章内容，或者删节，增加。如果认为本文内容有不当之处需要修改，请 与作者联系。 3、不能摘抄本文的内容，必须全文发表或者引用。 4、必须保留作者署名、注明文章出处。（本文授权给www.linuxaid.com.cn） 5、如不遵守本规定，则无权转载本文。 作者 ariesram 电子邮件地址 ariesram@linuxaid.com.cn, 或 ariesram@may10.ca 本文及本人所有文章均收集在bambi.may10.ca/~ariesram/articles/中。 本文授权给www.linuxaid.com.cn。 正文： 我曾经参与过一个比较大的项目，在这个项目里面，我们没有一个完全确定的设计文档，所以程序的实现常常变动。虽然我们有一个比较灵活的框架，但是从程序的 角度来讲，它使我们的程序非常的混乱。直到发布的日期临近，我们还没有一个稳定的可以用来做alpha测试的版本。所以我们必须尽快的删除掉无用的代码， 让这个版本足够的稳定。但是，在这个没有足够规范的软件公司，我们没有时间也没有足够的精力来做边界测试之类的工作。所以我们只能采用变通的办法。在软件 中最大的问题就是内存泄漏。因为往往出现这样的情况，我们在一段代码中分配了内存，但是却没有释放它。这造成了很大的问题。我们需要一个简单的解决方案， 能够简单的编译进这个项目，在运行的时候，它能够产生一个没有被释放的内存的列表，用这个列表，我们能够改正程序的错误。这就是我们称之为内存跟踪的方 法。首先，我们需要一种代码，能够被加入到源代码中去，而且这种代码能够被重用。代码重用是一种很重要的特性，能够节省大量的时间和金钱以及程序员的劳 动。另外，我们的这种代码必须简单，因为我们当时已经没有那么多的时间和精力去完全重看一遍所有的代码来重新编写以及改正错误从而使内存跟踪能够起作用。 好在，我们总能够找到解决的办法。首先，我们检查了代码，发现所有的代码都是用new来分配内存，用delete来释放内存。那么，我们能够用一 个全程替换，来替换掉所有的new和delete操作符吗？不能。因为代码的规模太大了，那样做除了浪费时间没有别的任何好处。好在我们的源代码是用C+ +来写成的，所以，这意味着没有必要替换掉所有的new和delete,而只用重载这两个操作符。对了，值用重载这两个操作符，我们就能在分配和释放内存 之前做点什么。这是一个绝对的好消息。我们也知道该如何去做。因为，MFC也是这么做的。我们需要做的是：跟踪所有的内存分配和交互引用以及内存释放。我 们的源代码使用Visual C++写成，当然这种解决方法也可以很轻松的使用在别的C++代码里面。要做的第一件事情是重载new和delete操作符，它们将会在所有的代码中被使 用到。我们在stdafx.h中，加入： #ifdef _DEBUG inline void * __cdecl operator new(unsigned int size, const char *file, int line) { }; inline void __cdecl operator delete(void *p) { }; #endif 这样，我们就重载了new和delete操作符。我们用$ifdef和#endif来包住这两个重载操作符，这样，这两个操作符就不会在发布版本中出现。 看一看这段代码，会发现，new操作符有三个参数，它们是，分配的内存大小，出现的文件名，和行号。这对于寻找内存泄漏是必需的和重要的。否则，就会需要 很多时间去寻找它们出现的确切地方。加入了这段代码，我们的调用new()的代码仍然是指向只接受一个参数的new操作符，而不是这个接受三个参数的操作 符。另外，我们也不想记录所有的new操作符的语句去包含__FILE__和__LINE__参数。我们需要做的是自动的让所有的接受一个参数的new操 作符调用接受三个参数的new操作符。这一点可以用一点点小的技巧去做，例如下面的这一段宏定义， #ifdef _DEBUG #define DEBUG_NEW new(__FILE__, __LINE__) #else #define DEBUG_NEW new #endif #define new DEBUG_NEW 现在我们所有的接受一个参数的new操作符都成为了接受三个参数的new操作符号，__FILE__和__LINE__被预编译器自动的插入到其中了。然 后，就是作实际的跟踪了。我们需要加入一些例程到我们的重载的函数中去，让它们能够完成分配内存和释放内存的工作。这样来做， #ifdef _DEBUG inline void * __cdecl operator new(unsigned int size, const char *file, int line) { void *ptr = (void *)malloc(size); AddTrack((DWORD)ptr, size, file, line); return(ptr); }; inline void __cdecl operator delete(void *p) { RemoveTrack((DWORD)p); free(p); }; #endif 另外，还需要用相同的方法来重载new[]和delete[]操作符。这里就省略掉它们了。 最后，我们需要提供一套函数AddTrack()和RemoveTrack()。我用STL来维护存储内存分配记录的连接表。 这两个函数如下： typedef struct { DWORD address; DWORD size; char file[64]; DWORD line; } ALLOC_INFO; typedef list AllocList; AllocList *allocList; void AddTrack(DWORD addr, DWORD asize, const char *fname, DWORD lnum) { ALLOC_INFO *info; if(!allocList) { allocList = new(AllocList); } info = new(ALLOC_INFO); info->address = addr; strncpy(info->file, fname, 63); info->line = lnum; info->size = asize; allocList->insert(allocList->begin(), info); }; void RemoveTrack(DWORD addr) { AllocList::iterator i; if(!allocList) return; for(i = allocList->begin(); i != allocList->end(); i++) { if((*i)->address == addr) { allocList->remove((*i)); break; } } }; 现在，在我们的程序退出之前，allocList存储了没有被释放的内存分配。为了看到它们是什么和在哪里被分配的，我们需要打印出allocList中的数据。我使用了Visual C++中的Output窗口来做这件事情。 void DumpUnfreed() { AllocList::iterator i; DWORD totalSize = 0; char buf[1024]; if(!allocList) return; for(i = allocList->begin(); i != allocList->end(); i++) { sprintf(buf, "%-50s: LINE %d, ADDRESS %d %d unfreed ", (*i)->file, (*i)->line, (*i)->address, (*i)->size); OutputDebugString(buf); totalSize += (*i)->size; } sprintf(buf, "----------------------------------------------------------- "); OutputDebugString(buf); sprintf(buf, "Total Unfreed: %d bytes ", totalSize); OutputDebugString(buf); }; 现在我们就有了一个可以重用的代码，用来监测跟踪所有的内存泄漏了。这段代码可以用来加入到所有的项目中去。虽然它不会让你的程序看起来更好，但是起码它能够帮助你检查错误，让程序更加的稳定。 文章整理：西部数码--专业提供域名注册、虚拟主机服务 http://www.west263.com 以上信息与文章正文是不可分割的一部分,如果您要转载本文章,请保留以上信息，谢谢!