在线欧美小视频,美国成人直播,久久狠狠亚洲综合

在Visual Studio 2005下��用CPPUnit向导

Stone Jiang — Fri, 04 Aug 2006 07:35:00 GMT

使用CPPUnitProjectWizard向导创徏支持使用CPPUnit的测试类的Visual Studio 2005��目�?/p>

安装向导
0. 下蝲 CPPUnitProjectWizard
http://cppunit.sourceforge.net/cppunit-wiki/CppUnitVisualStudio2005Wizard?action=AttachFile&do=get&target=CPPUnitProjectWizard.7z

1. 复制文�g
     CPPUnitProjectWizard.vsdir - 为向导命�?br />     CPPUnitProjectWizard.vsz    - 让VS8知道从哪里找到向�?br />    到您的Visual Studio 8安装目录下的 VSProjects 文�g夹中�?br />
2. 把整个CPPUnitProjectWizard解决�Ҏ��文�g夹复制到您的Visual Studio 8安装目录下的VCWizards文�g夹中�?br />   比如�Q�我攑֜�c:\Program Files\Microsoft Visual Studio 8\VC\VCWizards\CPPUnitProjectWizard\CPPUnitProjectWizard
   或者，也可以放在你��x��|�的其它地方�Q�然后编译CPPUnitProjectWizard.vsz�Q�定义参�?ABSOLUTE_PATH
   Param="ABSOLUTE_PATH = c:\Program Files\Microsoft Visual Studio 8\VC\VCWizards\CPPUnitProjectWizard\CPPUnitProjectWizard"

3. 该项目需要定义环境变�?CPPUNITDIR
   比如�Q�我的环境变量�?%CPPUNITDIR% = D:\cppunit-1.12.0
   最后，修改环境变量 %PATH%,在PATH路径中，增加 %CPPUNITDIR%/lib�Q�以便程序加载时能找�?cppunit_dll.dll
4. 在开发环境中�Q�设�|�好Include/Lib路径
    %CPPUNITDIR%\Include
    %CPPUNITDIR%\LIB

Stone Jiang 2006-08-04 15:35 发表评论

面向对象vs��Z��对象

Stone Jiang — Sun, 25 Jun 2006 08:18:00 GMT

面向对象vs��Z��对象

看到了一�U�说法，很多所谓面向对象开发只不过是基于对象的开�?wbr>。反思自�w�，发觉一针见血�?/wbr>

我们所谓的面向对象�Q�实际上只不�q�封装了业务对象�Q�分��Z��层次�Q�提供了接口。虽然在设计和实现的时候��用到了面向对象的��装�Q�但现在看来�q�算不上真正的面向对象，只能��是��Z��对象而已�?/wbr>

面向对象的原则�ƈ没有�W�合。面向对象的优势也没有发挥，反而感觉一个小变化��q��扯到多层的变动，�ȝ��。就好比��d��的项目，数据库采用ORACLE�Q�实际本�w�对ORACLE�q�不熟悉�Q�只�l�过不到一周的学习�Q�就上马了。结果只不过��ORACLE当成MSSQL使用。ORACLE的强大不但没有体玎ͼ�到现在也没有搞明白）�Q�反而失��M��MSSQL的好的经验。得不偿失�?

不过�Q�如何才��真正的面向对象呢？想了想一个好的面向对象的实践�Q�应该是辑ֈ�最大限度的软�g复用�Q��ƈ且可以快速适应不断变化的需求，而对已有的部分媄响最��?wbr>�?/wbr>

�q�不是一�y�而就的事情，如果想真正的用项目来实践的话�Q�正��的步骤也许应该是：

首先采用本��n较熟悉的开发方法（��Z��对象或是面向�q�程�Q�满��业务需�?wbr>。这一步很关键�Q�只有有了这样一个原型才可以验证寚w��求的满��E�度。个人感觉直接面向对象会陷入设计�q�度�Q��ƈ且在前期耗费大量�?wbr>�_�֊�。更重要的是使用不熟悉的技术会带来风险�Q�得不偿失�?/wbr>

