批处理 for应用

2007-11-08T18:48:00.001+08:00

批处理 for应用

作者:未知
时间:2005-09-13 21:50
出处:Blog.ChinaUnix.net
责编:chinaitpower

摘要：批处理 for应用

裕作小记：

这几天在埋头写自己的3D文件浏览器（稍后发布），突发奇想的要把自己的内部格式转化成XML，于是，把以前在研究所时用过的ExPat翻了出来。 ExPat是基于事件的XML解释器，速度挺快的，但结构方面有点不敢恭维－－当年写配置文件的导出导入部分花了我足足1个星期！而且由于它是基于事件发生的次序（SAX），似乎有时会发生一些无法控制的情况－－例如进入某Level后忘了记录，结果……后面的程序全部死掉！这时想起同事之前推荐的 TinyXML，结果……用了不到3小时就把我的3D格式导出来了～～呵呵。以下是一篇转贴的TinyXML基础，稍后我会写一篇TinyXML的实战例子，敬请留意 :-)

PS：由于没找到正式的出处，所以把全文引用如下，并没有写上引用出处－－如果哪位朋友知道，请告知在下。
－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－

TinyXml学习笔记

张弛com>

一、 TinyXml的特点

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

1. SAX和DOM

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

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

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

另据说，一些同时提供了SAX和DOM接口的库，是在底层先实现SAX，再在SAX的基础上实现DOM。

目前我知道的XML解析库有下面几个：

名称	访问接口	是否支持验证	备注
Expat	SAX/Local	不清楚	Local指它还有一套自己访问模型
LibXML2	SAX/DOM	是
TinyXml	DOM	否
XML4C	SAX/DOM	是	和Xerces-C是一家，不过用了ICU，国际化似乎更好
Xerces-C	SAX/DOM	是
XML Booster	Local	不清楚	这个库不是特别了解，好像是类似yacc那样，可以生成一个特定的解析器，估计效率应该很高（看名字也像）。

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.3.4。

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：表示一个元素的属性

下面是一个简单的例子：

version="1.0" encoding="utf-8" ?>

<book>

<name>TinyXml How To

<description>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文件，我觉得最好还是用验证的解析器来处理。

实战TinyXML

2007-09-28T20:06:00.001+08:00

实战TinyXML

作者：裕作

（本文为原创，转贴请注明出处：http://blog.csdn.net/KyosukeNo1）

这几天在埋头写自己的3D文件浏览器（稍后发布），突发奇想的要把自己的内部格式转化成XML，于是，把以前在研究所时用过的ExPat翻了出来。 ExPat是基于事件的XML解释器，速度挺快的，但结构方面有点不敢恭维－－当年写配置文件的导出导入部分花了我足足1个星期！而且由于它是基于事件发生的次序（SAX），似乎有时会发生一些无法控制的情况－－例如进入某Level后忘了记录，结果……后面的程序全部死掉！这时想起同事之前推荐的 TinyXML，结果……用了不到3小时就把我的文件导出来了～～呵呵。在阅读本文之前，请先看看我Blog里转贴的《TinyXML学习笔记》，相信它能给各位一个关于TinyXML的初步概念。

言归正传，本文目的在于补全之前《TinyXML学习》的不足，尽量把常用的示例代码列出让大家参考。此外，在本篇最后会给出一个完整的文件读写例子，供读者参考。

1. 编程环境的设置。新建一个项目，起名叫TestTXML。到http://sourceforge.net/projects/tinyxml/ 下载TinyXML的官方例子，并编译第一个Project tinyxml（注意，最好编译Release的版本，代码比较小。然后把生成的tinyxml.lib（如果是Debug版本，叫tinyxmld.lib）连同tinystr.h和tinyxml.h一起Copy到TestTXML项目的目录中。在TestTXML项目里的头文件加入对TinyXML的引用：

#pragma comment(lib,"tinyxml.lib") // 链接Library

#include "tinyxml.h" // TinyXML的头文件

2. 建立一个XML文件：

char* sFilePath = "ikk_doc.xml"; // 文件名称

