国产精品成人久久久久久久,久久综合精品国产一区二区三区,996久久国产精品线观看

walkspeed — Fri, 28 Dec 2007 06:01:00 GMT

头文�?regex.hpp

常用的类
boost::regex 正则表达�?br>
boost::cmatch 以char数组为容器，存储匚w��q�回倹{�?br>boost::smatch 以std::string为容器，存储匚w��q�回倹{�?br>
boost::regex_match 匚w��法
boost::regex_search 查找��法
boost::regex_replace 替换��法

��单例�?br>
#include

#include

int main( int argc, char* argv[] )
{
   char *buf = "This is boost::regex example";

   boost::regex exampleregex( "boost::regex" );
   boost::cmatch result;

   if( boost::regex_search( buf, result, exampleregex ) )
   {
       std::cout << result.str() << std::endl;
   }

   return 0;
}

注意regex.hpp的包含。要在开发工具中讄��boost头文件所在位子�?br>

walkspeed 2007-12-28 14:01 发表评论

snmp��Z��用oid来唯一标识对象

walkspeed — Fri, 31 Aug 2007 06:01:00 GMT

要在分布式系�l�中扑ֈ�一个对象，甚至是对象的某个实例�Q�我们必��ȝ��他们一个唯一标识�?br> 可以领用UUID来生成我们需要的唯一标识。但是在snmp中�ƈ没有选着UUID来标识每个对象，而是使用
了自��p��计的Oid。这是�ؓ(f��)何呢�Q�本��为，UUID虽可以唯一表示对象�?qi��ng)其实例�Q�但是UUID之间没有什�?br>关系�Q�不能�Ş成一�U�结构来表示对象之间的关�p�R��而Oid的显现却能满��以上两点，唯一表示对象和显�C?br>对象之间的结构，甚至是对象的实例的唯一标识和实例之间的关系�?br> �q�也�l�我们一个启�C�，分布式系�l�中对象的标识除了具有唯一性外�Q�要有一定显�C�对象之间关�pȝ��?br>力，�?x��)更好�?br>

walkspeed 2007-08-31 14:01 发表评论

接口设计的要点（接口不应被��用者直接销毁）

walkspeed — Tue, 07 Aug 2007 01:49:00 GMT

摘要: 接口的��用者不应该在��用完接口后直接销毁接口，而应该将接口�q�还�l�接口提供者。接口提供者来��理接口的声明周期�?nbsp; 阅读全文

walkspeed 2007-08-07 09:49 发表评论

Boost.Bind的基��使用

walkspeed — Fri, 20 Jul 2007 09:15:00 GMT

当我们��用函数时�?f��n)惯于C函数的格�?卛_��下�Ş�?br>resulttype funname( arglist );
�q�回值类�?函数�? 参数列表 );

在Boost.Function中，我们可以方便的定义定义函数对象。不�q�在定义用来表示�c�L��员函数的函数对象�?br>�W�一个参数是�c�L��针。而且在调用时�Q�要传入一个类实例的指针。这��L(f��ng)��h��q�不是很方便�Q�因��用�?br>要知道类实例。这实际上没有实现解耦。而解耦是我们使用回调或委托设计的一个目标�?br>
��Z��解决�q�个问题�Q�我们要使用Boost.Bind�?br>
Boost.Bind是一个函数对象工厂。他用来产生我们需要的函数对象。好了，有了它，你可以在你设计中�?br>量��用Boost.Function。不用再��d��义类成员函数形式的函数对象啦�Q�只用定义普通函数对象�?br>
一个简单的例子

class CExample
{
public:
    bool printstr( const std::string &str )
    {
        std::cout << "CExample::printstr" << str << std::endl;
        return true;
    }
};

//定义一个函数对�?br>boost::function< bool ( const std::string& ) > printstr;

//用Boost.Bind创徏一个函数对象，赋给printstr
CExample example;
printstr = boost::bind( &CExample::printstr, &example, _1 );

好了�Q�我们创��Z��一个函数对象，而且调用时不再需要类实例拉。用Boost.Function和Boost.Bind大大
的简化了Command模式的实现�?br>
在上面的例子中要个古怪的对象"_1"。这个叫做站位符�Q�他代表�q�个位置有个参数�Q�但现在�q�不知道�?br>数是什么。_1代表参数列表中的�W�一个位�|�上的参数。Boost.Bind一共定义了9个站位符对象。如�?br>_1,_2,_3,_4,_5,_6,_7,_8,_9。分别代表参数列表中位子�?br>
Boost.Bind产生的函数对象可以直接��用，利用上面的例子�?br>
bool b = boost::bind( &CExample::printstr, &example, _1 )( "Hello World" );

walkspeed 2007-07-20 17:15 发表评论

walkspeed — Wed, 18 Jul 2007 05:28:00 GMT

Boost.Function库用来提供一个对象化的函数指针�?br>
函数指针对设计很有用。它使调用者可以�g期调用，调用时机��p��用者确定。而且可以改变
响应者，以应对不同的要求�?br>
C中的函数指针只能用于自由函数。在C++中除了自由函数还有函数对象和�c�L��员函敎ͼ��q�些
C的函数指针是无法用的。这要求能适应C++语言的函数指针。既然C++语言本��n没有提供�Q?br>那就提供一个库。stl提供了，但是定义了很多类型，使用��h��q�不是很方便�Q�而且函数参数
的个数被限定在两个以下，更能是备受限制。Boost.Function库提供了一个好的解��x��案�?br>
Boost.Function库可以支持自由函敎ͼ�函数对象�Q�类成员函数。而且参数个数多达10个�?br>Boost.Function库利用模板技术来实现。生成的代码有很高的�q�行效率。本库可以不用编�?br>直接使用�?br>
Boost.Function的头文�g�?br>function.hpp

定义一个Boost.Function的对象（是一个返回值类型�ؓ(f��)int�Q�第一个参数是std::string�c�d��
�W�二个参数是float�c�L��Q?br>
boost::function< int ( std::string, float ) > funptr;

上面�q�个定义方式是一�U�容易理解的定义方式。但有些�~�译器不支持�Q�如果想更多的编译器
支持�Q�则用下面这�U�定义方�?br>
boost::function2< int, std::string, float > funptr;

注意模板中有3个类型，而function�c�d��是boost::function2。应��回值类型不计算在参�?br>�c�d��中（原因很简单，C++的编译器不会(x��)�Ҏ(gu��)��q�回�c�d��不同来区分函数定义的不同�Q��?br>
int freefun( std::string str, float f )
{
    std::cout << str << " : " << f << std::endl;
    return 0;
}

class CFun
{
public:
    int operator() ( std::string str, float f )
    {
        std::cout << str << " : " << f << std::endl;
        return 0;
    }
}

上面定义了一个自由函数和一个函数对象。下面将把他们付�l�function对象�?br>
赋��gؓ(f��)自由函数
funptr = &freefun;

赋��gؓ(f��)函数对象
CFun fun;
funptr = fun;

以上两种情况的调用方法一��_(d��)��如下
funptr( "float =", 10.0 );

Boost.Function对象要能指向�c�d��原函敎ͼ�其定义要如下

class FreeClass
{
public:
    int out( std::string str, float f )
    {
        std::cout << str << " : " << f << std::endl;
        return 0;
    }
};

boost::function< int ( FreeClass*, std::string, float ) > funptr;

跨��^台的定义�Ҏ(gu��)��
boost::function3< int, FreeClass*, std::string, float > funptr;

赋值方�?br>funptr = &FreeClass::out;

调用�Ҏ(gu��)��
FreeClass fc;

funptr( &fc, "float =", 10.0 );

walkspeed 2007-07-18 13:28 发表评论

领域分析--认识领域分析

walkspeed — Wed, 11 Jul 2007 07:54:00 GMT

领域分析--认识领域分析