然后逐渐的将采用真正的面向对象的�Ҏ��现有的原型�q�行重构。目的是提高性能�Q�灵�z�L�?wbr>�Q�扩展性，可复用性等�{�，�q�是一个长期的不断�q�代的过�E�。可以参看经典的《重�?改善代码质量》�?/wbr>

最后一步是架构的提点{��将�pȝ��中的可以外部复用的部分提炼出来�Ş�?wbr>一个可以复用的框架架构。有了它�Q�以后的开发相会事半功�?wbr>。此步骤��会用到重构和设计模式。整个的�q�程除了�W�一步和面向对象无大关系外，后两步则完全的面�?wbr>对象的思想�?/wbr>

在此之前��L��希望先有一个设计良好的架构�Q�一直这样不断的学习和进行实��c��结果却不尽人意。经验说明这样做��实有些本末倒置。正如模式的使用一�?wbr>�Q�在动机不明��的情况下盲目的套用模式是没有意义的�?/wbr>

每一个开发�h员的脑袋中有一些非常美妙的创意�Q�这些创意没有实现的一个原因就是，太过��x��l�节。对于面向对象还是基于对象开发，对于实现需求，完成��目的初期阶�D�，真的无所谓。当需要考虑提高开发和�l�护效率的时候，面向对象��成了很不错的选择�?/div>

Stone Jiang 2006-06-25 16:18 发表评论

�E�序员的八荣八�?-- 来源不详

Stone Jiang — Thu, 08 Jun 2006 03:03:00 GMT

�E�序员的八荣八�?/p>

以塌实编码�ؓ�?以心��气�w��ؓ�?/p>

以详�l�注释�ؓ�?以注释残�~�Zؓ�?/p>

以勤于测试�ؓ�?以懒于测试�ؓ�?/p>

以简明文档�ؓ�?以冗余文档�ؓ�?/p>

以注重团队�ؓ�?以孤傲自大�ؓ�?/p>

以刻苦钻研�ؓ�?以敷衍了事�ؓ�?/p>

以善于�ȝ�� 以不思进取�ؓ�?/p>

以质效�ƈ�q��ؓ�?以单取其一��?/p>

Stone Jiang 2006-06-08 11:03 发表评论

关于用例的随�W?

Stone Jiang — Tue, 06 Jun 2006 07:56:00 GMT

http://www.shnenglu.com/ace/archive/2006/06/06/8214.html

�q�来因工作需要，我细阅读了一些与UML相关的书�c��?/p>

�q�里�Q�以��水帐的方式�Q�作一��L��录�?/p>

关于用例�Q?/p>

1. 用例��x��需求，但需求�ƈ不是用例�?br /> 用例是描�q�讨论的�pȝ��(SuD)功能性需求的�Q�所以可以说用例��是需求。但需求除了功能性需求，�q�有非功能性需求。所以，不能说需求就是用例�?/p>

2. 用例不等于功�?br /> 用例是描�q�系�l�功能的�Q�但用例不是功能。功能是�pȝ��要达到或满��的目标，用例是用例的执行�?Actor)与系�l�交互的操作序列。两者是有差异的�?/p>

3. 用例是文本而不是图�?br /> 用例是描�q�执行者与�pȝ��交互的操作序列，要体现它的执行者在与系�l�交互��生的可观查的价倹{��图形仅仅是用例的概�q�ͼ�只画图是不够的。由于这一点，用例建模是撰写文档的�q�程�Q�而不是画囄��q�程�?/p>

4. 用例模型不仅仅是��h加随�?br /> 用例模型不仅是需求方面的工�g(artifact)�Q�它�q�包括补充说�?描述非功能需求的)�Q�词汇表�Q�愿景和业务规则。这些合在一��h��是需求分析的产物�?/p>

5. 用例技术无��d��象技术，在通过用例发现�Q�描�q�ͼ��理需求的时候，用不到对象技术。但是，用例是面向对象的分析和设计的关键需求�?/p>

6. 用例必须有一个主执行�?(Primary actor)
��L��行者确定了用例的名�U�。用例命令通常是以��L��行者视角的��d��语态的�q�宾�l�构的短语。因为只有这��L��短语才能充分的描�q�出�pȝ��的�h倹{��用例徏模的核心��是要描�q�出�pȝ��的�h倹{�?/p>

7. 三种�c�d��的执行�?br />   基本执行�?(Primary actor) :�q�种用例通过与系�l�交互能辑ֈ�目标
   支持执行�?(Supporting actor ) : ��论的�pȝ��Q�SuD)提供服务
   �q�后执行�?(Offstage actor ) :除了上述两种�Q�又对上�q�C��U�执行者与�pȝ��交互�q�程和结果感兴趣的�h或物�?/p>

Stone Jiang 2006-06-06 15:56 发表评论

Stone Jiang — Sun, 04 Jun 2006 04:18:00 GMT

Here's a partial list of acronyms in alphabetical order:

AFAICS = As far as I can see
BTW = By the way
FWIW = For what it's worth
FYI = For your information
HAND = Have a nice day
IMHO = In my humble opinion (egoless)
IMAO = In my arrogant opinion (oodles of ego)
IMNSHO = In my not-so humble opinion (a lot of ego)
IMO = In my opinion (not much ego)
KUTGW = Keep up the good work
MYOB = Mind your own business
OO = Object-oriented
OTOH = On the other hand
PEBCAC = Problem exists between chair and computer
PEBCAK = Problem exists between chair and keyboard
PMFJI = Pardon me for jumping in
RTFM = Read the ___ manual
SO = Significant other (as in, "My SO and I went for a walk...")
SSO = Small String Optimization (where short strings don't use the heap)
YHBT = You have been trolled
YHL = You have lost

Stone Jiang 2006-06-04 12:18 发表评论

关于用例模式的一句话评论

Stone Jiang — Fri, 02 Jun 2006 01:33:00 GMT

用例模式一�l�经�q�实践证明，能更�_��地反应真旉��求的模式集合�Q�正��地使用它，能很好地把用例�{化到工作的系�l�中�q�且更易于维护；使用�q�些模式�Q�构架设计师、系�l�分析员、开发工�E�师以及��理人员�Q�能像��用框杆一��h��自己数十�q�艰苦努力获得的知识和经验用于更快地获得更好的结果�?br />

书籍推荐 "Use Cases Patterns and Blueprints"

By Gunnar Övergaard, Karin Palmkvist

Publisher	: Addison Wesley Professional
Pub Date	: November 12, 2004
ISBN	: 0-13-145134-0
Pages	: 464

Stone Jiang 2006-06-02 09:33 发表评论

static_cast<>揭密 (�?

Stone Jiang — Mon, 22 May 2006 13:18:00 GMT

static_cast<>揭密

作者：Sam NG

译者：��刀�?/a>

原文链接�Q?a >What static_cast<> is actually doing

本文讨论static_cast<> �?reinterpret_cast<>�?

介绍
大多�E�序员在学C++前都学过C�Q��ƈ且习惯于C风格�Q�类型）转换。当写C++�Q�程序）�Ӟ��有时候我们在使用static_cast<>和reinterpret_cast<>时可能会有点模糊。在本文中，我将说明static_cast<>实际上做了什么，�q�且指出一些将会导致错误的情况�?br />
泛型�Q�Generic Types�Q?/strong>

float f = 12.3;
float* pf = &f;
// static cast<>
// 成功�~�译, n = 12
int n = static_cast(f);
// 错误,指向的类型是无关的（译注�Q�即指针变量pf是float�c�d��Q�现在要被�{换�ؓint�c�d��Q? //int* pn = static_cast(pf);
//成功�~�译
void* pv = static_cast(pf);
//成功�~�译, 但是 *pn2是无意义的内存（rubbish�Q?br /> int* pn2 = static_cast(pv);
// reinterpret_cast<>
//错误,�~�译器知道你应该调用static_cast<>
//int i = reinterpret_cast(f);
//成功�~�译, 但是 *pn 实际上是无意义的内存,�?*pn2一�?br /> int* pi = reinterpret_cast(pf);
��而言之，static_cast<> ��尝试�{换，举例来说�Q�如float-�?integer�Q�而reinterpret_cast<>��单改变编译器的意��N��新考虑那个对象作�ؓ另一�c�d��?br />
指针�c�d��Q�Pointer Types�Q?/strong>

指针转换有点复杂�Q�我们将在本文的剩余部分使用下面的类�Q?br />
class CBaseX
{
public:
int x;
CBaseX() { x = 10; }
void foo() { printf("CBaseX::foo() x=%d\n", x); }
};
class CBaseY
{
public:
int y;
int* py;
CBaseY() { y = 20; py = &y; }
void bar() { printf("CBaseY::bar() y=%d, *py=%d\n", y, *py); }
};
class CDerived : public CBaseX, public CBaseY
{
public:
int z;
};
情况1�Q�两个无关的�c�M��间的转换

// Convert between CBaseX* and CBaseY*
// CBaseX* �?CBaseY*之间的�{�?br /> CBaseX* pX = new CBaseX();
// Error, types pointed to are unrelated
// 错误�Q?�c�d��指向是无关的
// CBaseY* pY1 = static_cast(pX);
// Compile OK, but pY2 is not CBaseX
// 成功�~�译, 但是 pY2 不是CBaseX
CBaseY* pY2 = reinterpret_cast(pX);
// System crash!!
// �pȝ��崩溃!!
// pY2->bar();
正如我们在泛型例子中所认识到的�Q�如果你��试转换一个对象到另一个无关的�c�static_cast<>��失败，而reinterpret_cast<>��L��成功“欺骗”编译器�Q�那个对象就是那个无关类�?br />
情况2�Q��{换到相关的类
1. CDerived* pD = new CDerived();
2. printf("CDerived* pD = %x\n", (int)pD);
3.
4. // static_cast<> CDerived* -> CBaseY* -> CDerived*
//成功�~�译�Q�隐式static_cast<>转换
5. CBaseY* pY1 = pD;
6. printf("CBaseY* pY1 = %x\n", (int)pY1);
// 成功�~�译, 现在 pD1 = pD
7. CDerived* pD1 = static_cast(pY1);
8. printf("CDerived* pD1 = %x\n", (int)pD1);
9.
10. // reinterpret_cast
// 成功�~�译, 但是 pY2 不是 CBaseY*
11. CBaseY* pY2 = reinterpret_cast(pD);
12. printf("CBaseY* pY2 = %x\n", (int)pY2);
13.
14. // 无关�?static_cast<>
15. CBaseY* pY3 = new CBaseY();
16. printf("CBaseY* pY3 = %x\n", (int)pY3);
// 成功�~�译,��管 pY3 只是一�?"�?CBaseY()"
17. CDerived* pD3 = static_cast(pY3);
18. printf("CDerived* pD3 = %x\n", (int)pD3);
---------------------- 输出 ---------------------------
CDerived* pD = 392fb8
CBaseY* pY1 = 392fbc
CDerived* pD1 = 392fb8
CBaseY* pY2 = 392fb8
CBaseY* pY3 = 390ff0
CDerived* pD3 = 390fec

注意�Q�在��CDerived*用隐�?static_cast<>转换到CBaseY*�Q�第5行）�Ӟ��l�果是（指向�Q�CDerived*�Q�的指针向后�Q?偏移�?�Q�个字节�Q�（译注�Q?为int�c�d��在内存中所占字节数�Q�。�ؓ了知道static_cast<> 实际如何�Q�我们不得不要来看一下CDerived的内存布局�?/p>
CDerived的内存布局�Q�Memory Layout�Q?/strong>

如图所�C�，CDerived的内存布局包括两个对象�Q�CBaseX �?CBaseY�Q�编译器也知道这一炏V��因此，当你��CDerived* 转换�?CBaseY*�Ӟ��它给指针��d��4个字节，同时当你��CBaseY*转换到CDerived*�Ӟ��它给指针减去4。然而，甚至它即便不是一个CDerived你也可以�q�样做�?br />当然�Q�这个问题只在如果你做了多��承时发生。在你将CDerived转换 �?CBaseX时static_cast<> �?reinterpret_cast<>是没有区别的�?br />
情况3�Q�void*之间的向前和向后转换

因�ؓ��M��指针可以被�{换到void*�Q�而void*可以被向后�{换到��M��指针�Q�对于static_cast<> �?reinterpret_cast<>转换都可以这样做�Q�，如果没有��心处理的话错误可能发生�?br />
CDerived* pD = new CDerived();
printf("CDerived* pD = %x\n", (int)pD);
CBaseY* pY = pD; // 成功�~�译, pY = pD + 4
printf("CBaseY* pY = %x\n", (int)pY);
void* pV1 = pY; //成功�~�译, pV1 = pY
printf("void* pV1 = %x\n", (int)pV1);
// pD2 = pY, 但是我们预期 pD2 = pY - 4
CDerived* pD2 = static_cast(pV1);
printf("CDerived* pD2 = %x\n", (int)pD2);
// �pȝ��崩溃
// pD2->bar();
---------------------- 输出 ---------------------------
CDerived* pD = 392fb8
CBaseY* pY = 392fbc
void* pV1 = 392fbc
CDerived* pD2 = 392fbc
一旦我们已�l��{换指针�ؓvoid*�Q�我们就不能��L��其转换回原�c�R��在上面的例子中�Q�从一个void* �q�回CDerived*的唯一�Ҏ��是将其�{换�ؓCBaseY*然后再�{换�ؓCDerived*�?
但是如果我们不能��定它是CBaseY* �q�是 CDerived*�Q�这时我们不得不用dynamic_cast<> 或typeid[2]�?br />
注释�Q?/strong>
1. dynamic_cast<>�Q�从另一斚w��来说�Q�可以防止一个泛型CBaseY* 被�{换到CDerived*�?br />2. dynamic_cast<>需要类成�ؓ多态，卛_��括“虚”函敎ͼ��q�因此而不能成为void*�?br />参考：
1. [MSDN] C++ Language Reference -- Casting
2. Nishant Sivakumar, Casting Basics - Use C++ casts in your VC++.NET programs
3. Juan Soulie, C++ Language Tutorial: Type Casting

Stone Jiang 2006-05-22 21:18 发表评论

C/C++ 内存��理 Heap vs Stack

Stone Jiang — Wed, 17 May 2006 09:09:00 GMT

转注:
    今天有网友问到这个问�?于是在网上搜索了一�?转脓�q�此.
�怼�的太多了,出处不详.在此感谢原作者精彩讲�?

一、预备知识—程序的内存分配
一个由c/C++�~�译的程序占用的内存分�ؓ以下几个部分
1、栈区（stack�Q�— 由�~�译器自动分配释放，存放函数的参数��|��局部变量的值等。其操作方式�c�M��于数据结构中的栈�?
2、堆区（heap�Q� — 一般由�E�序员分配释放，若程序员不释放，�E�序�l�束时可能由OS回收。注意它与数据结构中的堆是两回事�Q�分配方式倒是�c�M��于链表，呵呵�?
3、全局区（静态区�Q�（static�Q�—，全局变量和静态变量的存储是放在一块的�Q�初始化的全局变量和静态变量在一块区域，未初始化的全局变量和未初始化的静态变量在盔R��的另一块区域。�? �E�序�l�束后有�pȝ��释放
4、文字常量区 —常量字�W�串��是攑֜��q�里的。程序结束后��q��l�释�?
5、程序代码区—存攑և��C��的二�q�制代码�?

二、例子程�?
�q�是一个前辈写的，非常详细

//main.cpp
int a = 0; 全局初始化区
char *p1; 全局未初始化区�?br />main()
{
int b;// 栈�?/span>
char s[] = "abc"; //栈�?/span>
char *p2; //栈�?/span>
char *p3 = "123456"; 123456\0";//在常量区�Q�p3在栈上。�?/span>
static int c =0�Q��?/span>//全局�Q�静态）初始化区
p1 = (char *)malloc(10);
p2 = (char *)malloc(20);
//分配得来�?0�?0字节的区域就在堆区。�?/span>
strcpy(p1, "123456"); //123456\0攑֜�帔R��区，�~�译器可能会��它与p3所指向�?123456"优化成一个地斏V��?/span>
}

三、堆和栈的理论知�?
3.1甌��方式
stack:
��q��l�自动分配。例如，声明在函��C��一个局部变量 int b; �pȝ��自动在栈中�ؓb开辟空�?
heap:
需要程序员自己甌��Q��ƈ指明大小�Q�在c中malloc函数
如p1 = (char *)malloc(10);
在C++中用new�q�算�W?
如p2 = (char *)malloc(10);
但是注意p1、p2本��n是在栈中的�?
3.2 甌��后系�l�的响应
栈：只要栈的剩余�I�间大于所甌��I�间�Q�系�l�将为程序提供内存，否则��报异常提示栈溢出�?
堆：首先应该知道操作�pȝ��有一个记录空闲内存地址的链表，当系�l�收到程序的甌��Ӟ��
会遍历该链表�Q�寻扄��一个空间大于所甌��I�间的堆�l�点�Q�然后将该结点从�I�闲�l�点链表中删除，�q�将该结点的�I�间分配�l�程序，另外�Q�对于大多数�pȝ��Q�会在这块内存空间中的首地址处记录本�ơ分配的大小�Q�这��P��代码中的delete语句才能正确的释放本内存�I�间。另外，�׃��扑ֈ�的堆�l�点的大��不一定正好等于申��L��大小�Q�系�l�会自动的将多余的那部分重新攑օ��I�闲链表中�?
3.3甌��大小的限�?
栈：在Windows�?栈是向低地址扩展的数据结构，是一块连�l�的内存的区域。这句话的意思是栈顶的地址和栈的最大容量是�pȝ��预先规定好的�Q�在 WINDOWS下，栈的大小�?M�Q�也有的说是1M�Q��M��是一个编译时��q��定的常数�Q�，如果甌��的空间超�q�栈的剩余空间时�Q�将提示overflow。因此，能从栈获得的�I�间较小�?
堆：堆是向高地址扩展的数据结构，是不�q�箋的内存区域。这是由于系�l�是用链表来存储的空闲内存地址的，自然是不�q�箋的，而链表的遍历方向是由低地址向高地址。堆的大��受限于计算机系�l�中有效的虚拟内存。由此可见，堆获得的�I�间比较灉|��Q�也比较大�?
3.4甌��效率的比较：
栈由�pȝ��自动分配�Q�速度较快。但�E�序员是无法控制的�?
堆是由new分配的内存，一般速度比较慢，而且�Ҏ��产生内存��片,不过用�v来最方便.
另外�Q�在WINDOWS下，最好的方式是用VirtualAlloc分配内存�Q�他不是在堆�Q�也不是在栈是直接在�q�程的地址�I�间中保留一快内存，虽然用�v来最不方�ѝ��但是速度快，也最灉|��
3.5堆和栈中的存储内�?
栈：在函数调用时�Q�第一个进栈的是主函数中后的下一条指令（函数调用语句的下一条可执行语句�Q�的地址�Q�然后是函数的各个参敎ͼ�在大多数的C�~�译器中�Q�参数是由右往左入栈的�Q�然后是函数中的局部变量。注意静态变量是不入栈的�?
当本�ơ函数调用结束后�Q�局部变量先出栈�Q�然后是参数�Q�最后栈��指针指向最开始存的地址�Q�也��是��d��C��的下一条指令，�E�序��p��点��l�运行�?
堆：一般是在堆的头部用一个字节存攑֠�的大��。堆中的具体内容有程序员安排�?
3.6存取效率的比�?

char s1[] = "aaaaaaaaaaaaaaa";
char *s2 = "bbbbbbbbbbbbbbbbb";
aaaaaaaaaaa是在�q�行时刻赋值的�Q?
而bbbbbbbbbbb是在�~�译时就��定的；
但是�Q�在以后的存取中�Q�在栈上的数�l�比指针所指向的字�W�串(例如�?快�?
比如�Q?
#include <stdio.h>;
void main()
{
char a = 1;
char c[] = "1234567890";
char *p ="1234567890";
a = c[1];
a = p[1];
return;
}

对应的汇�~�代�?
10: a = c[1];
00401067 8A 4D F1 mov cl,byte ptr [ebp-0Fh]
0040106A 88 4D FC mov byte ptr [ebp-4],cl
11: a = p[1];
0040106D 8B 55 EC mov edx,dword ptr [ebp-14h]
00401070 8A 42 01 mov al,byte ptr [edx+1]
00401073 88 45 FC mov byte ptr [ebp-4],al

�W�一�U�在��d��时直接就把字�W�串中的元素��d��寄存器cl中，而第二种则要先把指针��D��到edx中，在根据edx��d��字符�Q�显然慢了�?

3.7��结�Q?
堆和栈的区别可以用如下的比喻来看出：
使用栈就象我们去饭馆里吃饭，只管点菜�Q�发出申��P��、付钱、和吃（使用�Q�，吃饱了就赎ͼ�不必理会切菜、洗菜等准备工作和洗��、刷锅等扫尾工作�Q�他的好处是快捷�Q�但是自由度��?
使用堆就象是自己动手做喜�Ƣ吃的菜��_��比较�ȝ��Q�但是比较符合自��q��口味�Q�而且自由度大�?

堆和栈的区别主要分：
操作�pȝ��斚w��的堆和栈�Q�如上面说的那些�Q�不多说了�?
�q�有��是数据�l�构斚w��的堆和栈�Q�这些都是不同的概念。这里的堆实际上指的��是�Q�满��_��性质的）优先队列的一�U�数据结构，�W?个元素有最高的优先权；栈实际上��是满��先进后出的性质的数学或数据�l�构�?
虽然堆栈�Q�堆栈的说法是连��h��叫，但是他们�q�是有很大区别的�Q�连着叫只是由于历史的原因�?br />

Stone Jiang 2006-05-17 17:09 发表评论

避免依赖的消息处理方�?(试译)

Stone Jiang — Thu, 04 May 2006 12:52:00 GMT

避免依赖的消息处理方�?br />
Anthony Williams
url: http://www.ddj.com/dept/cpp/184429055
译�? Stone Jiang
译者说明：本�h�q�在学习英文的过�E�中�Q�有些句子很难译�Q�这里给出原文的链接�Q�欢�q�就其中译得不准��的地方与我交换意见�?br />

在您�l�护安全�c�d��和避免集成电路般函数�?你可以��用C++的强大的力量�q�行消息传递�?/p>
Anthony是Just Software Solution有限公司的一位��Y件开发者和执行��理者。可以通过anthony@justsoftwaresolutions.co.uk与之联系�?/p>
使用通用的消息传递方式传递数据在C++�E�序中很普遍。这�U�技术经常用于在�U�程间以及从/到GUI�l��g间传递数据。但是消息传递仍然很隑֮�现得良好�Q�这是因为在常见的消息传递方式中�Q�暴露出了过多的藕合、缺��类型安全和集成电�\般的消息处理函数�?/p>
在本文中�Q�我提出了一�U�技术，�q�种技术利用C++的强大力量来避免上述�~�陷——在消息传递中避免不适当的藕合，�l�护�c�d��安全�Q�以及消除集成电路般的消息处理函�? The only translation units that need to known the details of a message are those containning the source and handler functions for that specific message type.) 需要�{换的单元�Q�即需要知道的消息详细内容是包含了特定消息的类型的源代码和处理函数�?/p>
传统技�?/h2>

大概应用得最为广泛的消息传递技术是使用一个带有特�D�成员来表示消息�c�d��的结构体�Q�该消息�c�d��是消息的标识。这�U�方式被�q�泛应用归咎于��用了��Z��C的API�Q�比如X11和Microsoft Windows。在�q�种�Ҏ��中，消息�l�构体中要么有一个通用的字体用于区别不同消息的意义�Q�这个字�D�可被所有消息重用，或者它是更大结构的�W�一个成员，它的�c�d��q��型代码来��定。Windows API使用前面的技术，而X11使用后面的方法。无论用哪种方式�Q�处理消息的代码都须��查类型编码，用以军_��怎么处理该消息�?/p>
�q�些技术的问题�?�~�Z��c�d��安全�Q�集成电路般的处理函敎ͼ�需要管理类型编码来��保消息唯一性的适当层次。特别的�Q�缺乏类型安全意味着使用之前�Q��用代码必��L��消息数据转换成适当的类型。这一步是极易出错的，��其在当复制和粘贴代码时(�q�种非常的手�D�常发生在�ؓ处理�怼�消息�~�写代码的时�?�Q�编译器不会在这�U�错误给��Z�Q何警告�?/p>
�~�Z��c�d��安全�q�有一个额外的问题——即它不可能��单有效的通过消息�pȝ��传递资源或变长的数据， �q�是因�ؓ消息的发送方��L��不能知道何时�Q�或是否�Q�该消息已被处理�q�了�?/p>
在这部分�Q�集成电路般的消息处理函数是必须用于��定消息�c�d��的��物，通过已接收的消息来消息类型，然后得到如何处理它的方式。这�U�处理函数往往实现��Z��个很大的switch语句或是一串if eles if。一些框�Ӟ��如MFC�Q�提供一些宏来减��p��U�问题的影响�Q�它�q�不能完全消除这个问题�?/p>
最后的问题是管理类型代码。它必须要求接收消息代码清楚地知道是哪一个消息，以便于正��的处理它。所以，�c�d��代码需要在处理它的相关代码中确保唯一性。比如，在Windows API中，指定范围的消息类型在不同的应用程序中代表不同的意义，�q�且�Q�在同一个应��q��E�序中，其它范围的消息类型在不同�H�口或GUI�l��g中代表不同的意义�?通常,需要所有类型代码的列表�Q�该列表要求在给定的范围中保持唯一�Q�以便于��查它们的唯一性。列表常常是以头文�g的�Ş式给出，头文件中定义了类型代码，包含在需要知道消息类型的所有地斏V��这�U�方式容易导致应用程序不同部分之间的藕合,而这些部分之间却没有��M��关系。由于这�U�过度的藕，��单的变更��D��q�多的重新编译�?/p>
面向对象技�?br />
对象技术的一个常见特征是所有相��x��息类�z��自一个通用的基�c�R��该特征用编译器能认识的真实�c�d��代替了显式的�c�d��代码。不仅如此，它还有了一个重要的�Q�超��C风格技术的优点——类型安全。它提供的通用基类的析构函数是虚函敎ͼ�所以派生的消息�c�能自由地管理资源，如变长的数据�Q�这些数据可以在析构函数中释放。仅有的需求是接受消息的代码能正确地销毁消息对象，无论它们是否被处理�?/p>
��理�c�d��代码现在被替换�ؓ��理�c�R��这是一个更加简单的��d��Q�由于可能的消息名字的范围是没有限制的，可能存在名字冲突�Q�但�q�一点可以通过名字�I�间来解冟�?/p>
保持��?/font>

最��单的OOP技术就是用dynamic_cast��查实际的消息�c�d��代替��查消息编码。然而，�q�依焉��临着集成电�\般地消息处理方式——现在通过包括dynamic_cast的比较链也优于通过�c�d��~�码字段比较链。如列表1:

void handleMessage(Message * message)
{
     if (Message1 * m = dynamic_cast < Message1 *> (message))
     {
        handleMessage1(m);
    }
     else if (Message2 * m = dynamic_cast < Message2 *> (message))
     {
        handleMessage2(m);
    }
     //
}

[列表1]

一般而言�Q�由于仅仅是消息的源代码和接受消息的源代码需求知道相关的消息�Q�所以依赖得到降低。然后，集成电�\般地处理函数现在需要知道消息的有关�l�节�Q�所以dynamic_cast需要消息的完整定义——如果分�z��另外的函数处理实际的消息�Q�C风格技术的处理函数不需求知道消息的�l�节�?/p>
双重分派

(Direct testing of a class's type using dynamic_cast is generally indicative of a design problem;)�cȝ��c�d��用dynamic_cast的直��试一般可表示��计问�?然而，��单地把虚函数攑֜�消息�c�M��起不��C�Q何作用——它��把消息处理与消息缠�l�在一��P��q�个消息使在�W�一个地方发送消息的目的��p�|�?/p>
双重分派的关键点是，在消息类中的虚函数带有一个作为参数的处理器，然后在处理器上把自已作�ؓ参数传递传递给另一个函数�ƈ完成调用。因��里的�W�二�ơ到处理器的回调已经在实际的�z��c�M��完成�Q�所以真实的消息�c�d��已经知道�Q�在处理器上能调用适当的函敎ͼ�无论�q�个函数是通过重蝲的方式实现还是另外独立命名的函数来实�?列表2)�?/p>
class Message
{
public :
     virtual void dispatch(MessageHandler * handler) = 0 ;
};
class Message1:
     public Message
{
     void dispatch(MessageHandler * handler)
    {
        handler -> process( this );
    }
};
class Message2:
     public Message
{
     void dispatch(MessageHandler * handler)
    {
        handler -> process( this );
    }
};
// other message classes
class MessageHandler
{
     void process(Message1 * );
     void process(Message2 * );
     // overloads of process for other messages
};

[列表2]

依赖于重载的方式来区别不同的消息有利于大多数�q��——现在在每个消息�c�M��虚函数的实现方式是相同的�Q�如果需要，可以通过宏来一致地包装�Q�或通过从一个消息到另一个消息中直接复制�Q�不会有出错的机会�?/p>
双重分派存在一个缺点——高度藕合。由于通过重蝲方式在处理器�c�M��的选择处理函数�Q�在消息�c�M��虚函数的实现需要知道处理器�cȝ��定义的全部，因此必须注意到在�pȝ��中每个其它的�cȝ��名字。不光这些，如果要支持不同的处理器类�Q�处理函数必��d��通用的处理器的基�c�M��声明��函数�Q�所以每个处理器�c�d��d��pȝ��中注意到所有的消息�c�d��(列表3)。增加或删除一个消息类型会引�v应用�E�序大部分代码重新编译�?/p>
class MessageHandler
{
     virtual void process(Message1 * ) = 0 ;
     virtual void process(Message2 * ) = 0 ;
     virtual void process(Message3 * ) = 0 ;
     virtual void process(Message4 * ) = 0 ;
     // overloads of process for other messages
} ;
class SpecificMessageHandler:
     public MessageHandler
{
     void process(Message1 * );
     void process(Message2 * );
     void process(Message3 * );
     void process(Message4 * );
     // overloads of process for other messages
} ;
class OtherSpecificMessageHandler:
     public MessageHandler
{
     void process(Message1 * );
     void process(Message2 * );
     void process(Message3 * );
     void process(Message4 * );
     // overloads of process for other messages
} ;

[列表3]

动态双重分�z?br />
�Q�It was against this backdrop that I developed the technique I call "Dynamic Double Dispatch."�Q�我开发了一�U�技术，我称其�ؓ“动态双重分�z䏀�，�q�种技术用于解决上�q�问题。尽��有基本的双重分�z�技术，但选择的消息处理函��C��用的是在�~�译阶段��定的重载技�?��管发现在正��的消息处理器类中的实现是��用虚函数机制),而动态双重分�z�是在运行时��查在处理器上适当的处理函数的。结论是动态双重分�z�消除了双重分派的依赖问题。消息类型不在需要注意到其它的消息类型，�q�且处理器类仅需要注意到它的它要处理的消息�?/p>
动态检查的关键�Ҏ��Q�每一个消息类型有一个独立的基类——处理器�c�M��适当的，设计为处理消息的基类�z��。然后在每个消息�c�M��的分�z�և�数能用dynamic_cast来检查从正派基类�z��的处理器�c�，因而实��C��正确的处理函数�?列表4)

class MessageHandlerBase
{};
class Message1HandlerBase:
     public virtual MessageHandlerBase
{
     virtual void process(Message1 * ) = 0 ;
};
class Message1
{
     void dispatch(MessageHandlerBase * handler)
    {
        dynamic_cast < Message1HandlerBase &> ( * handler).process( this );
    }
};
class Message2HandlerBase:
     public virtual MessageHandlerBase
{
     virtual void process(Message2 * ) = 0 ;
};
class Message2:
     public MessageBase
{
     void dispatch(MessageHandlerBase * handler)
    {
        dynamic_cast < Message2HandlerBase &> ( * handler).process( this );
    }
};
//
class SpecificMessageHandler:
     public Message1HandlerBase,
     public Message2HandlerBase
{
     void process(Message1 * );
     void process(Message2 * );
};
class OtherSpecificMessageHandler:
     public Message3HandlerBase,
     public Message4HandlerBase
{
     void process(Message3 * );
     void process(Message4 * );
};

[列表4]

(Of course, having a completely separate handler base class for each message type would add excessive complication, as the dispatch function for each message type would now be specific to that message type, and the base classes would have to be written separately, despite being fundamentally the same, except for the message type they referenced.)
诚然�Q��ؓ每个消息�c�d��分别�~�写的处理器基类��增加过多的复杂性，同样圎ͼ�每个消息�c�d��各自的分�z�և�数现在需要特别指定，基类也需求分别编�?然后除了它们引用的消息类型外基础是相同的。消除这�U�重复的关键是��基类成�ؓ模板�Q�用消息�c�d��作�ؓ模板参数——分�z�և�数引用到模板的实现好于指定类型；��L��列表5�?/p>

template < typename MessageType >
class MessageHandler:
     public virtual MessageHandlerBase
{
     virtual void process(MessageType * ) = 0 ;
};
class Message1
{
     void dispatch(MessageHandlerBase * handler)
    {
        dynamic_cast < MessageHandler < Message1 >&> ( * handler).process( this );
    }
};
class SpecificMessageHandler:
     public MessageHandler < Message1 > ,
     public MessageHandler < Message2 >
{
     void process(Message1 * );
     void process(Message2 * );
};

[列表5]
��Z��化原因，在消息类中的分派函数几乎相同�Q�但也不是完全相同——它们必��L��的指定属于它们的指定消息类�Q�以便于转换为适当的处理器基类。像软�g中许多事情一��P��q�个问题可以增加一个额外的层来解决——分�z�և�数可以委托给单个模板函数�Q�这个模板函��C��用模板参数类型来��定消息�c�d��和把处理器�{换到适当的类型上�?列表6)

class Message
{
protected :
    template < typename MessageType >
     void dynamicDispatch(MessageHandlerBase * handler,MessageType * self)
    {
        dynamic_cast < MessageHandler < MessageType >&> ( * handler).process(self);
    }
};
class Message1:
     public MessageBase
{
     void dispatch(MessageHandlerBase * handler)
    {
        dynamicDispatch(handler, this );
    }
};

[列表6]

通过�q�一步抽象在消息对象中分�z�և�数的不同之处,我们把工作集中到一个地方——模板函数的定义�Q�它提供了�ؓ修改行�ؓ的单一炏V��在消息�c�M��剩下的分�z�և�数都是相同的�Q�这��以把它们简化到隐藏�l�节的宏中或在消息类之间中逐字复制�?/p>

未处理的消息

�q�今为止�Q�我们展�C�的 dynamicDispach模板函数的代码假定处理的�c�L��从适当的SpecificMessageHandler是派生的�Q�如是不是这��P�� dynamic_cast��抛出std::bad_cast异常。有时这��p��够了�Q�但是有的时候，有更适当的行为——也许更好的做法是抛弃消息，�q�不能被接受消息的代理处理或调用catch-all处理器。�D例来��_��dynamicDispatch 函数能被调整�Q�用��Z��指针的�{换代替基于引用的转换�Q�所以结果值可以与NULL�q�行��试�?/p>

�~�点(Trade-Off)在哪里？
有如此多的优点，一定存在它的缺点，那它的缺点在哪里呢？在这里，有两个缺炏V��第一个是�Q�额外的动态�{换，两个虚函数调用会影响性能。如果性能上是一个问题，�q�就是一个疑问，但是�Q�在很多情况下，花销在这里的额外的时间是不值得��x��的。可以��用相应的工具来签定到底哪里才是真正的性能瓉��所在�?/p>
�W�二个缺�Ҏ��:需要�ؓ每个消息处理从指定的基类�z��消息处理器。因为处理新的消息类型需要修改两个地方——适当的基�c�d��表入口和处理函数�Q�所以这可能成�ؓ错误的来源，遗失处理函数�Ҏ��被发玎ͼ�因�ؓ�q�是全局点，但是遗失基类在代码运行时只��生不易查觉的�~�陷。因为没有处理函数的时候仅仅是不调用它。这些错误在单元��试的时候是很容易被抓出来的�Q�所以所实话�Q�这些不便之处都成不了大问题�?/p>

Stone Jiang 2006-05-04 20:52 发表评论

socket�~�程�Q�SO_REUSEADDR例解 (�?

Stone Jiang — Sat, 29 Apr 2006 01:40:00 GMT
     摘要: socket�~�程�Q�SO_REUSEADDR例解                                             kevintz 2000-6-19     �|�友vmstat多次提出了这个问题：SO_REUSEADDR有什么用处和怎么使用。而且很多�|�友在编写网�l�程序时也会遇到�q�个问题。所以特意写了这么一��文章，希望能够解答一些�h的疑难�?    其实�q�个问题在Richard ...  阅读全文

Stone Jiang 2006-04-29 09:40 发表评论

谈谈C++�l�承中的重蝲�Q�覆盖和隐藏 (�?

Stone Jiang — Tue, 25 Apr 2006 05:29:00 GMT

谈谈C++�l�承中的重蝲�Q�覆盖和隐藏

      写正题之前，先给出几个关键字的中英文对照�Q�重�?overload)�Q�覆�?override),隐藏(hide)。在早期的C++书籍中，可能��译的�h不熟悉专业用语（也不能怪他们，他们不是搞计��机�~�程的，他们是英语专业的�Q�，常常把重�?overload)和覆�?override)搞错�Q?/p>
　　我们先来看一些代码及其编译结果�?/p>
　　实例一�Q?br />　　
　　#include "stdafx.h"
　　#include
　　class CB
　　{
　　public:
　　　　void f(int)
　　　　{
　　　　　　 cout << "CB::f(int)" << endl;
　　　　 }
　　};

　　class CD : public CB
　　{
　　public:
　　　　 void f(int,int)
　　　　{
  　　　　　　cout << "CD::f(int,int)" << endl;
　　　　}
　　　　void test()
　　　　{
  　　　　　f(1);
　　　　}
　　};
　int main(int argc, char* argv[])
　{
　　　 return 0;
　}
�~�译了一�?br />error C2660: 'f' : function does not take 1 parameters

�l�论�Q�在�c�CD�q�个域中�Q�没有f(int)�q�样的函敎ͼ�基类中的void f(int)�?font color="#ff0000">隐藏
　　如果把派生CD中成员函数void f(int,int)的声明改成和基类中一��P��即f(int)�Q�基�c�M��的void f(int)�q�是一栯��覆盖�Q�此时编译不会出错，在函��C��test调用的是CD中的f(int)　
　　所以，�?font color="#ff0000">基类�?/font>的某些函敎ͼ�如果没有virtral关键字，函数名是f(参数是什么我们不��?�Q�那么如果在�z��c�CD�?font color="#ff0000">也声明了某个f成员函数�Q�那么在�c�CD域中�Q?font color="#ff0000">基类中所有的那些f都被隐藏�?/font>
　　如果你比较心急，想知道什么是隐藏�Q�看文章最后的��单说明，不过我徏议你�q�是一步一步看下去�?/p>
　　我们刚才说的是没有virtual的情况，如果有virtual的情况呢�Q�？
　　实例二：
#include "stdafx.h"
#include
class CB
{
public:
　　virtual void f(int)
　　{
  　　　　cout << "CB::f(int)" << endl;
　　}
};

class CD : public CB
{
public:
　　 void f(int)
　　{
  　　　　cout << "CD::f(int)" << endl;
　　 }
};
int main(int argc, char* argv[])
{
　return 0;
}
　　�q�么写当然是没问题了�Q�在�q�里我不多费口舌了，�q�是很简单的�Q�多态，虚函敎ͼ�然后什么指向基�cȝ��指针指向�z��c�d��象阿�Q�通过引用调用虚函数阿什么的�Q�属性多的很咯，什么？�Q�你不明白？�Q�随便找本C++的书�Q�对会讲多态和虚函数机制的哦！�Q?br />　　�q�种情况我们�?font color="#ff0000">覆盖(override)�Q?/font>覆盖指的是派生类的虚拟函数覆盖了基类的同名且参数相同的函敎ͼ�
　　在这里，我要��的是�Q�这�U�覆盖，要满��两个条�?br />　(a)有virtual关键�?/font>�Q�在基类中函数声明的时候加上就可以�?br />　(b)基类CB中的函数和派生类CD中的函数要一模一�?/font>�Q�什么叫一模一��P��函数名，参数�Q�返回类型三个条�?/font>�?br />　　有�h可能会对(b)中的说法质疑�Q�说�q�回�c�d��也要一��P��Q?br />　　是，覆盖的话必须一��P��我试了试�Q�如果在基类�?把f的声明改成virtual int f(int)�Q�编译出错了
　　error C2555: 'CD::f' : overriding virtual function differs from 'CB::f' only by return type or calling convention
　　所以，覆盖的话�Q�必��要满��上述�?a)(b)条�g
　　那么如果基类CB中的函数f有关键字virtual　�Q�但是参数和�z��c�CD中的函数f参数不一样呢�Q?br />实例�?
#include "stdafx.h"
#include
class CB
{
　public:
　　 virtual void f(int)
　　 {
　　　　 cout << "CB::f(int)" << endl;
　　 }
}
;

class CD : public CB
{
public:
　　 void f(int�Q�int)
　　{
　　　 cout << "CD::f(int�Q�int)" << endl;
　　}
　　void test()
　　{
　　　　 f(1);
　　}
}
;
int main(int argc, char* argv[])
{
return 0;
}
�~�译出错了，
error C2660: 'f' : function does not take 1 parameters
　　咦？�Q�好面熟的错�Q�？对，和实例一中的情况一样哦�Q�结��Z��是基�c�M��的函数被隐藏了�?/p>
　　通过上面三个例子�Q�得��Z��个简单的�l�论
如果基类中的函数和派生类中的两个名字一��L��函数f
满��下面的两个条�?br />(a)在基�c�M��函数声明的时候有virtual关键�?br />(b)基类CB中的函数和派生类CD中的函数一模一��P��函数名，参数�Q�返回类型都一栗��?br />那么�q�就是叫�?font color="#ff0000">覆盖(override)�Q?/font>�q�也��是虚函敎ͼ�多态的性质
那么其他的情况呢�Q�？只要名字一��P��不满��上面覆盖的条�g�Q�就�?font color="#ff0000">隐藏了�?/font>
下面我要讲最关键的地方了�Q�好多�h认�ؓ�Q�基�c�CB中的f(int)会��承下来和CD中的f(int,int)在派生类CD中构成重载，��像实例一中想像的那样�?br />　　对吗�Q�我们先看重载的定义
　　重蝲(overload):
　　必须在一个域�?函数名称相同但是函数参数不同,重蝲的作用就是同一个函数有不同的行�?因此不是在一个域中的函数是无法构成重载的,�q�个是重载的重要特征
　　必须在一个域�?/font>�Q�而��承明显是在两个类中了哦，所以上面的��x��是不成立的，我们��试的结构也是这��P��z��c�M��的f(int,int)把基�c�M��的f(int)隐藏�?br />　　所以，相同的函数名的函敎ͼ�在基�c�d��z��c�M��的关�p�d��能是覆盖或者隐藏�?/font>
　　在文章中�Q�我把重载和覆盖的定义都�l�了出来了，但是一直没有给隐藏的定义，在最后，我把他给出来�Q�这�D�话是网上google来的�Q�比较长�Q�你可以��单的理解成，在派生类域中�Q�看不到基类中的那个同名函数了，或者说�Q�是�q�没有��承下来给你用�Q�呵呵，如实例一　那样�?br />　　
隐藏(hide):
指的是派生类的成员函数隐藏了基类函数的成员函�?隐藏一词可以这么理�?在调用一个类的成员函数的时�?�~�译器会沿着�cȝ��l�承��N��的向上查扑և�数的定义,如果扑ֈ�了那么就停止查找�?所以如果一个派生类和一个基�c�都有同一个同�?暂且不论参数是否相同)的函�?而编译器最�l�选择了在�z��c�M��的函�?那么我们��p��q�个�z��cȝ��成员函数"隐藏"了基�cȝ��成员函数,也就是说它阻止了�~�译器��l�向上查扑և�数的定义

Stone Jiang 2006-04-25 13:29 发表评论

STL中map与hash_map容器的选择 (�?

Stone Jiang — Tue, 25 Apr 2006 01:25:00 GMT

STL中map与hash_map容器的选择

　　实际上这个问题不光C++会遇刎ͼ�其他所有语�a�的标准容器的实现及选择上都是要考虑的。做应用�E�序你可能觉得媄响不大，但是写算法或者核心代码就要小心了。今天改�q�代码，��Z��又来温习基础功课了�?/p>

　　�q�记得Herb Sutter那极有味道的《C++对话�p�d��》么�Q�在其中《��生真正的hash对象》这个故事里��p��了map的选择。顺便回��一下，也讲一下我在实用中的理解�?/p>
　　选择map容器�Q�是��Z��更快的从关键字查扑ֈ�相关的对象。与使用list�q�样的线性表容器相比�Q�一可以��化查扄��法�Q�二可以使�Q意的关键字做索引�Q��ƈ与目标对象配对，优化查找��法。在C++的STL中map是��用树来做查找��法�Q�这�U�算法差不多相当与list�U�性容器的折半查找的效率一��P��都是O(log2N)�Q�而list��没有map�q�样易定制和操作了�?/p>
　　相比hash_map�Q�hash_map使用hash表来排列配对�Q�hash表是使用关键字来计算表位�|�。当�q�个表的大小合适，�q�且计算��法合适的情况下，hash表的��法复杂度�ؓO(1)的，但是�q�是理想的情况下的，如果hash表的关键字计��与表位�|�存在冲�H�，那么最坏的复杂度�ؓO(n)�?/p>
　　那么有了�q�样的认识，我们应该怎么样选用��法呢？前两天看Python文章的时候，不知道哪个小子说Python的map比c++的map快，如何如何的。但是他�q�不知道Python是默认��用的hash_map�Q�而且�q�些语言特征本质上是使用c/c++写出来的�Q�问题在与算法和手段�Q�而不是在于语�a�本��n的优劣，你熟悉了各种��法�Q�各�U�语�a�的细节、设计思想�Q�还能在�q�偏�Ȁ的嚷嚷孰好孰�?片面与偏�Ȁ的看待事物只能表明愚昧与无知�Q��Q何事物都有存在的价��|��包括技�?。显然C++的STL默认使用树结构来实现map�Q�是有考究的�?/p>
　　树查找，在��L��找效率上比不上hash表，但是它很�E�_��Q�它的算法复杂度不会出现波动。在一�ơ查找中�Q�你可以断定它最坏的情况下其复杂度不会超�q�O(log2N)。而hash表就不一��P��是O(1)�Q�还是O(N)�Q�或者在其之��_��你�ƈ不能把握。假若你在开发一个供外部调用的接口，其内部有关键字的查找�Q�但是这个接口调用�ƈ不频�J�，你是会希望其调用速度快、但不稳定呢�Q�还是希望其调用旉��q�_��、且�E�_��呢。反之假若你的程序需要查找一个关键字�Q�这个操作非帔R��J�，你希望这些操作在��M��上的旉��较短�Q�那么hash表查询在��L��间上会比其他要短�Q��^均操作时间也会短。这里就需要权衡了�?/p>
　　�q�里�ȝ��一下，选用map�q�是hash_map�Q�关键是看关键字查询操作�ơ数�Q�以及你所需要保证的是查询��M��旉��q�是单个查询的时间。如果是要很多次操作�Q�要求其整体效率�Q�那么��用hash_map�Q��^均处理时间短。如果是��数�ơ的操作�Q��用hash_map可能造成不确定的O(N)�Q�那么��用��^均处理时间相对较慢、单�ơ处理时间恒定的map�Q�考虑整体�E�_��性应该要高于整体效率�Q�因为前提在操作�ơ数较少。如果在一�ơ流�E�中�Q��用hash_map的少数操作��生一个最坏情况O(N)�Q�那么hash_map的优势也因此丧尽了�?

Stone Jiang 2006-04-25 09:25 发表评论

��单讲解ACE_SOCK Wrapper Class的��?原创)

Stone Jiang — Thu, 20 Apr 2006 15:50:00 GMT

��单讲解ACE_SOCK Wrapper Class的��?/h1> Stone Jiang
http://www.shnenglu.com/ace

我们先来看一个场�?
您去一安��馆吃�?�q�家��馆位置��在水木清华�?3��P��您得事先知道��馆的位�|�，从门�q�入�Q�如果你想破墙而入那是不允可的。当你进门后�Q�餐馆会有一位领位员招呼你，领位员会安排一个服务员��Z��提供服务的，你可以向服务员点菜，或听取服务员的推荐。用��后你离开��馆�?br />
利用ACE SOCK�~�程�Q�与上馆子极其相伹{��我们来作一个对比�?br /> ��馆的位�|�，嗯，计算��Z��Q�我们是IP地址�Q�水木清华我们对应的�?smth.org,它的门牌号呢�Q�对应的是我们的端口地址�Q�在ACE中，我们用ACE_INET_Addr来表�C��?br /> 卻I��
ACE_INET_Addr peer_addr;
peer_addr;.set(23,"smth.org");
我们也可以直接通过它的带参数的构造函数来声明和初始化�Q?br /> ACE_INET_Addr peer_addr(23,"smth.org")

��馆的领位员相当�?ACE_SOCK_Acceptor,它被动的站在站口�{�着客户的到来，您作为客��P��是主动端�Q�ACE_SOCK_Connector则是您将在代码中看到的�?br />
ACE面向�q�接的网�l�编�E�，有三个主要的角色
��d��?被动端和数据交流的通道�Q�即
ACE_SOCK_Acceptor, ACE_SOCK_Connector和ACE_SOCK_Stream

接收和发送数据，则通过 ACE_SOCK_Stream::recv(...)和send(...)完成�Q�本例演�C�Z��接收时的调用�?br />
完成数据交互之后�Q�ACE_SOCK_Stream::close()完成断开�q�接操作�?�q�相当于买单��C�h�?br />
注：smth.org:23是水木清华Telnet服务�Q�您�q�可以通过
telnet smth.org来访问�?br />
下面是完整代码示�?VC 7.1下调试通过
//@file: mybrowser.cpp
//       Main function
//@auth: Stone Jiang <2005119@gmail.com>
//@date: 2006-4-20

#include "ace/Log_Msg.h"
#include "ace/SOCK_Connector.h"
#include "ace/SOCK_Stream.h"
#include "ace/INET_Addr.h"

int ACE_TMAIN(int argc, ACE_TCHAR* argv[])
{
  ACE_DEBUG((LM_DEBUG,"start here\n"));

  const char* server_hostname = "smth.org";

  ACE_SOCK_Connector connector;
  ACE_SOCK_Stream peer;
  ACE_INET_Addr peer_addr;
  char buf[64]={0};

  if(peer_addr.set(23,server_hostname) == -1)
  {
     ACE_ERROR_RETURN((LM_DEBUG,"(%P|%t) %p\n",
                 "Set server host"),-1);

  }
  else if(connector.connect(peer,peer_addr) == -1)
  {
    ACE_ERROR_RETURN((LM_DEBUG,"(%P|%t) %p\n",
      "Connection"),-1);

  }
  ACE_DEBUG((LM_DEBUG,"建立�q�接成功 \n"));
  const int s = 64 * 10;
  int m = 0;
  for(ssize_t n; (n = peer.recv(buf,sizeof buf))>0;)
  {

    ace::write_n(ACE_STDOUT,buf,n);
    m += n;
    if( m > s)
    {
      break;
    }
  }
  peer.close();

  return 0;
}

Stone Jiang 2006-04-20 23:50 发表评论

巧用虚友元函�?原创)

Stone Jiang — Mon, 17 Apr 2006 14:12:00 GMT

父类的友元不会自动成为子�cȝ��友元�Q�而且友元会破坏封装；C++的语方不允许�Q�非成员�Q�友元函��Cؓ虚函数�?br />但是�Q�某些时候，必须通过友元才能实现一些操作符重蝲�Q�如operator<<()�Q�如果�ؓ每个子类都实现operator<<()倒是一个可行的�Ҏ��Q�但是显得很啰嗦�?br />
如果能把友元定义��函数�Q�则子类可以�l�承该友元的接口而无需重复声明友好那该多好啊？
本文则通过一�U�变通的�Ҏ��巧妙辑ֈ�虚函数的效果�?br />
//基类 Base.

#pragma once
#include < iostream >
using namespace std;
class Base
{
public :
  Base( void );
   ~ Base( void );
public :
   virtual void print(ostream & output) = 0 ;
  friend ostream & operator << (ostream & output,Base & obj);
private :
   char * name_;
   int age_;
} ;

基类的实�?base.cpp
#include "StdAfx.h"
#include ".\base.h"

Base::Base(void)
{
  name_ = "This is data1";
  age_ = 18;
}

Base::~Base(void)
{
}

void Base::print(ostream& output)
{
  output<<"name = " <<name_<<endl;
  output<<"age = "<<age_<<endl;
}

ostream& operator<<(ostream& output,Base& obj)
{
  obj.print(output);
  return output;
}

�z��cȝ�� Derived.h

#pragma once
#include "Base.h"
class Derived :public Base
{
public:
  Derived(int score = 80);
  ~Derived(void);
  virtual void print(ostream& output);
private:
  int score_;
};

�z��cȝ��实现 Derived.cpp
#include "StdAfx.h"
#include ".\derived.h"

Derived::Derived(int score):score_(score)
{

}

Derived::~Derived(void)
{
}

void Derived::print(ostream& output)
{
  Base::print(output);
  output<<"score = "<<score_<<endl;
}

�ȝ��序main.cpp
// Test_VirtualFirendFunction.cpp : Defines the entry point for the console application.
//

#include "stdafx.h"
#include <iostream>
#include "Derived.h"
using namespace std;
int _tmain(int argc, _TCHAR* argv[])
{
  Derived  d;

  Derived  d2(90);
  cout<<d<<endl<<d2<<endl;
    return 0;
}

屏幕输入�l�果
name = This is data1
age = 18
score = 80

name = This is data1
age = 18
score = 90
�l�果�Q?br />��M��从Base�z��cȝ��Q�都可以利用cout<
同样道理�Q�也可以利用此方法实现ACE_InputCDR  / ACE_OutputCDR对网�l�操作序列化操作�?br />(本文也是回答某网友关于派生类不能重蝲的问题的回复)

Stone Jiang 2006-04-17 22:12 发表评论

C++风格的类型�{换的用法 (�?

Stone Jiang — Sun, 16 Apr 2006 06:21:00 GMT

C++风格的类型�{换的用法
�q�是More Effecitve C++里的�W�二条对�c�d��转换讲的很好�Q�也很基��好懂�?br />Item M2�Q�尽量��用C++风格的类型�{�?br />仔细��x��C��卑贱的类型�{换功能（cast�Q�，其在�E�序设计中的��C��p��goto语句一样��o人鄙视。但是它�q�不是无法��o人忍受，因�ؓ当在某些紧要的关��_��c�d��转换�q�是必需的，�q�时它是一个必需品�?br />不过C风格的类型�{换�ƈ不代表所有的�c�d��转换功能�?br />一来它们过于粗鲁，能允�怽�在�Q何类型之间进行�{换。不�q�如果要�q�行更精��的�c�d��转换�Q�这会是一个优炏V��在�q�些�c�d��转换中存在着巨大的不同，例如把一个指�? const对象的指针（pointer-to-const-object�Q��{换成指向非const对象的指针（pointer-to-non -const -object�Q?即一个仅仅去除const的类型�{�?�Q�把一个指向基�cȝ��指针转换成指向子�cȝ��指针�Q�即完全改变对象�c�d��Q��? 传统的C风格的类型�{换不对上�q�C��U��{换进行区分。（�q�一点也不��o人惊�Ӟ��因�ؓC风格的类型�{换是为C语言设计的，而不是�ؓC++语言设计的）�?br />�? 来C风格的类型�{换在�E�序语句中难以识别。在语法上，�c�d��转换由圆括号和标识符�l�成�Q�而这些可以用在C�Q�＋中的��M��地方。这使得回答象这样一个最基本的有关类型�{换的问题变得很困难：“在�q�个�E�序中是否��用了�c�d��转换�Q�”。这是因��Z�h工阅��d��可能忽略了类型�{换的语句�Q�而利用象grep的工��L��序也不能�? 语句构成上区分出它们来�?br />C++通过引进四个新的�c�d��转换操作�W�克服了C风格�c�d��转换的缺点，�q�四个操作符�? static_cast, const_cast, dynamic_cast, 和reinterpret_cast�? 在大多数情况下，对于�q�些操作�W�你只需要知道原来你习惯于这样写�Q?br />(type) expression
而现在你��d��该这样写�Q?br />static_cast < type > (expression)
例如�Q�假设你��x��一个int转换成double�Q�以便让包含int�c�d��变量的表辑ּ�产生出��Q�Ҏ��值的�l�果。如果用C风格的类型�{换，你能�q�样写：
int firstNumber, secondNumber;

double result = ((double)firstNumber)/secondNumber�Q?br />如果用上�q�新的类型�{换方法，你应该这样写�Q?br />double result = static_cast < double > (firstNumber)/secondNumber;
�q�样的类型�{换不论是对�h工还是对�E�序都很�Ҏ��识别�?br />static_cast 在功能上基本上与C风格的类型�{换一样强大，含义也一栗��它也有功能上限制。例如，你不能用static_cast象用C风格的类型�{换一��h�� struct转换成int�c�d��或者把double�c�d��转换成指针类型，另外�Q�static_cast不能从表辑ּ�中去除const属性，因�ؓ 另一个新的类型�{换操作符const_cast有这��L��功能�?br />其它新的C++�c�d��转换操作�W�被用在需要更多限制的地方。const_cast用于 �c�d��转换掉表辑ּ�的const或volatileness属性。通过使用const_cast�Q�你向�h们和�~�译器强调你通过�c�d��转换惛_��的只是改变一些东西的 constness或者volatileness属性。这个含义被�~�译器所�U�束。如果你试图使用const_cast来完成修�? constness 或者volatileness属性之外的事情�Q�你的类型�{换将被拒�l�。下面是一些例子：
class Widget {  };
class SpecialWidget: public Widget {  };
void update(SpecialWidget *psw);
SpecialWidget sw; // sw 是一个非const 对象�?br />const SpecialWidget& csw = sw; // csw 是sw的一个引�?br />// 它是一个const 对象
update( &csw ); // 错误!不能传递一个const SpecialWidget* 变量
// �l�一个处理SpecialWidget*�c�d��变量的函�?br />update(const_cast < SpecialWidget * > ( &csw ));
// 正确�Q�csw的const被显�C�地转换掉（
// csw和sw两个变量值在update
//函数中能被更斎ͼ�
update((SpecialWidget*) &csw );
// 同上�Q�但用了一个更难识�?br />//的C风格的类型�{�?br />Widget *pw = new SpecialWidget;
update(pw); // 错误�Q�pw的类型是Widget*�Q�但�?br />// update函数处理的是SpecialWidget*�c�d��
update(const_cast < SpecialWidget * > (pw));
// 错误�Q�const_cast仅能被用在媄�?br />// constness or volatileness的地方上�?
// 不能用在向��承子�c�进行类型�{换�?br />到目前�ؓ止，const_cast最普通的用途就是�{换掉对象的const属性�?br />�W? 二种�Ҏ��的类型�{换符是dynamic_cast�Q�它被用于安全地沿着�cȝ��l�承关系向下�q�行�c�d��转换。这��是��_��你能用dynamic_cast把指向基 �cȝ��指针或引用�{换成指向其派生类或其兄弟�cȝ��指针或引用，而且你能知道转换是否成功。失败的转换��返回空指针�Q�当�Ҏ��针进行类型�{换时�Q�或者抛出异�? �Q�当对引用进行类型�{换时�Q�：
Widget *pw;

update(dynamic_cast < SpecialWidget * > (pw));
// 正确�Q�传递给update函数一个指�?br />// 是指向变量类型�ؓSpecialWidget的pw的指�?br />// 如果pw��实指向一个对�?
// 否则传递过�ȝ��ɽI�指针�?br />void updateViaRef(SpecialWidget& rsw);
updateViaRef(dynamic_cast < SpecialWidget & > (*pw));
//正确。传递给updateViaRef函数
// SpecialWidget pw 指针�Q�如果pw
// ��实指向了某个对�?br />// 否则��抛出异�?br />dynamic_casts在帮助你��览�l�承层次上是有限制的。它不能被用于缺乏虚函数的类型上�Q�参见条�ƾM24�Q�，也不能用它来转换掉constness�Q?br />int firstNumber, secondNumber;

double result = dynamic_cast < double > (firstNumber)/secondNumber;
// 错误�Q�没有��承关�p?br />const SpecialWidget sw;

update(dynamic_cast < SpecialWidget * > ( &sw ));
// 错误! dynamic_cast不能转换
// 掉const�?br />如你惛_��没有�l�承关系的类型中�q�行转换�Q�你可能惛_��static_cast。如果是��Z��去除const�Q�你��d��用const_cast�?br />�q�四个类型�{换符中的最后一个是reinterpret_cast。��用这个操作符的类型�{换，其的转换�l�果几乎都是执行期定义（implementation-defined�Q�。因此，使用reinterpret_casts的代码很隄��植�?br />reinterpret_casts的最普通的用途就是在函数指针�c�d��之间�q�行转换。例如，假设你有一个函数指针数�l�：
typedef void (*FuncPtr)(); // FuncPtr is 一个指向函�?br />// 的指针，该函数没有参�?br />// �q�回值类型�ؓvoid
FuncPtr funcPtrArray[10]; // funcPtrArray 是一个能容纳
// 10个FuncPtrs指针的数�l?br />让我们假设你希望�Q�因为某些莫名其妙的原因�Q�把一个指向下面函数的指针存入funcPtrArray数组�Q?br />int doSomething();
你不能不�l�过�c�d��转换而直接去做，因�ؓdoSomething函数对于funcPtrArray数组来说有一个错误的�c�d��。在FuncPtrArray数组里的函数�q�回值是void�c�d��Q�而doSomething函数�q�回值是int�c�d��?br />funcPtrArray[0] = &doSomething; // 错误�Q�类型不匚w��
reinterpret_cast可以让你�q��ɾ~�译�K�q?/span>

Stone Jiang 2006-04-16 14:21 发表评论

今天喜得两本�?需要的��L��a�

Stone Jiang — Fri, 14 Apr 2006 02:14:00 GMT
1.
C++ Coding Standards: 101 Rules, Guidelines, and Best Practices
By Herb Sutter, Andrei Alexandrescu

�q�本书得�?005 Jolt大奖

2. The Art or Unix Programming
�q�是�l�xxx和yyyy以来的最优秀的Unix�ȝ��.

Stone Jiang 2006-04-14 10:14 发表评论

通过模板实现"多态�?,避开�l�承带来的性能开销之讨�?

Stone Jiang — Fri, 14 Apr 2006 01:29:00 GMT

多态生其实�q�可以通过�cȝ��聚合或组合的方式来达�?wbr>,从而还可以避免�l�承或多�l�承,

代码如下 (未在开发环境中调试)
#include <stdio.h>

template <class T>
class A
{
public:
  void print()
  {
    base_.b();
  }
  typename T base_;
};

class B
{
public:
  void b()
  {
    printf(" Class B---------------------\n");
  }
};

class C
{
public:
  void b()
  {
    printf(" Class C---------------------\n");
  }
};

int main(int, char* [])
{
  A<B> c;
  c.print();
  A<C> c2;
  c2.print();
  return 0;
}

Stone Jiang 2006-04-14 09:29 发表评论

Stone Jiang — Thu, 13 Apr 2006 10:21:00 GMT
今天在看��C��位网友关于泛型编�E�的一个问�?源代码我�E�整理变成这个样�?
�q�里是＂多态性＂的一�U�实现方�?/div>

#include <stdio.h>

template <class BASE>
class A : public BASE
{
public:
  void print()
  {
    BASE::b();
  }
};

class B
{
public:
  void b()
  {
    printf(" Class B---------------------\n");
  }
};

class C
{
public:
  void b()
  {
    printf(" Class C---------------------\n");
  }
};

int main(int, char* [])
{
  A<B> c;
  c.print();
  A<C> c2;
  c2.print();
  return 0;
}

��管General Programming 与Object-Oriend Programming没有什么优劣之�?如做乘法和做加法没有�?wbr>坏之分一��P��
但这里，我还是想问一下，�q�里有模板有什么具体的好处�Q?/div>

与之�{�效的我可以通过从基�c�L��生的方式�Q�实现同��L��效果�Q�但众所周知�Q��承伴随着是virtual table和性能下降�Q�这里，用这�U�方法显然可以避开上述问题�Q?/wbr>

�q�只是我的认知能力，��Z��抛砖引玉的目的，希望大家能多发表�Ҏ��?wbr>�Q�这�q�有什么益处呢�Q?/wbr>

Stone Jiang 2006-04-13 18:21 发表评论

C++�~�码不规范出现的错误一例的解析

Stone Jiang — Tue, 11 Apr 2006 07:29:00 GMT

在Huihoo的ACE论坛中，有一�|�友问到��Z��么ACE_Time_Value的秒数在Debug版本��一�U�，�?br />在Release版本上“正常”。经�q�对其代码的复读以及对ACE的跟�t�，发现原来是编码不规范�?br />下的一个很严重的错误造成的。本文就讨论�q�一例子�?br />
以下引用

1 /*
2 我写了个从年月日时分�U�数值得到ACE_Time_Value�l�果的函�?
3 */
4 long s_get_ace_datetime(ACE_Time_Value & ace_datetime,
5       int year,
6       int month,
7       int day,
8       int hour,
9       int min,
10       int sec)
11 {
12     if(year<1970 || year>2038 || month<1 || month>12 || day<1 || day>31 ||
13         hour<0 || hour>23 || min<0 || min>59 || sec<0 || sec>59)
14           ACE_ERROR_RETURN((LM_ERROR,
15                          ACE_TEXT("%I(日期旉��参数溢出合理的习惯日期时间范�?970.1.2-2038.1.18)n")),-1);
16     timespec_t spec_t;
17     tm time_tm;
18   time_tm.tm_year=year-1900;
19   time_tm.tm_mon=month-1;
20   time_tm.tm_mday=day;
21   time_tm.tm_hour=hour;
22   time_tm.tm_min=min;
23   #if defined (ACE_NDEBUG)
24     time_tm.tm_sec=sec;
25   #else
26     time_tm.tm_sec=sec+1; //奇�?当由各部分数量构造ACE_Time_Value�?debug�~�译�?�U�的数量��L��自动�?,在此要补�?
27   #endif
28    spec_t.tv_sec=mktime(&time_tm);
29    if(spec_t.tv_sec<0)
30    ACE_ERROR_RETURN((LM_ERROR,ACE_TEXT("%I(日期旉��转化错误,得到<0的time_t,日期范围�?970.1.2-2038.1.18)n")),-1);
31    ace_datetime.set(spec_t);
32    return 0;
33 }
34 /*
35 我在VC++7.1上分别编译了Debug版本和Release版本,time_tm.tm_sec竟然会有一�U�的差别,莫名其妙地媄响了我的��目.
36 哪位高手知道��Z��?
37 另外ACE_Time_Value的范围太��?ACE中是否有大日期时间范围的其它�c�d��?
38 */

以下是我的回�?

你这个问题还真有��?我跟�t�了ACE相关代码后才发现,问题原来出在你写的函��C��,病因�?使用未完全初始化的结构体变量

timespec_t spec_t;
后面加上语句
memset( &spec_t ,0,sizeof(timespec_t));
卛_��

局部变量 spec_t 在debug�?各字�D�均被初始化�?xCCCCCCCC,它是一个负�?br />在下面的操作�?只修改了tv_sec,而tv_nsec 仍�ؓ一个负�?br />spec_t.tv_sec=mktime( &time_tm );

ACE_Time_Value::normalize()默默��Cؓ你作了规格化处理�Q�就替你减去了一�U�钟�?br />

原代码更严重的错误在于：
原以�?Release版本是“正常”的�Q�其实不�Ӟ��而是Release隐藏了更严重的错误�?br />严重是因为它表现出错误的时候很随机�Q�一旦��品发布，很难发现�?br />

// 对象(�l�构�?timespec有两个公有属�?/span>
typedef struct timespec
      {
       time_t tv_sec; // Seconds
        long tv_nsec; // Nanoseconds, 十亿分之一�U?/span>
     } timespec_t;


在原代码16�?br />timespec_t spec_t;
构造了一�?timespec_t 临时对象spec_t�?debug版把它各字段初始化�ؓ 0xcccccccc,�q��得问题一下子得于曝光.而Release版本, spec_t ��Z��个随机�? 本例�E�中,不允�?spec_t的tv_nsec为非0的�Q何数,为正常尽��看上去没有问题,但是�q�个对应的ACE_Time_Value的��g��不可�?在特定情况下可能产生重大事故.

C++�~�码规范�Q?br />初始化对象时要完全�?/p>
声明一个结构体后，如果要对其初始化�Q�徏议先把它设�ؓ0之后再作后箋操作�Q�养成这样一个习惯，��׃��会出现这样郁��L��事了�?br />

原脓出处:
http://www.huihoo.com/forum/viewthread.php?tid=11016

mooyee

Stone Jiang 2006-04-11 15:29 发表评论

C++ Coding Standards: 101 Rules, Guidelines, and Best Practices
By Herb Sutter, Andrei Alexandrescu

在线欧美小视频,美国成人直播,久久狠狠亚洲综合

在Visual Studio 2005下��用CPPUnit向导

面向对象vs��Z��对象

面向对象vs��Z��对象

�E�序员的八荣八�?-- 来源不详

关于用例的随�W?

关于用例模式的一句话评论

static_cast<>揭密 (�?

C/C++ 内存���理 Heap vs Stack

避免依赖的消息处理方�?(试译)

保持����?/font>

双重分派

socket�~�程�Q�SO_REUSEADDR例解 (�?

谈谈C++�l�承中的重蝲�Q�覆盖和隐藏 (�?

STL中map与hash_map容器的选择 (�?

STL中map与hash_map容器的选择

���单讲解ACE_SOCK Wrapper Class的���?原创)

巧用虚友元函�?原创)

C++风格的类型�{换的用法 (�?

今天喜得两本�?需要的��L���a�

通过模板实现"多态�?,避开�l�承带来的性能开销之讨�?

C++�~�码不规范出现的错误一例的解析

C/C++ 内存��理 Heap vs Stack

保持��?/font>

��单讲解ACE_SOCK Wrapper Class的��?原创)

今天喜得两本�?需要的��L��a