TiXmlDocument xmlDoc( sFilePath ); // 建立一个XML文件

TiXmlDeclaration Declaration( "1.0","gb2312", "yes" ); // 声明XML的属性

xmlDoc.InsertEndChild( Declaration ); // 写入基本的XML头结构

xmlDoc.SaveFile(); // 把XML文件写入硬盘

这时，在硬盘上的TestXML项目目录里，ikk_doc.xml文件已经被创建出来了。

3. 在XML文件里插入Element

所谓的Element，就是在XML里面的Tag，例如在裕作”>简历内容中，“Resume”就是Element的名字，上述的整个字符串就是一个Element。在TinyXML里，插入Element的步骤如下：

TiXmlElement* pElm = NULL;

pElm = new TiXmlElement( "resumes" ); //定义当前的子节点 pElmParent.InsertEndChild( *pElm ); // 把子节点插入父节点中

4. 在element里插入属性。在刚才例子中，name=”裕作”就是Resume的属性，其中name是属性的名字，”裕作”是属性的值。在当前子节点内插入属性的方法如下：

pElm->SetAttribute( "name", resume.sName );

5. 在XML里插入文本。在裕作”>简历内容中，“简历内容”就是一段文本，事实上，在TinyXML里，它是被当作一个Text类型的子节点来插入的。还而言之，就是在Resume的子节点中，插入这个Text子节点。插入例子如下：

TiXmlText* pText = NULL;
pText = new TiXmlText( "简历内容" ); // 定义文本的内容

pElmChild->InsertEndChild( *pText ); //把text子节点插入父节点中

在具备了以上背景知识之后，我们已经可以用TinyXML读写一个XML文件了。本文最后的程序将写入，然后重新读取一个XML文件到我们的结构里。这个XML文件的内容如下：

裕作">

男

编程

吹牛

裕作 The Great">

男

编程

以下程序将建立ikk_doc.xml文件，然后重新把内容读取进内存：

#pragma comment(lib,"tinyxml.lib")

#include "string.h"

#include "stdio.h"

#include "tinyxml.h"

#define XML_FILE "ikk_doc.xml"

#define NAME_LENGTH 256 // 名字类字符的分配长度

#define SAFE_DELETE(x) {if(x) delete x; x=NULL;} // 安全删除new分配出来的变量空间

#define SAFE_DELETE_ARRAY(x) {if(x) delete[] x; x=NULL;} // 安全删除new分配出来的数组空间

#define XML_HEADER "" // XML文件头的定义

typedef unsigned int uint32;

// 技能的结构

typedef struct skill_s {

uint32 nLevel; // 技能的程度

char sName[ NAME_LENGTH ]; // 技能的名称

skill_s() {

nLevel = 0;

sName[0] = 0;

}

} skill_t;

// 简历的结构

typedef struct resume_s {

char sName[ NAME_LENGTH ]; // 名字

bool isMan; // 是否男性

uint32 nAge; // 年龄

uint32 nNumSkill; // 技能的数目

skill_t* pSkill; // 技能的结构

resume_s() {

sName[0] = 0;

isMan = false;

nAge = 0;

nNumSkill = 0;

pSkill = NULL;

}

} resume_t;

void exportSkill( TiXmlElement* pElmParent, skill_t skill )

{

int i;

char sBuf[NAME_LENGTH]; // 一个临时存放的字符串

TiXmlElement* pElm = NULL; // 一个指向Element的指针

TiXmlText* pText = NULL; // 一个指向Text的指针

pElm = new TiXmlElement( "skill" );

// 插入等级（以属性形式）

sprintf( sBuf, "%d", skill.nLevel ); // 把Skill的登记变成字符串临时存进sBuf里

pElm->SetAttribute( "level", sBuf ); // 把等级插入Skill里

// 插入技能名称（以子Element形式）

pText = new TiXmlText( skill.sName ); // 建立一个Skill的子Element（一个Text形式的子元素）

pElm->InsertEndChild( *pText ); // 把这个Skill的子Element插入Skill里

SAFE_DELETE( pText ); // 删除这个Text

// 最后把整个Resume的子节点插入到父节点中

pElmParent->InsertEndChild( *pElm );

}