软�g分析的开端一般是需求分析。但是在实践中，发现了很多的问题�?br>1 用户的需求�ƈ不是有用��h��出。在和用��h��软�g的风险承担者交谈后�Q�会(x��)常发玎ͼ�他们对自己想要的
软�g�q�不是很清楚�Q�会(x��)提出一些笼�l�的要求。在开发出一个原型后�Q�他们会(x��)修正或更改，甚至推翻他们
的需求。你�?x��)发现是你在不断的提出、完善需求，用户或风险承担者只是在裁决你的需求。而这样下�?br>你的软�g要不断的改，好像遥遥无期�?br>2 需求多是一�U�功能的集合。��Y件出来后�Q�如果有了改动，或在新的��目中去复用以前的��Y件会(x��)发现�?br>难。对每个需求，你不得不从头开始�?br>
领域分析和需求分析不同，它不是面向功能的。而是面向问题的。这有些像考试中解题。针对特定的�?br>题，来提供解��x��案，�q�在�q�个�Ҏ(gu��)��的直接指��g��解出题目。这个直接指导很有意义，应�ؓ(f��)直接指导�?br>�C��题的�Ҏ(gu��)��被应用到解题的�q�程中（��x��可实现的�Q��?br>
领域分析不是对要构造的软�g�q�行全面的分析。而是对��Y件涉�?qi��ng)到的特定的领域�q�行分析�Q�如写多媒体
软�g�Q�你要对韌��频领域进行分析）。而领域是与特定的知识相关联的�Q�如韌��频领域中关于音频、视
频编解码知识�Q�领域分析要搞清楚这个领域中的知识，扑և�各知识点中的关系�Q��ƈ对它们进行抽象，�?br>成模型。领域分析强调的是问题域。这��是说它面对的是一个相对确定的范围。��Y件要解决的是一个相
对确定的范围。也有利于测试��Y件�?br>
领域分析不能代替需求分析，但是可以��q��需求来对特定的领域�q�行分析。领域分析后产生的设计要�?br>接指导实玎ͼ�可以映射到��Y件中。由于领域分析是面对问题的，它��生的软�g不一定能满��需求，可能
�Ҏ(gu��)��对应不上需求。但是它是特定问题的解决�Ҏ(gu��)��Q�可以作��Z��个机制来支持需求的实现。而且特定
的问题或着说这�U�反应某个领域中的知识关�pȝ��软�g其对应的是一�U�稳定的需求，比较�Ҏ(gu��)��复用、测�?br>和发展�?br>
面对需求分析得到是一�U�应用的要求。而根据��Y件涉�?qi��ng)的领域�q�行分析�Q�得到的是它的基本机制。应�?br>是多��L(f��ng)��Q�而机制其实就只有那么几个。根据应用的要求来组合这些机制。这样需求的变化�Q��ƈ不会(x��)�?br>�q�多的冲��M��通过领域分析得到的模型和实现。你要做的是对他们进行组合�?img src ="http://www.shnenglu.com/walkspeed/aggbug/27869.html" width = "1" height = "1" />

walkspeed 2007-07-11 15:54 发表评论

walkspeed — Thu, 31 May 2007 02:50:00 GMT

    new出来的空间如果没有主动销毁，在程序退出时仍可能有内存的泄霌Ӏ?br>操作�pȝ��描述刎ͼ�在进�E�退出时�?x��)销毁它所使用的所有内存空��_(d��)��但这只是
一个模型上的构惛_��描述。在实际的操作系�l�的实现上�ƈ不能做到�q�一炏V�?br>因�ؓ(f��)�Q�要实现在进�E�退出时销毁它所使用的内存空��_(d��)��p��l�每个被使用�?br>内存�I�间打一个标�Q�表�C��D�内存空间被那个�q�程使用。在�q�种情况下，�?br>果有多个使用��内存量的进�E�，�q�且被频�J�的创徏和销毁，那么光记住那�?br>�q�程标致��p��占用很大的内存空��_(d��)��q�是一个很不划��的�Ҏ(gu��)��。所以在实际
中，操作�pȝ��q�没有给每个�q�程使用的内存空间打标。这��P��有些��内存是
没有被回收的�Q�如果多�ơ开兌��个程序就�?x��)发玎ͼ�有内存被大量的占用，�?br>不能被释放�?br>    所以那些在�E�序中只有一个实例，�q�且是被new出来的对象，也应该主�?br>的去手动销毁，而不能依赖程序退出时��q��l�销毁�?br>
    被new出来的对象其销毁是两个步骤�?br>   1 析构对象。条用对象的析构函数�Q�将对象占用的资源释放掉�?br>   2 释放内存。将对象所占用的内存释放掉�?br>
    如果new出来的对象没有被销毁，�?x��)造成�q�个层面上的泄露�?br>    1 对象泄露。他�?x��)造成背对象占用的资源也没有销毁或释放。比如在对象
中占有文件的句柄�Q�在析构时才释放。如果对象泄露了�Q�这个句柄是不会(x��)被释
攄��。那个文件会(x��)一直被占用。如果文件打开时是独占的，那么�?qi��ng)时对象所�?br>的程序退��Z��Q�别的程序也别想讉K��q�个文�g�?br>    2 内存泄露。所占用的内存不能被释放�?

walkspeed 2007-05-31 10:50 发表评论

Berkeley DB在Queue模式下的使用2

walkspeed — Wed, 30 May 2007 05:58:00 GMT

Berkeley DB在Queue模式下的使用

Queue模式��L��据的一个简单的�C�Z��
在Queue模式下读数据�Q�记录（Dbt�Q�要调用set_ulen函数和set_flags函数

#include < time.h >
#include < iostream >
#include < bdb/db_cxx.h >

struct ValueType
{
    int _int;
    char _char;
    char _array[256];
};

void readDB( void )
{
   Db bdb( 0, 0 );

   bdb.set_re_len( sizeof( ValueType ) ); //用Queue模式一定要调用�Q�而且一定要在open前调�?br>   bdb.set_re_pad( 0x00 ); //��Z��字符串的填充�?�?br>
   bdb.open( 0, "SaveRecodeDB.db", 0, DB_QUEUE, DB_CREATE, 0 );

   size_t k;
   ValueType v;
   Dbt key( &k, sizeof( size_t ) );
   key.set_ulen( sizeof( size_t ) );

   Dbt value( &v, sizeof( ValueType ) );
   value.set_ulen( sizeof( ValueType ) );
   value.set_flags( DB_DBT_USERMEM );

   //直接用数据库的读函数
   for( int i=0; i<1000000; ++i )
   {
       bdb.get( 0, &key, &value, DB_CONSUME );
   }

   bdb.close( 0 );
}

int main( int argc, char* argv[] )
{
    clock_t et1 = clock();
    readDB();
    clock_t et2 = clock();

    std::cout << "work is fine, " << "have times : " << et2 - et1 << std::endl;
    return 0;
}

walkspeed 2007-05-30 13:58 发表评论

Berkeley DB在Queue模式下的使用 1

walkspeed — Tue, 29 May 2007 10:03:00 GMT

Berkeley DB在Queue模式下的使用

Queue模式下仅能存储定长的记录�Q�既value的长度�ؓ(f��)定长。Queue的key是一个逻辑增长的数�Q�一般就是int�?br>不需要开发者去改变�q�个�c�d��?br>
Queue模式下只能存储定长的记录。所以一定要调用DB的set_re_length函数来设定数据库中记录的长度�?br>如果没有讑֮��Q�默认的�?。这样当存储记录时一定会(x��)报异常。程序出错�?br>在读取记录时�Q�当记录的长度小于设定的长度�Ӟ��?x��)填充字�W�达到设定长度�?br>默认的字�W��ؓ(f��)0x02�Q�ASCII中的�Q�。可以设定自��q��填充字符。调用DB的set_re_pad�?br>
一个简单的�C�Z��

#include < time.h >
#include < iostream >
#include < bdb/db_cxx.h >

struct ValueType
{
   int _int;
   char _char;
   char _array[256];
};

void writeDB( void )
{
   Db bdb( 0, 0 );

   bdb.set_re_len( sizeof( ValueType ) ); //用Queue模式一定要调用�Q�而且一定要在open前调�?br>   bdb.set_re_pad( 0x00 ); //��Z��字符串的填充�?�?br>
   bdb.open( 0, "SaveRecodeDB.db", 0, DB_QUEUE, DB_CREATE, 0 );

   size_t k;
   ValueType v;
   Dbt key( &k, sizeof( size_t ) );
   Dbt value( &v, sizeof( ValueType ) );

   //直接用数据库的写函数
   for( int i=0; i<1000000; ++i )
   {
       bdb.put( 0, &key, &value, DB_APPEND );
   }

   bdb.close( 0 );
}

int main( int argc, char* argv[] )
{
   clock_t et1 = clock();
   writeDB();
   clock_t et2 = clock();

   std::cout << "work is fine, " << "have times : " << et2 - et1 << std::endl;
   return 0;
}

在Queue模式下不能用游标�q�行数据的插入。只能进行数据的修改�?br>

walkspeed 2007-05-29 18:03 发表评论

Berkeley DB对�ƈ发的支持

walkspeed — Sat, 26 May 2007 08:17:00 GMT

Berkeley DB对�ƈ发的支持

要让Berkeley DB数据支持�q�发�Q�就要创建Berkeley DB的环境（environment�Q?br>环境�c�L�� DbEnv。要支持�q�发�Q�在初始化DbEnv时要用DB_INIT_CDB、DB_INIT_MPOOL
两个标致�?br>
如下

DbEnv env�Q?br>env.open( "evn", DB_INIT_CDB|DB_INIT_MPOOL, 0 );

然后在创建数据库�Ӟ��环境传�l�数据库。如�?br>
Db bdb( &env, 0 );

�q�样��可以支持�ƈ发了�?br>
Berkeley DB�q�发的简单原�?br>Berkeley DB的�ƈ发遵循的是允许同时多个读操作�Q�当只有一个写操作�?br>1 每个游标有一锁，非游标的��d��用一�?br>2 写操作等待所有的读锁解锁�?br>3 ��L��作不需要等待写锁解锁�?

walkspeed 2007-05-26 16:17 发表评论

walkspeed — Sat, 26 May 2007 03:26:00 GMT

Berkeley DB的访问方法有四种BTree、Hash、Queue、Recno
他们在DB创徏旉��择�Q�而且只能在创建时选择。一炚w��定某一个访问方法，
在��用中不能改变�?br>
BTree 数据被存储在一个排序的�q��?w��i)结构中。key和value都可以是��单数
据（如整型，字符�Ԍ��Q�也可以是复杂数据（如结构）。当有多个数据的key
相同�Ӟ��可以有复本�?br>
Hash 数据存储在一个扩展的�U�性hash表中。其他的�Ҏ(gu��)��象BTree�?br>
Queue 数据存储在一个队列中�Q�记录是定长的。key��Z��个逻辑敎ͼ�不由用户
选择�c�d��。在��N��插入记录�Q�在头部删除记录和取��录非常的快。提供了
记录水��^�~�，提高在�ƈ发下的访问�?br>
Recno 数据可以是定常或是变长的记录。其他特性象Queue。key也是一个逻辑数�?br>
数据库访问方法的选择�?br>�Ҏ(gu��)��key可否用户定义分�ؓ(f��)BTree、Hash一�l�，Queue、Renco一�l��?br>
BTree与Hash之间的选择
如果数据量不�Q�能被放到内存中。这�U�情况下选择BTree。即在小数据量的情况�?br>选用BTree�Q�原因是在利用key来定��录时�Q�成功的几率大些。Hash有退步算法�?br>
但是在大数据量的情况下，�׃��数据�q�不能都在数据库中，要访问磁盘，�q�且BTree
要维护的内部信息大于Hash�Q�访问磁盘的几率大于Hash�Q�会(x��)造成讉K��的瓶颈。所�?br>在大数据量下选择Hash�?br>
Queue与Recno之间的选择
用在多�ƈ发下最好用Queue。但是如果记录是变长的，��只能选Recno了。在其它的情
况下�Q�两者没有明昄��差别�?br>
Berkeley DB支持从非常小的数据库�?56T的数据容量的数据库。单个key或recode
最大可以�ؓ(f��)4G的数据�?br>
Berkeley DB的数据库被存储�ؓ(f��)二进制的格式�Q�有利于�q�_��的移植�?br>
Berkeley DB支持�q�发的访问，但是不能用在NSF�Q�网�l�文件系�l�）下。因为无法定位和
获得数据库的环境�Q�在环境中设�|�对�q�发的控�Ӟ��?br>
Berkeley DB的环境（Environments�Q�提供了以下的功�?br>1 多数据库文�g�Q�Multi-database files�Q�。将多个数据存储在一个物理文件中�?br>2 提供多线�E�或多进�E�的支持�Q�Multi-thread and multi-process support�Q��?br>3 事务处理
4 高可用性（重复性）支持。即一个主数据库，和多个提供只读能力的复制数据�?br>5 日志子系�l��?

walkspeed 2007-05-26 11:26 发表评论

walkspeed — Fri, 25 May 2007 07:30:00 GMT

C++标准库中用来计算旉��差的函数
头文�?< time.h >

double difftime(
   time_t timer1,
   time_t timer0
);
double _difftime32(
      __time32_t timer1,
   __time32_t timer0
);
double _difftime64(
   __time64_t timer1,
   __time64_t timer0
);

C++标准库用来格式化输出旉��字符�?br>头文�?< time.h >

size_t strftime(
   char *strDest,
   size_t maxsize,
   const char *format,
   const struct tm *timeptr
);
size_t _strftime_l(
   char *strDest,
   size_t maxsize,
   const char *format,
   const struct tm *timeptr,
   _locale_t locale
);
size_t wcsftime(
   wchar_t *strDest,
   size_t maxsize,
   const wchar_t *format,
   const struct tm *timeptr
);
size_t _wcsftime_l(
   wchar_t *strDest,
   size_t maxsize,
   const wchar_t *format,
   const struct tm *timeptr,
   _locale_t locale
);

The formatting codes for strftime are listed below:

%a
    Abbreviated weekday name

%A
    Full weekday name

%b
    Abbreviated month name

%B
    Full month name

%c
    Date and time representation appropriate for locale

%d
    Day of month as decimal number (01 – 31)

%H
    Hour in 24-hour format (00 – 23)

%I
    Hour in 12-hour format (01 – 12)

%j
    Day of year as decimal number (001 – 366)

%m
    Month as decimal number (01 – 12)

%M
    Minute as decimal number (00 – 59)

%p
    Current locale's A.M./P.M. indicator for 12-hour clock

%S
    Second as decimal number (00 – 59)

%U
    Week of year as decimal number, with Sunday as first day of week (00 – 53)

%w
    Weekday as decimal number (0 – 6; Sunday is 0)

%W
    Week of year as decimal number, with Monday as first day of week (00 – 53)

%x
    Date representation for current locale

%X
    Time representation for current locale

%y
    Year without century, as decimal number (00 – 99)

%Y
    Year with century, as decimal number

%z, %Z
    Either the time-zone name or time zone abbreviation, depending on registry settings; no characters if time zone is unknown

%%
    Percent sign

walkspeed 2007-05-25 15:30 发表评论

walkspeed — Fri, 25 May 2007 06:47:00 GMT

C++标准库中string�c�M��用的注意�?br>
在string�c�M��间进行复制没有什么问题�?br>但是要拷贝到内存中时��p��注意。一定要在string取出的长度上�?�?br>
如下

char buf[256];
std::string str = "1234567890";

memcpy( buf, str.c_str(), str.length()+1 );

�q�样才能拯��到字�W�串的结束符‘0’。要不就拯��不到�?br>string的length函数只计��有效字�W�的长度。如同C中的strlen函数�?

walkspeed 2007-05-25 14:47 发表评论

在工作中�Ҏ(gu��)��件操作引发的��x��

walkspeed — Thu, 24 May 2007 08:42:00 GMT