void importSkill( TiXmlElement* pElm, skill_t* pSkill )

{

int i;

char sBuf[NAME_LENGTH]; // 一个临时存放的字符串

TiXmlElement* pElmChild = NULL; // 一个指向Element的指针

TiXmlText* pText = NULL; // 一个指向Text的指针

// 读取level

pSkill->nLevel = atoi( pElm->Attribute( "level" ) );

// 读取技能名称

strcpy( pSkill->sName, pElm->FirstChild()->Value() );

}

void exportResume( TiXmlElement* pElmParent, resume_t resume )

{

int i;

char sBuf[NAME_LENGTH]; // 一个临时存放的字符串

TiXmlElement* pElm = NULL; // 一个指向Element的指针

TiXmlElement* pElmChild = NULL; // 一个指向Element的指针

TiXmlText* pText = NULL; // 一个指向Text的指针

pElm = new TiXmlElement( "resume" );

// 插入名字（以属性形式）

pElm->SetAttribute( "name", resume.sName );

// 插入性别（以子Element形式）

pElmChild = new TiXmlElement( "gender" ); // 建立一个子Element叫Gender

if( resume.isMan )

pText = new TiXmlText( "男" ); // 建立一个Gender的子Element（一个Text形式的子元素）

else

pText = new TiXmlText( "女" ); // 建立一个Gender的子Element（一个Text形式的子元素）

pElmChild->InsertEndChild( *pText ); // 把这个Gender的子Element插入Gender里

pElm->InsertEndChild( *pElmChild ); // 把Gender插入到主Element里

SAFE_DELETE( pElmChild ); // 删除已经用完的Gender

SAFE_DELETE( pText ); // 删除这个Text

// 插入年龄（以子Element形式）

pElmChild = new TiXmlElement( "age" ); // 建立一个子Element叫Age

sprintf( sBuf, "%d", resume.nAge ); // 把Age变成字符串临时存进sBuf里

pText = new TiXmlText( sBuf ); // 建立一个Age的子Element（一个Text形式的子元素）

pElmChild->InsertEndChild( *pText ); // 把这个Age的子Element插入Age里

pElm->InsertEndChild( *pElmChild ); // 把Age插入到主Element里

SAFE_DELETE( pElmChild ); // 删除已经用完的Age

SAFE_DELETE( pText ); // 删除这个Text

// 插入技能子节点

pElmChild = new TiXmlElement( "skills" ); // 建立一个子Element叫Skills

sprintf( sBuf, "%d", resume.nNumSkill ); // 把Skill的数目变成字符串临时存进sBuf里

pElmChild->SetAttribute( "num", sBuf ); // 把这个Skills的属性插入Skills里

for( i=0; i

{

exportSkill( pElmChild, resume.pSkill[i] ); // 插入一项技能

}

pElm->InsertEndChild( *pElmChild ); // 把Skills插入到主Element里

SAFE_DELETE( pElmChild ); // 删除已经用完的Skills

SAFE_DELETE( pText ); // 删除这个Text

// 最后把整个Resume的子节点插入到父节点中

pElmParent->InsertEndChild( *pElm );

SAFE_DELETE( pElm ); // 删除子节点

}

void importResume( TiXmlElement* pElm, resume_t* pResume )

{

int i;

char sBuf[NAME_LENGTH]; // 一个临时存放的字符串

TiXmlElement* pElmChild = NULL; // 一个指向Element的指针

TiXmlElement* pElmGrandChild = NULL; // 一个指向Element的指针

TiXmlText* pText = NULL; // 一个指向Text的指针

// 读入"resume"子节点

strcpy( pResume->sName, pElm->Attribute( "name" ) );

// 读入"gender"子节点

pElmChild = pElm->FirstChildElement( "gender" );

if( strcmp( "男", pElmChild->FirstChild()->Value() ) == 0 )

pResume->isMan = true;

else

pResume->isMan = false;

// 读入"age"子节点

pElmChild = pElm->FirstChildElement( "age" );

pResume->nAge = atoi( pElmChild->FirstChild()->Value() );

// 读入"skills"子节点

pElmChild = pElm->FirstChildElement( "skills" );

pResume->nNumSkill = atoi( pElmChild->Attribute( "num" ) );

pResume->pSkill = new skill_t[pResume->nNumSkill];

pElmGrandChild = pElmChild->FirstChildElement( "skill" ); // 指向第一个Skill

for( i=0; inNumSkill; i++ ) {

importSkill( pElmGrandChild, &(pResume->pSkill[i]) ); // 读取一个Skill

pElmGrandChild = pElmGrandChild->NextSiblingElement(); // 指向下一个Skill

}

bool readXML( char* sFilePath, int* nNumResume, resume_t** ppResume ) {

int i; // 用做循环的变量

TiXmlElement* pElmChild = NULL; // 一个指向Element的指针

TiXmlDocument xmlDoc( sFilePath ); // 输入XML路径

if( !xmlDoc.LoadFile() ) // 读取XML并检查是否读入正确

return false;

TiXmlElement* pElmRoot = NULL; // 根节点

pElmRoot = xmlDoc.FirstChildElement( "resumes" ); // 得到根节点

if( !pElmRoot ) {

return false;

}

*nNumResume = atoi( pElmRoot->Attribute( "num" ) ); // 读取Resume的数目

*ppResume = new resume_t[*nNumResume]; // 分配Resume的空间

pElmChild = pElmRoot->FirstChildElement( "resume" ); // 找出第一个Resume

for( i=0; i<*nNumResume; i++ ) {

importResume( pElmChild, &((*ppResume)[i]) ); // 读取Resume的内容

pElmChild = pElmChild->NextSiblingElement(); // 找出下一个Resume

}

return true;

}

bool writeXML( char* sFilePath, int nNumResume, resume_t* pResume )
{

if( !sFilePath || !pResume )

return false; // 确定指针存在

int i; // 用做循环的变量

char sBuf[NAME_LENGTH]; // 一个临时存放的字符串

TiXmlElement* pElm = NULL; // 一个指向Element的指针

TiXmlDeclaration Declaration( "1.0","gb2312", "yes" ); // 建立XML头结构

TiXmlDocument xmlDoc( sFilePath ); // 用存档的文件名字来建立一个XML文件

xmlDoc.InsertEndChild( Declaration ); // 把XML头结构插入当前文档

// 插入根节点“Resumes”
pElm = new TiXmlElement( "resumes" ); // 建立根节点“Resumes”
sprintf( sBuf, "%d", nNumResume ); // 把nNumResume变成字符串临时存进sBuf里

pElm->SetAttribute( "num", sBuf ); // 建立一个Resumes的子Element

for( i=0; i<2; i++ )
{
exportResume( pElm, pResume[i] ); // 在根节点上插入以上定义的2个简历
}
xmlDoc.InsertEndChild( *pElm );

xmlDoc.SaveFile();

SAFE_DELETE( pElm ); // 删除Element

return true;

}

void main()

{

int i, j;

// + == 设置两份简历 ==========================================================

int nNumResume = 2;

resume_t* pResume = new resume_t[ nNumResume ];

// 1. 初始化第一份简历

strcpy( pResume[0].sName, "裕作" );

pResume[0].isMan = true;

pResume[0].nAge = 26;

pResume[0].nNumSkill = 2;

pResume[0].pSkill = new skill_t[2];

{ // 设置技能列表结构

strcpy( pResume[0].pSkill[0].sName, "编程" );

strcpy( pResume[0].pSkill[1].sName, "吹牛" );

pResume[0].pSkill[0].nLevel = 99;

pResume[0].pSkill[1].nLevel = 1;

}

// 2. 初始化第二份简历

strcpy( pResume[1].sName, "裕作 The Great" );

pResume[1].isMan = true;

pResume[1].nAge = 0;

pResume[1].nNumSkill = 1;

pResume[1].pSkill = new skill_t[1];

{ // 设置技能列表结构

strcpy( pResume[1].pSkill[0].sName, "编程" );

pResume[1].pSkill[0].nLevel = 100;

}

// - == 设置两份简历 ==========================================================

// 把简历以XML形式写入磁盘

if( !writeXML( XML_FILE, nNumResume, pResume ) )

{

printf( "ERROR: can't write the file." );

return;

}

// 删除Resume

nNumResume = 0;

SAFE_DELETE_ARRAY( pResume );

// 重新读入XML文件里的Resume数据

if( !readXML( XML_FILE, &nNumResume, &pResume ) )

{

printf( "ERROR: can't read the file." );

return;

}

// 把所有简历输出到屏幕

if( pResume ) // 确定有Resume

{

for( i=0; i

printf( "简历：======================\n" );

printf( "\t名字：%s\n", pResume[i].sName );

if( pResume[i].isMan )

printf( "\t性别：男\n" );

else

printf( "\t性别：女\n" );

printf( "\t年龄：%d\n", pResume[i].nAge );

printf( "\t职业技能：\n" );

for( j=0; j

printf( "\t\t技能名称：%s\n", pResume[i].pSkill[j].sName );

printf( "\t\t技能等级：%d\n", pResume[i].pSkill[j].nLevel );

}

[trac]有用的插件

2007-09-28T20:01:00.000+08:00

[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 (已更新)

2007-09-28T19:49:00.000+08:00

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

2007-09-28T19:45:00.002+08:00

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

2007-09-28T19:45:00.001+08:00

解析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在游戏中的作用

2007-09-28T19:45:00.000+08:00

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使用的简单总结

2007-09-28T19:43:00.000+08:00

有关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的使用作了介绍，欢迎各位提问留言，我会尽力解答各位的问题。

如何监测内存泄漏

2007-09-27T17:04:00.000+08:00
如何监测内存泄漏

作者：未知点击：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
以上信息与文章正文是不可分割的一部分,如果您要转载本文章,请保留以上信息，谢谢!

Qt4.2.3编译记录

2007-09-27T14:28:00.001+08:00

Qt4.2.3编译记录
Posted on 2007-06-19 09:27 chemz 阅读(561) 评论(1) 编辑收藏引用所属分类: C++
Qt4.2.3编译记录
Qt已经发布了最新架构的版本Qt4了，目前的最新版本已经到了Qt4.3，由于原来还使用
的是Qt3.3.4的版本，所以就Qt4种的2.3版进行了编译，准备升级到Qt4。这个编译过程一般
而言还算是比较的简单，只是由于Visual Studio 2005在进行了SP1后引入了一个编译bug，
导致编译Qt4时候会出现编译时错误，同时一般而言在Qt4.2.3的编译选项中包含了一些和
Visual Studio2005默认不相同的选项（同时也是标准不太兼容的地方），所以现在将编译
的具体过程进行详细的说明。

1. 设置环境变量
首先肯定是要解压缩Qt4.2.3的源代码包到某个目录下（这里使用的是commercial版本），
如：D:\Qt\4.2.3\。然后在系统环境目录下添加一个QTDIR=D:\Qt\4.2.3环境变量，并且
在系统的PATH追加%QTDIR%\bin目录项，以使得可以找到编译后的库和应用程序。
2. 应用Patch
Qt4中有两个地方需要进行修改才能够正常的编译，一个是关于编译选项的，另外一个是
关于源代码的。
2.1. 修改编译选项
进入到%QTDIR%\mkspecs\win32-msvc2005\目录下，打开qmake.conf文件找到19行的
QMAKE_CFLAGS = -nologo -Zm200 -Zc:wchar_t-，删除后面的-Zc:wchar_t-选项，
主要是为了保持标准兼容性以及和其他代码的兼容性，否则会出现Qt4中采用了
wchar_t的函数不能够接受没有-Zc:wchar_t选项下的wchar_t类型；
2.2. 修改源代码
进入到%QTDIR%\src\corelib\tools\目录下，打开qmap.h文件找到QMultiMap类的
定义，用如下的内容替换replace和insert函数：
typedef QMap::iterator QMap_iterator;
inline QMap_iterator replace(const Key &akey, const T &avalue){ return QMap::insert(akey, avalue); }
inline QMap_iterator insert(const Key &akey, const T &avalue){ return QMap::insertMulti(akey, avalue); }
并将下面的replace和insert函数的定义体给注释掉；
同样的打开qhash.h文件找到QMultiHash类的定义，用如下的内容替换replace和
insert函数：
typedef QHash::iterator QHash_iterator;
inline typename QHash_iterator replace(const Key &akey, const T &avalue){ return QHash::insert(akey, avalue); }
inline typename QHash_iterator insert(const Key &akey, const T &avalue){ return QHash::insertMulti(akey, avalue); }
并将下面的replace和insert函数的定义体给注释掉。
之所以要这样修改是因为Visual Studio2005的SP1所引入的bug导致的。
3. 安装协议文件
要安装商业版本就必须具有安装商业的license，将.qt-license文件拷贝到用户的
%USERPROFILE%目录下，如：C:\Documents and Settings\Administrator\。
4. 配置并编译
打开console窗口，并设置VC的环境变量，然后运行如下的配置命令：
configure -debug-and-release -no-stl -no-sql-sqlite -qt-libjpeg -qt-gif -platform win32-msvc2005
成功后就可以通过运行nmake来完成源代码的完全编译了。
上面的命令行中，根据你的要求可以自行调整，一般而言为了成功编译必须要包含的命令
选项是-debug-and-release和-platform win32-msvc2005两个，其他可以选择。

QT4 和 VS2005 SP1 编译错误 C2244

2007-09-27T12:29:00.001+08:00

QT4 和 VS2005 SP1 编译错误 C2244

Author : sanchaji2

Article ID : 94

Audience : Default

Version 1.00

Published Date: 2007/8/7 6:49:30

Reads : 32

一个BUG的修正，可能引入更多BUG的出现不仅仅是教科书上的套话。今天，我在重新编译QT商业版源代码时，就遇到了这样的一个例子。VS2005安装 SP1补丁后，编译QT4源代码（QT v4.2.2版），编译器报告很多模板方面的致命错误，导致编译失败。通过查询网络可知，这是SP1引入的BUG，微软已经发布了修正补丁，您可以在 http://support.microsoft.com/kb/930198 找到详细信息，另外，微软给出了该错误的详细描述，请参考 http://support.microsoft.com/kb/928957 。

我解决这个问题是通过修改配置文件，使 QT 系统调用 INTEL C++ Compiler 来编译代码避开这个BUG。如果您坚持希望通过MSVC 2005 SP1编译QT源代码，请安装上面提及的补丁，或者参考 thought 的文章修改QT源代码。

下面附上，我这里用到的 bin\qtvars.bat，如果您有微软的 KB930198 补丁，希望您能发送到我的电子邮箱 12985462 at QQ dot com ，谢谢！
下面再附上，一份QT与VS2005-SP1的兼容性修正补丁，不用自己修改了！

@echo off
rem
rem This file is generated
rem

echo Setting up a Qt environment...
echo -- QTDIR set to C:\Qt\4.2.2
echo -- Added C:\Qt\4.2.2\bin to PATH
echo -- QMAKESPEC set to win32-icc

set QTDIR=C:\Qt\4.2.2
set PATH=C:\Qt\4.2.2\bin;%PATH%
set QMAKESPEC=win32-icc

if not "%1"=="vsvars" goto END
call "E:\Program Files\Intel\Compiler\C++\9.1\IA32\Bin\ICLVars.bat"
:END

if not "%1"=="vsstart" goto ENDSTARTVS
call "E:\Program Files\Intel\Compiler\C++\9.1\IA32\Bin\ICLVars.bat"
devenv /useenv
:ENDSTARTVS

下面这份修正补丁来自日本一个专门说明这一问题的博客网页： http://ashula.info/mt/d061216_qt4_msvc8_sp1_problem.html 。

下载: qt4-multi-map-hash-msvc8-sp1.diff
diff -Naur tools_orig/qhash.h tools/qhash.h
--- tools_orig/qhash.h 2006-12-17 03:53:53.406250000 +0900
+++ tools/qhash.h 2006-12-17 05:16:20.921875000 +0900
@@ -848,8 +848,11 @@
QMultiHash() {}
QMultiHash(const QHash &other) : QHash(other) {}

- inline typename QHash::iterator replace(const Key &key, const T &value);
- inline typename QHash::iterator insert(const Key &key, const T &value);
+ // fix for vs2005 SP1
+ // cf. http://forums.microsoft.com/MSDN/ShowPost.aspx?PostID=987536&SiteID=1
+ typedef QHash::iterator QHashItr;
+ inline typename QHashItr replace(const Key &key, const T &value);
+ inline typename QHashItr insert(const Key &key, const T &value);

inline QMultiHash &operator+=(const QMultiHash &other)
{ unite(other); return *this; }
@@ -862,11 +865,11 @@
};

template
-Q_INLINE_TEMPLATE Q_TYPENAME QHash::iterator QMultiHash::replace(const Key &akey, const T &avalue)
+Q_INLINE_TEMPLATE Q_TYPENAME QMultiHash::QHashItr QMultiHash::replace(const Key &akey, const T &avalue)
{ return QHash::insert(akey, avalue); }

template
-Q_INLINE_TEMPLATE Q_TYPENAME QHash::iterator QMultiHash::insert(const Key &akey, const T &avalue)
+Q_INLINE_TEMPLATE Q_TYPENAME QMultiHash::QHashItr QMultiHash::insert(const Key &akey, const T &avalue)
{ return QHash::insertMulti(akey, avalue); }

diff -Naur tools_orig/qmap.h tools/qmap.h
--- tools_orig/qmap.h 2006-12-17 03:53:03.437500000 +0900
+++ tools/qmap.h 2006-12-17 05:16:29.984375000 +0900
@@ -890,8 +890,11 @@
QMultiMap() {}
QMultiMap(const QMap &other) : QMap(other) {}

- inline typename QMap::iterator replace(const Key &key, const T &value);
- inline typename QMap::iterator insert(const Key &key, const T &value);
+ // fix for vs2005 SP1
+ // cf. http://forums.microsoft.com/MSDN/ShowPost.aspx?PostID=987536&SiteID=1
+ typedef QMap::iterator QMapItr;
+ inline typename QMapItr replace( const Key &key, const T &value );
+ inline typename QMapItr insert( const Key &key, const T &value );

inline QMultiMap &operator+=(const QMultiMap &other)
{ unite(other); return *this; }
@@ -904,11 +907,11 @@
};

template
-Q_INLINE_TEMPLATE Q_TYPENAME QMap::iterator QMultiMap::replace(const Key &akey, const T &avalue)
+Q_INLINE_TEMPLATE Q_TYPENAME QMultiMap::QMapItr QMultiMap::replace(const Key &akey, const T &avalue)
{ return QMap::insert(akey, avalue); }

template
-Q_INLINE_TEMPLATE Q_TYPENAME QMap::iterator QMultiMap::insert(const Key &akey, const T &avalue)
+Q_INLINE_TEMPLATE Q_TYPENAME QMultiMap::QMapItr QMultiMap::insert(const Key &akey, const T &avalue)
{ return QMap::insertMulti(akey, avalue); }

解决Visual Studio 2005 SP1编译QT代码的BUG

2007-09-27T12:16:00.000+08:00

解决Visual Studio 2005 SP1编译QT代码的BUG
产品：QT 4.1.4 & QT 4.2.2
平台：Visual Studio 2005 Service Pack 1 (SP1)
错误：error C2244: unable to match function definition to an existing declaration
现象：
在qmap.h头文件中出现：error C2244: 'QMultiMap::insert' : unable to match function definition to an existing declaration
（据说在qhash.h中也会出现）
参考URL：
http://connect.microsoft.com/VisualStudio/feedback/ViewFeedback.aspx?FeedbackID=214100
原因：编译器升级后，分不清嵌套类型的名字是指哪一个，哪怕它们很明显地是同一个类型。例如，如下代码就会引发此错误：
template
class Foo
{
public:
typedef int NestedType;
};
template
class Bar : public Foo
{
public:
typename Foo::NestedType test();
};
template
typename Foo::NestedType Bar::test() // this is where the error lies
{
return 0;
}
微软的解释：
The problem is due to the use of Foo and Bar on the line above; the compiler cannot figure out the relationship between the two template parameters even though they are clearly the same. The workaround is to add a typedef for the NestedType of Bar and use that in the implementation of test
解决方法：
在子类型中再次定义嵌套类型的名字
例如，对于QMultiMap，就是这样子
template
class QMultiMap : public QMap
{
public:
/////////////////////////////////////////////////////////////////////////
//Modified by Kenny
//Purpose: fixed the compiling-time error of Visual Studio 2005 SP1
//Ref: http://connect.microsoft.com/VisualStudio/feedback/ViewFeedback.aspx?FeedbackID=214100
typedef typename QMap::iterator QMapIteratorType;
//End of modification
/////////////////////////////////////////////////////////////////////////
QMultiMap() {}
QMultiMap(const QMap &other) : QMap(other) {}
inline QMapIteratorType replace(const Key &key, const T &value);
inline QMapIteratorType insert(const Key &key, const T &value);
inline QMultiMap &operator+=(const QMultiMap &other)
{ unite(other); return *this; }
inline QMultiMap operator+(const QMultiMap &other) const
{ QMultiMap result = *this; result += other; return result; }
private:
T &operator[](const Key &key);
const T operator[](const Key &key) const;
};
/////////////////////////////////////////////////////////////////////////////
//Modified by Kenny
//Purpose: fixed the compiling-time error of Visual Studio 2005 SP1
//Ref: http://connect.microsoft.com/VisualStudio/feedback/ViewFeedback.aspx?FeedbackID=214100
template
Q_INLINE_TEMPLATE Q_TYPENAME QMultiMap::QMapIteratorType QMultiMap::replace(const Key &akey, const T &avalue)
{ return QMap::insert(akey, avalue); }
template
Q_INLINE_TEMPLATE Q_TYPENAME QMultiMap::QMapIteratorType QMultiMap::insert(const Key &akey, const T &avalue)
{ return QMap::insertMulti(akey, avalue); }
//The old code is commented out as the following lines
//template
//Q_INLINE_TEMPLATE Q_TYPENAME QMap::iterator QMultiMap::replace(const Key &akey, const T &avalue)
//{ return QMap::insert(akey, avalue); }
//
//template
//Q_INLINE_TEMPLATE Q_TYPENAME QMap::iterator QMultiMap::insert(const Key &akey, const T &avalue)
//{ return QMap::insertMulti(akey, avalue); }
//End of modification
/////////////////////////////////////////////////////////////////////////////

充实过好每一天！

批处理 for应用

一、 TinyXml的特点

1. SAX和DOM

2. 验证和非验证

二、 TinyXml的构建和使用

1. 获取

2. 构建

3. 使用

三、 TinyXml的编程模型

1. 类之间的关系

2. 需要注意的问题

四、 总结

实战TinyXML

[trac]有用的插件

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

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

C++解析XML -- TinyXml

解析XML的利器-TinyXML

TinyXml在游戏中的作用

有关TinyXML使用的简单总结

有关TinyXML使用的简单总结

如何监测内存泄漏

Qt4.2.3编译记录

Qt4.2.3编译记录

QT4 和 VS2005 SP1 编译错误 C2244

解决Visual Studio 2005 SP1编译QT代码的BUG

解决Visual Studio 2005 SP1编译QT代码的BUG

四、总结