文�g是一�U�资源�?br>��对象要依附与某个资源�?br>
所以在C++标准库中�Q�流都是不可拯��的和赋值的�?br>一个类有了��对象成员，那么它也��׃��可拷贝和赋��g��?br>如果�q�行了拷贝和赋��g��(x��)出现�q�行旉��误�?br>
�q�也表现了一�U�设计范型�?br>资源只能在资源的使用者中保存其应用。�ƈ在资源的使用者环境中创徏�?br>不同使用者之间只传递资源的描述�Q�而不直接传递资源�?br>
例如�?br>一个类要��用文件�?br>只传递给�q�个�c�L��件的描述�Q�如文�g名，偏移量等�{��?br>而不传个他一个文件�?br>
�q�个�c�d��Ҏ(gu��)��q�些描述来开启文件。对其操作�?

walkspeed 2007-05-24 16:42 发表评论

tm�l�构中每个字�D늚�解释

walkspeed — Wed, 23 May 2007 04:02:00 GMT

tm�l�构中每个字�D늚�解释

tm�l�构中的每个�D�|��一个int�c�d��

tm_sec �U�钟�?�Q?9�?br>tm_min 分钟�?�Q?9�?br>tm_hour ��时�?�Q?3】。是从午夜开始计时。UTC下是是以格林威治为标�?�Q�local下是以本地时��Zؓ(f��)标准0.
gmtime�q�回的是UTC�Q�localtime�q�回的是本地�?br>tm_mon 月䆾�?�Q?1】。注意是0�?1.而不是常用的1�?2.
tm_year �q�䆾。是�?900�q�开始计��。即记录的是本年�?900�q�的差倹{�?br>tm_wday 表示在一个星期中的第几天�?�Q?�?br>tm_yday 表示一�q�中的第几天�?�Q?65】，1�?日�ؓ(f��)0
tm_isdst 不清楚，文档中只是说在gmtime下�ؓ(f��)0

walkspeed 2007-05-23 12:02 发表评论

walkspeed — Tue, 22 May 2007 02:00:00 GMT

��tm�l�构的��D�{换�ؓ(f��)一个time_t�c�d��的�?br>�?2位系�l�中time_t是一个long�?br>头文�?

time_t mktime(
   struct tm *timeptr
);
__time32_t _mktime32(
   struct tm *timeptr
);
__time64_t _mktime64(
   struct tm *timeptr
);

获得�pȝ��旉��?br>头文�?
In Visual C++ 2005, time is a wrapper for _time64 and time_t is, by default, equivalent to __time64_t.
If you need to force the compiler to interpret time_t as the old 32-bit time_t, you can define _USE_32BIT_TIME_T.
This is not recommended because your application may fail after January 18, 2038; the use of this macro is not allowed on 64-bit platforms.

time_t time(
   time_t *timer
);
__time32_t _time32(
   __time32_t *timer
);
__time64_t _time64(
   __time64_t *timer
);

��时间�{换成一个字�W�串
头文�?

char *ctime(
   const time_t *timer
);
char *_ctime32(
   const __time32_t *timer )
;
char *_ctime64(
   const __time64_t *timer )
;
wchar_t *_wctime(
   const time_t *timer
);
wchar_t *_wctime32(
   const __time32_t *timer
);
wchar_t *_wctime64(
   const __time64_t *timer
);

��时间�{换成一个字�W�串
是个安全的版本，用来替代上面的函�?br>头文�?

errno_t ctime_s(
   char* buffer,
   size_t sizeInBytes,
   const time_t *time
);
errno_t _ctime32_s(
   char* buffer,
   size_t sizeInBytes,
   const __time32_t *time
);
errno_t _ctime64_s(
   char* buffer,
   size_t sizeInBytes,
   const __time64_t *time )
;
errno_t _wctime_s(
   wchar_t* buffer,
   size_t sizeInWords,
   const time_t *time
);
errno_t _wctime32_s(
   wchar_t* buffer,
   size_t sizeInWords,
   const __time32_t *time
);
errno_t _wctime64_s(
   wchar_t* buffer,
   size_t sizeInWords,
   const __time64_t *time
);
template
errno_t _ctime32_s(
   char (&buffer)[size],
   const __time32_t *time
); // C++ only
template
errno_t _ctime64_s(
   char (&buffer)[size],
   const __time64_t *time
); // C++ only
template
errno_t _wctime32_s(
   wchar_t (&buffer)[size],
   const __time32_t *time
); // C++ only
template
errno_t _wctime64_s(
   wchar_t (&buffer)[size],
   const __time64_t *time
); // C++ only

��时间��D�{换成一个结�?br>头文�?

struct tm *gmtime(
   const time_t *timer
);
struct tm *_gmtime32(
   const time32_t *timer
);
struct tm *_gmtime64(
   const __time64_t *timer
);

��时间��D�{换成一个结�?br>头文�?
同上面函数的功能�Q�是安全版本

errno_t _gmtime_s(
   struct tm* _tm,
   const __time_t* time
);
errno_t _gmtime32_s(
   struct tm* _tm,
   const __time32_t* time
);
errno_t _gmtime64_s(
   struct tm* _tm,
   const __time64_t* time
);

��时间�{换成本地旉��?br>头文�?

struct tm *localtime(
   const time_t *timer
);
struct tm *_localtime32(
   const __time32_t *timer
);
struct tm *_localtime64(
   const __time64_t *timer
);

��时间�{换成本地旉��?br>头文�?
同上面函数的功能�Q�是安全版本

errno_t _localtime_s(
   struct tm* _tm,
   const time_t *time
);
errno_t _localtime32_s(
   struct tm* _tm,
   const time32_t *time
);
errno_t _localtime64_s(
   struct tm* _tm,
   const _time64_t *time
);

clock函数
头文�?
clock_t clock( void );

walkspeed 2007-05-22 10:00 发表评论

walkspeed — Sun, 20 May 2007 04:06:00 GMT

输入��的��d��多个字符的操作多用read�?br>read的定义�Ş式如�?br>basic_istream& read( char_type *_Str, streamsize _Count );

char_type* 是流字符�c�d��的指针，�q�个指针是用来存储要��d��的字�W?br>的位�|��?br>streamsize 是存储空间大��的�c�d��Q�多位long�?br>
重点在返回值的�c�d��Q�是一个输入流�c�d��的应用。不是实际的��d��数据的长度�?br>要获得实际的��d��长度要调�?gcount函数。定义如�?br>streamsize gcount( ) const;

要获得当前读取的位置要调用tellg函数。定义如�?br>pos_type tellg( );
惌��知道以一��p��取了多少数据��可以用�q�个函数�?br>tellg�?x��)蟩�q�格式符。即�q�回的位�|�是跌��控制�W�的�?br>�q�就是说几个gcount的和不一定等于tellg的倹{��所�?br>用来��定��d��位置时一定要用tellg函数。而不能用
gcount的和�Q�在偏移�Q�这�?x��)��生不对的位置�?br>
看下面的例子
int main( int argc, char* argv[] )
{
   std::ifstream ifile;

   char buf[10];

   ifile.open( "example.txt" ); //examplet.txt文�g中每行有一个回车符

   ifile.read( buf, 10 );
   size_t size = ifile.tellg(); //size�?1
   size = ifile.gcount(); //size�?0

   ifile.read( buf, 10 );
   size = ifile.tellg(); //size�?2
   size = ifile.gcount(); //size�?0

   if( ifile.eof() )
   {
       return -1;
   }
   ifile.close();

   return 0;
}

��d��q�程中可能会(x��)出现问题�Q�流是不保证��d��q�程的完整性。即要读多少数据�Q?br>在对到这么多的数据后才返回�?br>�q�要求编�E��h员去判断��的当前状态。再�q�行下面的处理�?br>
good函数知道当前状态是好的。即上一个操作成功。可以进行下一个操作�?br>fail函数表示上一个操作失败。但��还没有完全破坏�Q�可以进行一些处理�?br>bad函数表示��被破坏啦，别想了。不要在处理�q�个��拉�?br>eof函数表示已到��的��N��。不用再往下读拉。不�?x��)读出数据的�?br>
int main( int argc, char* argv[] )
{
   std::ifstream ifile;

   char buf[10];

   ifile.open( "example.txt" ); //examplet.txt文�g中每行有一个回车符
   ifile.seekg( 0, ios::end );
   ifile.close();

    ifile.open( "example.txt" );

    //�q�是成立的。说明状态�ƈ没有应�ؓ(f��)文�g的关闭而改变。只要这个对�?br>    //的还?g��u)zȝ��Q�他的上一个状态将保持。而�v�?x��)对下面的操作��生媄响�?br>    //除非你清除或修改了状态�?br>    if( ifile.eof() )
    {
        ifile.close();
        return -1;
    }

    ifile.close();

    return 0;
}

walkspeed 2007-05-20 12:06 发表评论

用WTL作界面开�?

walkspeed — Wed, 09 May 2007 03:59:00 GMT

WTL中的�H�口消息的映��和自定义窗口消息映��?br>
�H�口消息的映��是通过宏MESSAGE_HANDLER完成的�?br>MESSAGE_HANDLER�Q?消息ID�Q�消息处理函�?�Q��?br>自定义的消息也是通过�q�个宏来映射�?br>
��d��H�口消息函数后的对话框的定义如下
#include < atlapp.h >
#include "resource.h"

const int WM_MY_MESSAGE = WM_USER+1; //自定义消息ID

class CMainDialog : public CDialogImpl< CMainDialog >
{
public:
   enum { IDD = IDD_MAINDLG };

public:
   BEGIN_MSG_MAP( CMainDialog )
       MESSAGE_HANDLER( WM_INITDIALOG, OnInitDialog ) //�pȝ��的窗口消息映��，�H�口初始化消�?br>       MESSAGE_HANDLER( WM_MY_MESSAGE, OnMyMessage ) //自定义消息的映射
       COMMAND_ID_HANDLER( IDOK, OnOk ) //控�g消息的映��?br>       COMMAND_ID_HANDLER( IDCANCEL, OnCancel )
       COMMAND_ID_HANDLER( IDC_SENDMESSAGE_BUTTON, OnSendMyMessage ) //用来发送自定义消息的按钮消息映��?br>   END_MSG_MAP()

public:
    //�H�口初始化消息映��函敎ͼ��q�是个窗口系�l�消�?br>   LRESULT OnInitDialog(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL& bHandled)
   {
       // center the dialog on the screen
       CenterWindow();

       return TRUE;
   }

   LRESULT OnOk( WORD wNotifyCode, WORD wID, HWND hWndCtl, BOOL &bHandled )
   {
       EndDialog( wID );
       return 0;
   }

   LRESULT OnCancel( WORD wNotifyCode, WORD wID, HWND hWndCtl, BOOL &bHandled )
   {
       EndDialog( wID );
       return 0;
   }

   //发送自定义消息
   LRESULT OnSendMyMessage( WORD wNotfyCode, WORD wID, HWND hWndCtl, BOOL &bHandled )
   {
       //ATL::CWindow的SendMessage的调�?br>       SendMessage( WM_MY_MESSAGE );
       return 0;
   }

   //处理自定义消�?br>   LRESULT OnMyMessage( UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL& bHandled )
   {
       //ATL::CWindow的MessageBox的调�?br>       MessageBox( "This is MyMessage Handle" ); //弹出个对话框
       return 0;
   }
};

walkspeed 2007-05-09 11:59 发表评论

用WTL作界面开�?

walkspeed — Wed, 09 May 2007 03:18:00 GMT

WTL创徏对话框�?br>要用到头文�g atlapp.h

对话框的定义如下
#include < atlapp.h >
class CMainDialog : public CDialogImpl< CMainDialog >
{
    //用户代码
}

CDialogImpl�c�L��WTL中的模式对话框的基类。他利用了奇异自递归模板技术，来获得��承类的实际行为�?br>有了定义我们要给�q�个对话框一个窗口资源。很��单，只要代码中定义一个IDD的枚��N��可以了�?br>枚�D量的��gؓ(f��)�H�口资源的ID。对话框的定义代码演化�ؓ(f��)如下
#include < atlapp.h >
class CMainDialog : public CDialogImpl< CMainDialog >
{
public:
    enum { IDD=IDD_MAINDLG };//一定要在public域，否则没办法访问，�~�译时报�?br>    //用户代码
}

��p��栯��行编译，�~�译器会(x��)报错�Q�说CMainDialog是个抽象�c�，不能实例化�?br>其原因是ProessWindowMessage函数是个抽象地�?br>我们是不是要手动��d��q�个函数呢？可以。但对于�~�写代码来说�q�不方便�?br>�q�里要用到ATL中的消息映射宏了�?br>BEGIN_MSG_MAP( �c�d�� )
END_MSG_MAP()
有了�q�两个宏对后�Q�就自动的添加了ProessWindowMessage函数了，而且��d��消息映射的函��C��方便�?br>现在对话框的定义代码演化为如下了
#include < atlapp.h >
class CMainDialog : public CDialogImpl< CMainDialog >
{
public:
    enum { IDD=IDD_MAINDLG };//一定要在public域，否则没办法访问，�~�译时报�?br>
public:
    BEGIN_MSG_MAP( CMainDialog )
    END_MSG_MAP()
    //用户代码
}

有了以上代码�Q�对话框��可以显现在屏幕上了。但是这个对话框没有办法推出�Q�应为没有一个消息映��函数�?br>接不到推出的消息�?br>我们有添加两个消息映��，分别对应界面上的OK按钮和Cancel按钮。这两个是button控�g�Q�我们用控�g的消息映��?br>COMMAND_ID_HANDLER( ID, Fun )�?br>��d��消息映射后的对话框类定义如下
#include < atlapp.h >
class CMainDialog : public CDialogImpl< CMainDialog >
{
public:
    enum { IDD=IDD_MAINDLG };//一定要在public域，否则没办法访问，�~�译时报�?br>
public:
    BEGIN_MSG_MAP( CMainDialog )
        COMMAND_ID_HANDLER( IDOK, OnOk )
        COMMAND_ID_HANDLER( IDCANCEL, OnCancel )
    END_MSG_MAP()

public:
    LRESULT OnOk( WORD wNotifyCode, WORD wID, HWND hWndCtl, BOOL &bHandled )
    {
        EndDialog( wID );//推出对话�?br>        return 0;
    }

    LRESULT OnCancel( WORD wNotifyCode, WORD wID, HWND hWndCtl, BOOL &bHandled )
    {
        EndDialog( wID );//推出对话�?br>        return 0;
    }
    //用户代码
};

walkspeed 2007-05-09 11:18 发表评论

用WTL作界面开�?

walkspeed — Wed, 09 May 2007 02:42:00 GMT

�E�序的进入函��C��是C/C++的进入函数main�Q�而是微��Y的进入函数winMain。其形式如下
int WINAPI _tWinMain( HINSTANCE hInstance, HINSTANCE hPrevInstance, LPTSTR lpCmdLine, int nShowCmd )
{
    //用户代码
    ...............
    return 0;
}

WTL是在ATL的基��上发展�v来的�Q�要用到ATL中的模块�c�CComModule,所以要初始化COM库�?br>初始化COM库调用CoInitialize�Q�卸载COM库调用CoUninitialize。程序�Ş式如�?br>#include < atlbase.h >

int WINAPI _tWinMain( HINSTANCE hInstance, HINSTANCE hPrevInstance, LPTSTR lpCmdLine, int nShowCmd )
{
    CoInitialize�Q?NULL �Q?//用于应用�E�序
    //用户代码
    ...............

    CoUninitialize�Q�）;
    return 0;
}

WTL的应用程序部分的代码��装在了CAppModule中。要定义一个CAppModule的全局变量�Q�保证在�E�序启动前就被构造好
CAppModule是��承的ATL中的CComModule�c�R��程序�Ş式演变成如下
#include < atlbase.h >
#include < atlapp.h > //WTL要用到的

int WINAPI _tWinMain( HINSTANCE hInstance, HINSTANCE hPrevInstance, LPTSTR lpCmdLine, int nShowCmd )
{
    CoInitialize�Q?NULL �Q?//用于应用�E�序
    _Module.Init( NULL, hInstance );//初始化一个应用程�?br>    //用户代码
    ...............
    _Module.Term();//销�?br>    CoUninitialize�Q�）;
    return 0;
}

walkspeed 2007-05-09 10:42 发表评论

walkspeed — Wed, 02 May 2007 09:04:00 GMT

C++标准库中的文件流�c�L��供的各种操作中没有直接获得正在操作的文�g的大��的函数。要获得文�g大小得�{个弯�Q�用如下的方�?br> 假设我们有了一个已�l�打开的文件对象ifile�?br> 先将文�g内的位置指针�U�d��文�g��?br> ifile.seekg( 0, ios::end );
再读取当前位�|�，�q�就是文件的大小了�?br> long filelength = ifile.tellg();

walkspeed 2007-05-02 17:04 发表评论

walkspeed — Wed, 02 May 2007 08:57:00 GMT

通过文�g��读取数�?br>ifstream�c�M��表读文�g对象�Q�所有的��L��作都在这个类中�?br>
read成员函数�Q�用来读取数据到指定的buf中�?br>�q�个成员函数来至basic_istream�c�R�?br>函数原型�Q�来直MSDN文档�Q?br>basic_istream& read( char_type *_Str, streamsize _Count );
_Str 字符指针
_Count 要读取的字符数量

get成员函数�Q�用来读取一个或多个字符
�q�个成员函数来至basic_istream�c�R�?br>函数原型�Q�来直MSDN文档�Q?br>int_type get( ); ��d��一个字�W�，不过是作为int�c�d��q�回
basic_istream& get( char_type& _Ch ); ��d��一个字�W?br>basic_istream& get( char_type *_Str, streamsize _Count ); ��d��指定数量的字�W?br>basic_istream& get( char_type *_Str, streamsize _Count, char_type _Delim ); ��d��指定数量的字�W�，但与��C��_Delim相同的字�W�就停止
basic_istream& get( basic_streambuf *_Strbuf );
basic_istream& get( basic_streambuf *_Strbuf, char_type _Delim );

peek成员函数�Q�用来返回下一个字�W�，当不从istream的buf中移�?br>�q�个成员函数来至basic_istreamlei�?br>函数原型�Q�来至MSDN文档�Q?br>int_type peek( );

getline成员函数�Q�用来读取一行数�?br>�q�个成员函数来至basic_istream�c?br>函数原型�Q�来至MSDN文档�Q?br>basic_istream& getline( char_type *_Str, streamsize _Count );
basic_istream& getline( char_type *_Str, streamsize _Count, char_type _Delim );

readsome成员函数�Q�用于读取指定数量的数据到buf�?br>�q�个函数来至basic_istream�c�R�?br>函数原型�Q�来至MSDN文档�Q?br>streamsize readsome( char_type *_Str, streamsize _Count );

>>�q�算�W�重�?br>对C++基本�c�d��q�行了重载操作。可以直接读取这些数据。但�?x��)蟩�q�控制字�W��?br>用户可以扩展�q�个�q�算�W�操作的�c�d��?br>�q�个��d��是有�c�d��的�?br>

walkspeed 2007-05-02 16:57 发表评论

walkspeed — Wed, 02 May 2007 05:31:00 GMT

C++ STL中的�Ҏ(gu��)��件操作的�c?br>ifstream 用于��L��?br>ofstream 用于写文�?br>fstream 用于��d��文�g

打开文�g
可以在够高文件流对象时直接打开
ifstream ifile( 文�g�?)
ofstream ofile( 文�g�?)
fstream file( 文�g�?)

也可以用open行�ؓ(f��)
ifstream ifile
ifile.open( 文�g�?)
ofstream ofile
ofile.open( 文�g�?)
fstream file
file.open( 文�g�?)

关闭文�g
文�g对象销毁时自动关闭文�g�?br>也可用close关闭文�g�?br>ifile.close()
ofile.close()
file.close()

文�g大开攑ּ�标致
�q�写标致定义在iso_base�c�M��。分别如�?br>in     打开�Q�用于读取（�q�是ifstream的缺省模式）
out    打开�Q�用于改写（�q�是ofstream的缺省模式）
app    写入是始�l�添加与��
ate    打开文�g之后令读写位�|�移��x��件尾�?br>trunc ��先前的文�g内容�U�除
binary 二进制方式打开
�q�些标致和或在一赗��?br>�q�些标致作�ؓ(f��)对象构造或open行�ؓ(f��)的第二个参数�Q�来定义文�g打开分方式�?br>
随机存储
用于��L��件的随机存储
tellg�Q�）     �q�回��d��的位�|?br>seekg( pos ) 从当前位�|�移动pos个位子（�l�对�U�送）
seekg( offset, rpos ) 以rpos位置开始移动offset个位�|�（相对�U�d��Q?br>
用于写文件的随机存储
tellp()       �q�回写入的位�|?br>seekp( pos ) 从当前位�|�移动pos个位子（�l�对�U�送）
seekp( offset, rpos ) 以rpos位置开始移动offset个位�|�（相对�U�d��Q?br>
��L��?br>利用read行�ؓ(f��)
ifstream ifile
ifile.read�Q�buf,length�Q?br>
写数�?br>利用write行�ؓ(f��)
ofstream ofile
ofile.write�Q�buf,length�Q?

walkspeed 2007-05-02 13:31 发表评论

Signal中用来管理slot的管理器

walkspeed — Wed, 25 Apr 2007 07:18:00 GMT

Signal�?x��)安优先�U�的不同来调用不同组�?/span>slot。这栯��?/span>signal能根据不同的优先�U�来��理slot�l�。典型的实现�Ҏ(gu��)��是用std::map。将其定义�ؓ(f��)如下形式std::map< int, slot >。由于每个优先��下可能有一�l?/span>slot�Q�所以要��这一�l?/span>slot�l�织��C��L(f��ng)��理，�?/span>boost signal中��?/span>std::list来管理，其可能的形式大体如下std::list< slot >。这样就要修改刚才定义的map了，修改后的map可能的定义如�?/span>std::map< int, std::list< slot > >�?/span>

在实际的boost signal中�ƈ没有直接的存�?/span>slot�Q?/span>boost signal库中有个slot�c�）�Q�而是存储�?/span>function�Q?/span>boost function�cȝ��对象�Q�对象。而且��Z��方便控制signal�?/span>function之间的联�p�，引入�?/span>connection�c�，用来表示signal�?/span>function之间的联�p�R�?/span>Connection的对象当然和一�?/span>function攑֜�了一赗��这�?/span>boost signal提供了一�?/span>connection_slot_pair�c�L��存储一�?/span>function�?/span>connection寏V��这样在boost signal中一�?/span>slot�l�的实际定义如下std::list< connection_slot_pair >。�ƈ且被重定义�ؓ(f��)group_list�c�d��Q?/span>typedef std::list group_list�Q�。相应的�?/span>boost signal�?/span>map的实际定义如�?/span>std::map�Q��ƈ且被重定义�ؓ(f��)slot_container_type�Q?/span>typedef std::map slot_container_type�Q�。将以上的这些东西组�l�到一个类中，以便于管理。这个类��是named_slot_map�?/span>Signal中真正用来管�?/span>slot的管理器�?/span>

Named_slot_map的类数据成员如下定义�Q?/span>boost源码中的一部分�Q�数据成员部分）

class BOOST_SIGNALS_DECL named_slot_map

{

public:

typedef named_slot_map_iterator iterator;//named_slot_map容器的�P代器

private:

typedef std::list group_list;//function connection对组�c�d��

typedef std::map slot_container_type;//容器�c�d��

typedef slot_container_type::iterator group_iterator;//容器�q�代器类�?/span>

typedef slot_container_type::const_iterator const_group_iterator;

slot_container_type groups;//定义一个用来管�?/span>function connection�l�的容器对象

group_iterator back;//容器的�P代器对象

};

Named_slot_map也是一个容器�?/span>Stl的容器�ؓ(f��)了外界方便访问容器内数据单元�Q�提供了�q�代器�?/span>Named_slot_map也有自己的�P代器。这个�P代器��是named_slot_map_iterator�c�R�?/span>Named_slot_map提供了以下方法来获得�q�代�?/span>iterator begin()�Q?/span>iterator end()�?/span>Begin�Ҏ(gu��)��提供首�P代器�Q?/span>end�Ҏ(gu��)��提供��P代器。向容器中插入数据用insert。清除某个数据用而而然erase�Q�清�I�容器中的所有数据用clear�?/span>

walkspeed 2007-04-25 15:18 发表评论

由signal的一些东西联惛_��了AM

walkspeed — Tue, 24 Apr 2007 11:36:00 GMT

　　敏捷开发中提倡依赖关�p�d��置�Q�即�Q�依赖接口而非具体�c�，�Q��用接口的对象定义接口�?br>　　boost signal中的signal的模板参数是个函数类型。可以将其看成一个接口。signal对象依赖�q�个接口�Q�而且是有signal定义的。具体类��d��现镇��歌接口�Q�即实现�q�个函数�c�d��Q?br>　　signal和slot框架�l�成了一个observer模式的实现。signal是出版者，slot是订阅�?

walkspeed 2007-04-24 19:36 发表评论

walkspeed — Mon, 23 Apr 2007 08:57:00 GMT

　　本以为slot��是被signal存储�q�管理的slot。但是通过解读boost的源代码发现�q�个�c�dƈ没有被signal直接��理�Q�而仅仅用来构造了下connection。没有发现其他的用途。如果这��P��那�ؓ(f��)何不直接在signal的connect中直接进行connection的构造呢�?br>　　signal的connect函数没有直接接收function对象�Q�而是接收的slot<>对象�Q�而slot<>对象用来接收function。这个function看来未必一定是个函数对象了。可以是个原始函数或�c�d��C��?�q�个猜测要证实了才能��定。即便如此，�q�个�cȝ��作用是有限的。不�q�关于那个tackeable的用法还没有完全高清楚，可能那是�q�个�c�d��在的理由�Q�也�总�后会(x��)有什么的发展。但现在��实看不��Z��么大的用途�?br>　　奇怪于��Z��在signal中的slot��理器，不去直接��理slot<>的实例，而是��理connection和function的pair�?/p>

　　个�h觉得在slot<>中的最有用处的函数�?br>void slot_base::create_connection()
{
basic_connection* con = new basic_connection();

{
  con->signal = static_cast(this);
  con->signal_data = 0;
  con->blocked_ = false ;
  con->signal_disconnect = &bound_object_destructed;
}

data->watch_bound_objects.reset(con);

scoped_connection safe_connection(data->watch_bound_objects);

for(std::vector::iterator i = data->bound_objects.begin();
  i != data->bound_objects.end(); ++i)
{
  BOOST_SIGNALS_NAMESPACE::detail::bound_object binding;
  (*i)->signal_connected(data->watch_bound_objects, binding);

BOOST_SIGNALS_NAMESPACE::detail::auto_disconnect_bound_object disconnector(binding);

con->bound_objects.push_back(binding);
disconnector.release();
}

safe_connection.release();
data->watch_bound_objects.set_controlling(true);
}

walkspeed 2007-04-23 16:57 发表评论

得到�c�L��据成员的位置

walkspeed — Sun, 08 Apr 2007 02:54:00 GMT

        �cȝ��数据成员的布局是按某种��序的，有一个相对与�cȝ��头位子的偏移量，�q�个偏移量的计算�Ҏ(gu��)��如下�Q?br>
        (size_t)&(((classname*)0)->members)

        classname 是一个类名，members是类中�Q何一个数据成员的名字�?在这里是一个地址�Q�这是一个保留地址�Q�它不能作�ؓ(f��)左��|��但可以作为右��|��L��取其中的对象�?br>        �?地址位，构造了一个classname的结构布局�?br>
        在��用中��L��ơ写�q�个表达式还是很�ȝ��的。可以用个宏��其包�v来，如下

        #difine offsetof( ClassName, MemberName ) (size_t)&(((classname*)0)->members)

        其实�q�个宏在windows和linux�q�_��下都以提供了�?

walkspeed 2007-04-08 10:54 发表评论

walkspeed — Sat, 07 Apr 2007 08:28:00 GMT

以下的东西是我在�|�上看到的东西，摘抄下来的，忘了出处。先向�A(ch��)献者表�C�感�?br>
thinking in c++ 之static��结
本的含义是：(x��)“位置不变的某个东�?#8220;�Q�这里指的是内存中的位置或者文件中的可见�?br>1�Q�在c和c++中，static的两�U�含义：(x��)
�Q?�Q�，静态存储�?br>�Q?�Q�，对一个特定的�~�译单元来说是本地的�Q�这个名字在�q�个单元或类之外不可见�?/p>

2�Q�static对象��存储在�E�序的静态存储区中，而不是在堆栈中。这个对象只在汉书第一�ơ调用是初始化，其后不用再初始化�?/p>

3�Q�对于静态对象的初始化，零赋值只寚w��定义对象有效�Q�用戯��定义的类型必��ȝ��构造函数初始化�?/p>

4�Q�静态对象的析构函数在程序的main()函数退出时�Q�或者标准c函数exit()调用时才被调用。在析构函数中调用exit()是很危险的，因�ؓ(f��)�q�样可能引�v��d�@环�?/p>

5�Q�静态对象的销毁是按它们初始化的相反顺序进行的。全局对象��L��在main()执行之前被创建。如果一个包含静态对象的函数从没有被调用�q�，那么�q�个对象的构造函数就没有被执行，所以也��׃��?x��)调用析构函�?/p>

6�Q�一个被明确声明为static的对象或函数的名字对�~�译单元来说是局部变量，�q�些名字有内部连接。类声明和局部变量没有联接�?/p>

7�Q�extern表示该名字对所有的�~�译单元是可见的�Q�用static和extern限定的对象��L��ȝ��在静态数据区

8�Q�普通函数是外部�q�接�?/p>

9�Q�类的静态成员拥有一块单独的存储�?而不��我们创��Z��多少个该�cȝ��对象�Q�这��׃ؓ(f��)�q�些了创��Z��一个通信的方法�?/p>

10�Q�静态成员的定义必须出现在外部，而且只能有一��?/p>

11�Q�一个类的静态常量可以被用作一个编译时帔R��

12�Q�在局部类(在函数内部定义的�c�）中不能有静态数据成员�?/p>

13�Q�静态成元函敎ͼ�(x��)
�Q?�Q�，静态成元函��Cؓ(f��)该类的全体服务，而不是�ؓ(f��)�cȝ��部分对象服务�Q?br>�Q?�Q?静态成员函��C��能访问一般的数据成员�Q�只能访问静态数据成员，�q�且只能调用静态成元函数�?/p>

14�Q��ؓ(f��)什么静态成元函��C��能访问一般的数据成员�Q�也不能调用普通的成员函数?
�׃��当前对象的地址是被隐藏的传递给被调用的函数的，�׃��静态成员函��C��是某个对象独有的�Q�所以没有this指针�Q�所以无法调用调用普通成员函敎ͼ�同样�Ҏ(gu��)��通成员变量的讉K��也用��C��this指针�?br>
�~�译单元
�l�过预处理之后的文�g�Q�这个是内存中的临时文�g�Q?br>#include在预处理时被展开�Q�宏也一�?/p>

一个经�q�展开后的.cpp文�g��是一个编译单�?/p>

一个xx.h�Q�经�q�预处理�Q?+ 一个xx.cpp = 一个编译单�?br>一个编译单元（�l�过�~�译�Q? xx.obj
整个�E�序的多�?obj加�v�?�l�过链接) = .exe�Q�可执行文�g�Q?

预处�?br>-----------
把一些带#��L(f��ng)��Q�比方说宏定义，预处理命令（#include�Q�等

内部�q�接与外部连�?br>在说内部�q�接与外部连接前�Q�先说明一些概��c�?

　　1.声明

　　一个声明将一个名�U�引入一个作用域;

　　在c++中，在一个作用域中重复一个声明是合法�?

　　以下都是声明�Q?

int foo(int,int); //函数前置声明

typedef int Int; //typedef 声明

class bar; //�c�d��|�声�?

extern int g_var; //外部引用声明

class bar; //�c�d��|�声�?

typedef int Int; //typedef 声明

extern int g_var; //外部引用声明

friend test; //友员声明

using std::cout; //名字�I�间引用声明

friend test; //友员声明

using std::cout; //名字�I�间引用声明

int foo(int,int); //函数前置声明

　　在同一个作用域中你可以多次重复�q�些声明�?

　　有两�U�声明不能重复，那就是类成员函数�?qi��ng)静态数据成员的声明

class foo
{
　static int i;
　static int i;//不可�?
　public:
　　int foo();
　　int foo();//不可�?
};

2.定义

　　一个定义提供一个实�?�c�d��、实例、函�?在一个作用域的唯一描述�?/p>

　　在同一作用域中不可重复定义一个实体�?/p>

　　以下都是定义�?/p>

int y;

class foo ;

struct bar ;

foo* p;

static int i;

enum Color;

const double PI = 3.1415;

union Rep;

void test(int p) {};

foo a;

bar b;

　　3.�~�译单元

　　当一个c或cpp文�g在编译时�Q�预处理器首先递归包含头文�Ӟ��形成一个含有所有必要信息的单个源文�?�q�个源文件就是一个编译单元。这个编译单元会(x��)被编译成��Z��个与cpp文�g名同名的目标文�g(.o或是.obj)。连接程序把不同�~�译单元中��生的�W�号联系��h��Q�构成一个可执行�E�序�?/p>

　　4.自由函数

　　如果一个函数是自由函数�Q�那么这个函��C��是类的成员函敎ͼ�也不是友元函数�?/p>

　　下面来看内部�q�接和外部连�?/p>

　　内部�q�接�Q�如果一个名�U�对于它的编译单元来说是局部的�Q��ƈ且在�q�接时不�?x��)与其它�~�译单元中的同样的名�U�相冲突�Q�那么这个名�U�有内部�q�接(注：(x��)有时也将声明看作是无�q�接的，�q�里我们�l�一看成是内部连接的)�?/p>

　　以下情况有内部连�?

　　a)所有的声明

　　b)名字�I�间(包括全局名字�I�间)中的静态自由函数、静态友元函数、静态变量的定义

　　c)enum定义

　　d)inline函数定义(包括自由函数和非自由函数)

　　e)�cȝ��定义

　　f)名字�I�间中const帔R��定义

　　g)union的定�?/p>

　　外部�q�接:在一个多文�g�E�序中，如果一个名�U�在�q�接时可以和其它�~�译单元交互�Q�那么这个名�U�就有外部连接�?/p>

　　以下情况有外部连�?

　　a)�c�非inline函数��L��外部�q�接。包括类成员函数和类静态成员函�?/p>

　　b)�c�静态成员变量��L��外部�q�接�?/p>

　　c)名字�I�间(包括全局名字�I�间)中非静态自由函数、非静态友元函数及(qi��ng)非静态变�?/p>

　　下面举例说明�Q?/p>

　　a)声明、enum定义、union定义有内部连�?/p>

　　所有的声明、enum定义�?qi��ng)union定义在编译后不会(x��)产生�q�接�W�号�Q�也��是在不同编译单元中有相同名�U�的声明�?qi��ng)enum、union定义�q�不�?x��)在�q�接时发生发现多个符��L(f��ng)��错误�?/p>

// main.cpp

typedef int Int; //typedef 声明�Q�内部连�?/p>

enum Color; //enum定义,内部�q�接

union X //union定义�Q�内部连�?br>{
　long a;
　char b[10];
};

int main(void)
{
Int i = red;
return i;
}

// a.cpp

typedef int Int; //在a.cpp中重声明一个int�c�d��别名�Q�在�q�接时不�?x��)发生错�?br>enum Color; //在a.cpp中重定义了一个enum Color�Q�在�q�接时不�?x��)发生错�?br>const Int i =blue; //const帔R��定义�Q�内部连�?br>union X //union定义�Q�内部连�?br>{
　long a;
　char b[10];
};

　　b)名字�I�间中静态自由函数、静态友元函数、静态变量、const帔R��定义有内部连�?/p>

// main.cpp

namespace test
{
　int foo(); //函数声明�Q�内部连�?br>　static int i = 0; //名字�I�间静态变量定义，内部�q�接
　static int foo() { return 0;} //名字�I�间静态函数定义，内部�q�接
}

static int i = 0; //全局静态变量定义，内部�q�接
static int foo() {return 1;} //全局静态函数定义，内部�q�接
const int k = 0; //全局const帔R��定义�Q�内部连�?br>int main(void)
{
　return 0;
}

//a.cpp

namespace test
{
　int i = 0; //名字�I�间变量定义�Q�外部连�?br>　int foo() {return 0;} //名字�I�间函数定义�Q�外部连�?br>}

int i = 0; //全局变量定义�Q�外部连�?br>int k = 0; //全局变量定义�Q�外部连�?br>int foo() { return 2;} //全局函数定义�Q�外部连�?

　　在全局名字�I�间中，main.cpp中定义了静态变量i,帔R��k,�?qi��ng)静态自由函数foo�{�，�q�些都有内部�q�接。如果你��这些变量或函数的static或是const修饰�W�去掉，在连接时��׃��(x��)现multiply defined symbols错误�Q�它们与a.cpp中的全局变量、全局函数发生冲突�?/p>

c)�c�d��义��L��内部�q�接,而非inline�c�L��员函数定义��L��外部�q�接�Q�不��个成员函数是静态、虚拟还是一般成员函敎ͼ��c�静态数据成员定义��L��外部�q�接�?

　　1.�cȝ��定义有内部连接。如果不是，惌��一下你�?个cpp文�g中include定义了类Base的头文�g�Q�在4个编译单元中的类Base都有外部�q�接�Q�在�q�接的时候就�?x��)出错�?/p>

　　看下面的例子:

//main.cpp

class B //�c�d��义，内部�q�接
{
　static int s_i; //静态类成员声明�Q�内部连�?
　public:
　　void foo() { ++s_i;} //�c�inline函数�Q�内部连�?br>};
struct D
{
　void foo(); //�c�L��员函数声明，内部�q�接
};

int B::s_i = 0; //�c�静态数据成员定义，外部�q�接
void D::foo() //�c�L��员函数定义，外部�q�接
{
　cout << "D::foo in main.cpp" <
}

int main() //main函数�Q�全局自由函数�Q�外部连�?br>{
　B b;
　D d;
　return 0;
}

//a.cpp

class B
{
　int k;
};

struct D
{
　int d;
};

　　在这个例子中�Q�main.cpp与a.cpp中都有class B和class D的定义，但在�~�译�q�两个cpp文�g时�ƈ不发生link错误�?/p>

　　2.�cȝ��非inline成员函数(一般，静态，虚拟都是)��L��外部�q�接�Q�这样当你include了某个类的头文�g�Q��用这个类的函数时�Q�就能连接到正确的类成员函数上，�l�箋以上面�ؓ(f��)例子�Q�如果把a.cpp中的struct D改�ؓ(f��)

struct D //�c�d��?br>{
　int d;
　void foo(); //�c�L��员函数声�?br>};
void D::foo() //�c�L��员函数定义，外部�q�接
{
　cout << " D::foo in a.cpp" <
}

　　�q�时main.cpp与a.cpp中的D::foo都有外部�q�接�Q�在�q�接��׃��(x��)出现multiply defined symbols错�?

　　3.�cȝ��静态数据成员有外部�q�接�Q�如上例的B::s_i,�q�样当你在main.cpp中定义了�c�静态数据成员，其它�~�译单元若��用了B::s_i,��׃��(x��)�q�接到main.cpp对应�~�译单元的s_i�?/p>

　　d)inline函数��L��内部�q�接�Q�不��个函数是什么函�?/p>

// main.cpp

inline int foo() { return 1;} //inline全局函数�Q�内部连�?br>class Bar //�c�d��义，内部�q�接
{
　public:
　　static int f() { return 2;} //inline �c�静态函敎ͼ�内部�q�接
　　int g(int i) { return i;} //inline �c�L��员函敎ͼ�内部�q�接
};

class Base
{
　public:
　　inline int k()�Q?//�c�L��员函数声明，内部�q�接
}�Q?/p>

inline int Base::k(){return 5;} //inline �c�L��员函敎ͼ�内部�q�接
int main(void)
{
　return 0;
}

　　如果你的Base�c�L��定义在Base.h中，而Base的inline 函数是在Base.cpp中定义的�Q�那么在main.cpp中include "Base.h"�~�译不会(x��)出现问题�Q�但在连接时�?x��)找不到函数k�Q�所以类的inline函数最好放到头文�g中，让每一个包含头文�g的cpp都能扑ֈ� inline函数�?/p>

　　现在对c++中的�q�接有了一个认识，能清楚的知道是什么原因��生连接时错误。当你在�q�接时��生连接不到的错误�Q�这说明所有的�~�译单元都没有这个实体的外部�q�接�Q�当你在�q�接时发现有多个�q�接实体�Q�这说明有多个编译单元提供了同名的有外部�q�接的实体。同�Ӟ��在进行程序设计时�Q�也要注意不要��只有本编译单元用到的函数、类、变量等有外部连接，减少与其它编译单元的�q�接冲突�?/p>

　　不过在这里没有说明template函数�?qi��ng)template class的连接性，�q�且对一些特别的情况也没有作��?比如inline函数不能被inline)�?br>

walkspeed 2007-04-07 16:28 发表评论

walkspeed — Sat, 07 Apr 2007 08:24:00 GMT

�~�译单元�Q�是代码的物理组�l��Ş式。有时在单个�?#8216;.h’�?#8216;.cpp’的编写中看没有问题的代码�Q�在�~�译单元中就是有问题的。特别是软�g规模大时�?br>
�~�译器不�?x��)去�~�译'.h'或�?.hpp'文�g�?br>�~�译器只�?x��)编�?.c'�?.cpp'文�g�?/p>

'.h'�?.hpp'里的代码�?x��)�?include宏添加到'.c'�?.cpp'文�g中�?br>�q�个�q�程发生在预�~�译期，预编译器�Q�现在好像没有这个东西了�Q�都
在编译器中完成）完成�q�䆾工作�?/p>

一�?.c'�?.cpp'是一个编译单元。编译器��其��译成二�q�制代码�?/p>

walkspeed 2007-04-07 16:24 发表评论

walkspeed — Sat, 07 Apr 2007 08:20:00 GMT

�q�是我在看boost MPL时试着��译的东西，现在贴上来�?br>
A metafunction is a class or a class template that represents a function invocable at compile-time.
一个原操作是在�~�译器表��C��调用操作的一个类或一个模板类�?/p>

An non-nullary metafunction is invoked by instantiating the class template with particular template parameters (metafunction arguments);
一个非无参的原操作被一个有详细模板参数的模板类��h��Q?br>the result of the metafunction application is accessible through the instantiation's nested type typedef.
原操作应用的�q�回值是一个通过模板�c�d��例可取的内嵌的类型定义�?/p>

All metafunction's arguments must be types (i.e. only type template parameters are allowed).
所有的原操作的参数必须是类型�?/p>

A metafunction can have a variable number of parameters.
一个原操作能有一个数量变化的参数

A nullary metafunction is represented as a (template) class with a nested type typename member.
一个无参数原操作被表现为有内嵌重命名类型的�c?/p>

原操作的三种表达式（f是一个原操作�Q?br>1 f::type
2 f<>::type
3 f< a1,..,an >::type

Lambda Expression 构造和分配表达�?/p>

A Lambda Expression is a compile-time invocable entity in either of the following two forms:
一个构造和分配表达式是下面两个中的一个编译期调用单元

Metafunction Class
原操作类

Placeholder Expression
站位�W�表辑ּ�

Most of the MPL components accept either of those, and the concept gives us a consice way to describe these requirements.
大部分的MPL�l��g接收它们其中一个，

walkspeed 2007-04-07 16:20 发表评论

国产精品成人久久久久久久,久久综合精品国产一区二区三区,996久久国产精品线观看

snmp��Z��用oid来唯一标识对象

接口设计的要点（接口不应被��用者直接销毁）

Boost.Bind的基���使用

领域分析--认识领域分析

Berkeley DB在Queue模式下的使用2

Berkeley DB在Queue模式下的使用 1

Berkeley DB对�ƈ发的支持

在工作中�Ҏ(gu��)��件操作引发的��x��

tm�l�构中每个字�D늚�解释

用WTL作界面开�?

用WTL作界面开�?

用WTL作界面开�?

Signal中用来管理slot的管理器

由signal的一些东西联惛_��了AM

得到�c�L��据成员的位置

Boost.Bind的基��使用