亚洲精品中文字幕在线,国产精品国产三级国产aⅴ浪潮,在线观看一区二区精品视频

转：位运��符的一些简单应�?

Sandy — Tue, 28 Jul 2009 08:21:00 GMT

今天看的一些东西用��C��位运��符�Q�这里有一��文章也谈了一些位�q�算�W�的��单操作。还不错�?br>转过来了�?br>
摘自�Q?a href="http://www.shnenglu.com/pengkuny/archive/2007/04/21/22551.html">http://www.shnenglu.com/pengkuny/archive/2007/04/21/22551.html

位运��符的一些简单应�?/font>

位运��符有：&(按位�?、|(按位�?、^(按位异或)、~ (按位取反)�?
优先�U�从高到低，依次为~�?amp;、^、|�Q?

位运��符的一些简单应�?
按位与运��有两种典型用法�Q�一是取一个位串信息的某几位，如以下代码截取x的最�?位：x & 0177。二是让某变量保留某几位�Q�其余位�|?�Q�如以下代码让x只保留最�?位：x = x & 077�?/p>

按位或运��的典型用法是将一个位串信息的某几位置�?。如��要获得最�?�?�Q�其他位与变量j的其他位相同�Q�可用逻辑或运��?17|j

按位异或�q�算的典型用法是求一个位串信息的某几位信息的反。如�Ʋ求整型变量j的最�?位信息的反，用逻辑异或�q�算017^j�Q�就能求得j最�?位的信息的反,卛_��来�ؓ1的位�Q�结果是0,原来�?的位�Q�结果是1�?交换两个��|��不用临时变量,假如a=3,b=4。想��a和b的��g��换，可以用以下赋��D��句实玎ͼ�
a=a^b; b=b^a; a=a^b;

取反�q�算常用来生成与�pȝ��实现无关的常数。如要将变量x最�?位置�?�Q�其余位不变�Q�可用代码x = x & ~077实现。以上代码与整数x�?个字节还是用4个字节实现无兟�?
当两个长度不同的数据�q�行位运��时(例如long型数据与int型数�?�Q�将两个�q�算分量的右端对齐进行位�q�算。如果短的数为正敎ͼ�高位�?补满�Q�如果短的数��敎ͼ�高位�?补满。如果短的�ؓ无符��h��敎ͼ�则高位��L��?补满�?/p>

位运��用来对位串信息�q�行�q�算�Q�得��C��串信息结果。如以下代码能取下整型变量k的位串信息的最双��?的信息位�Q?(k-1)^k) & k�?

对于带符��L��数据�Q�如果移位前�W�号位�ؓ0(正数)�Q�则左端也是�?补充�Q�如果移位前�W�号位�ؓ1(负数)�Q�则左端�?或用1补充�Q�取决于计算机系�l�。对于负数右�U�，�U�用0 补充的系�l��ؓ“逻辑右移”�Q�用1补充的系�l��ؓ“��术右移”。以下代码能说明读者上机的�pȝ��所采用的右�U�L��法：
printf("%d\n\n\n", -2>>4);
若输出结果�ؓ-1�Q�是采用��术右移�Q�输出结果�ؓ一个大整数�Q�则为逻辑右移�?/p>

�U�M��q�算与位�q�算�l�合能实现许多与位串�q�算有关的复杂计��。设变量的位自右臛_��序�~�号�Q�自0位至15位，有关指定位的表达式是不超�q?5的正整数。以下各代码分别有它们右�Ҏ��释所�C�的意义�Q?br>   (1) 判断int型变量a是奇数还是偶�?��其是对大数的判�?br>        a&1 == 0 偶数
        a&1 == 1 奇数
    (2) 取int型变量a的第k�?(k=0,1,2……sizeof(int))
a>>k&1
    (3) ��int型变量a的第k位清0
a=a&~(1<    (4) ��int型变量a的第k位置1
a=a|(1<    (5) int型变量��@环左�U�k��?br> a=a<>16-k   (设sizeof(int)=16)
    (6) int型变量a循环右移k��?br> a=a>>k|a<<16-k   (设sizeof(int)=16)
    (7) 实现最低n位�ؓ1�Q�其余位�?的位串信�?
~�Q�~0 << n�Q?
    (8)截取变量x自p位开始的双��n位的信息:
(x >> (1+p-n)) & ~(~0 << n)
    (9)截取old变量�W�row位，�q�将该位信息装配到变量new的第15-k�?br> new |= ((old >> row) & 1) << (15 – k)
    (10)设s不等于全0�Q�代码寻找最双��?的位的序号j:
for(j = 0; ((1 << j) & s) == 0; j++) ;

有些用法�q�未考证

Sandy 2009-07-28 16:21 发表评论

�? C++ 虚函数表解析

Sandy — Fri, 03 Jul 2009 09:32:00 GMT

C++ 虚函数表解析

陈皓

http://blog.csdn.net/haoel

前言

C++中的虚函数的作用主要是实��C��多态的机制。关于多态，��而言之就是用父类型别的指针指向其子类的实例，然后通过父类的指针调用实际子�cȝ��成员函数。这�U�技术可以让父类的指针有“多种形�?#8221;�Q�这是一�U�泛型技术。所谓泛型技术，说白了就是试图��用不变的代码来实现可变的��法。比如：模板技术，RTTI技术，虚函数技术，要么是试囑ց�到在�~�译时决议，要么试图做到�q�行时决议�?/p>

关于虚函数的使用�Ҏ��Q�我在这里不做过多的阐述。大家可以看看相关的C++的书�c�。在�q�篇文章中，我只想从虚函数的实现机制上面为大�?一个清晰的剖析�?/p>

当然�Q�相同的文章在网上也出现�q�一些了�Q�但我��L��觉这些文章不是很�Ҏ��阅读�Q�大�D�大�D늚�代码�Q�没有图片，没有详细的说明，没有比较�Q�没有�D一反三。不利于学习和阅读，所以这是我惛_��下这��文章的原因。也希望大家多给我提意见�?/p>

�a�归正传，让我们一赯��入虚函数的世界�?/p>

虚函数表

对C++ 了解的�h都应该知道虚函数�Q�Virtual Function�Q�是通过一张虚函数表（Virtual Table�Q�来实现的。简�U�CؓV-Table。在�q�个表中�Q�主是要一个类的虚函数的地址表，�q�张表解决了�l�承、覆盖的问题�Q�保证其容真实反应实际的函数。这��P��在有虚函数的�cȝ��实例中这个表被分配在了这个实例的内存中，所以，当我们用父类的指针来操作一个子�cȝ��时候，�q�张虚函数表��显得由为重要了�Q�它��像一个地图一��P��指明了实际所应该调用的函数�?/p>

�q�里我们着重看一下这张虚函数表。C++的编译器应该是保证虚函数表的指针存在于对象实例中最前面的位�|�（�q�是��Z��保证取到虚函数表的有最高的性能——如果有多层�l�承或是多重�l�承的情况下�Q��?�q�意味着我们通过对象实例的地址得到�q�张虚函数表�Q�然后就可以遍历其中函数指针�Q��ƈ调用相应的函数�?/p>

听我扯了那么多，我可以感觉出来你现在可能比以前更加晕头�{向了�?没关�p�，下面��是实际的例子，�怿�聪明的你一看就明白了�?/p>

假设我们有这��L��一个类�Q?/p>

class Base {

public:

virtual void f() { cout << "Base::f" << endl; }

virtual void g() { cout << "Base::g" << endl; }

virtual void h() { cout << "Base::h" << endl; }

};

按照上面的说法，我们可以通过Base的实例来得到虚函数表�?下面是实际例�E�：

typedef void(*Fun)(void);

Base b;

Fun pFun = NULL;

cout << "虚函数表地址�Q? << (int*)(&b) << endl;

cout << "虚函数表 �?�W�一个函数地址�Q? << (int*)*(int*)(&b) << endl;

// Invoke the first virtual function

pFun = (Fun)*((int*)*(int*)(&b));

pFun();

实际�q�行�l�果如下�Q?Windows XP+VS2003, Linux 2.6.22 + GCC 4.1.3)

虚函数表地址�Q?012FED4

虚函数表 �?�W�一个函数地址�Q?044F148

Base::f

通过�q�个�C�Z��Q�我们可以看刎ͼ�我们可以通过��?amp;b转成int *�Q�取得虚函数表的地址�Q�然后，再次取址��可以得到第一个虚函数的地址了，也就是Base::f()�Q�这在上面的�E�序中得��C��验证�Q�把int* 强制转成了函数指针）。通过�q�个�C�Z��Q�我们就可以知道如果要调用Base::g()和Base::h()�Q�其代码如下�Q?/p>

(Fun)*((int*)*(int*)(&b)+0); // Base::f()

(Fun)*((int*)*(int*)(&b)+1); // Base::g()

(Fun)*((int*)*(int*)(&b)+2); // Base::h()

�q�个时候你应该懂了吧。什么？�q�是有点晕。也是，�q�样的代码看着太�ؕ了。没问题�Q�让我画个图解释一下。如下所�C�：

注意�Q�在上面�q�个图中�Q�我在虚函数表的最后多加了一个结点，�q�是虚函数表的结束结点，��像字符串的�l�束�W?#8220;\0”一��P��其标志了虚函数表的结束。这个结束标志的值在不同的编译器下是不同的。在WinXP+VS2003下，�q�个值是NULL。而在Ubuntu 7.10 + Linux 2.6.22 + GCC 4.1.3下，�q�个值是如果1�Q�表�C��有下一个虚函数表，如果值是0�Q�表�C�是最后一个虚函数表�?/p>

下面�Q�我��分别说�?#8220;无覆�?#8221;�?#8220;有覆�?#8221;时的虚函数表的样子。没有覆盖父�cȝ��虚函数是毫无意义的。我之所以要讲述没有覆盖的情况，主要目的是�ؓ了给一个对比。在比较之下�Q�我们可以更加清楚地知道其内部的具体实现�?/p>

一般��承（无虚函数覆盖�Q?br>

下面�Q�再让我们来看看�l�承时的虚函数表是什么样的。假设有如下所�C�的一个��承关�p�：

��h��意，在这个��承关�p�M��Q�子�c�L��有重载�Q何父�cȝ��函数。那么，在派生类的实例中�Q�其虚函数表如下所�C�：

对于实例�Q�Derive d; 的虚函数表如下：

我们可以看到下面几点�Q?/p>

1�Q�虚函数按照其声明顺序放于表中�?/p>

2�Q�父�cȝ��虚函数在子类的虚函数前面�?/p>

我相信聪明的你一定可以参考前面的那个�E�序�Q�来�~�写一�D늨�序来验证�?/p>

一般��承（有虚函数覆盖�Q?br>

覆盖父类的虚函数是很昄��的事情，不然�Q�虚函数��变得毫无意义。下面，我们来看一下，如果子类中有虚函数重载了父类的虚函数�Q�会是一个什么样子？假设�Q�我们有下面�q�样的一个��承关�p�R�?/p>

��Z��让大家看到被�l�承�q�后的效果，在这个类的设计中�Q�我只覆盖了父类的一个函敎ͼ�f()。那么，对于�z��cȝ��实例�Q�其虚函数表会是下面的一个样子：

我们从表中可以看��C��面几点，

1�Q�覆盖的f()函数被放��C��虚表中原来父�c�虚函数的位�|��?/p>

2�Q�没有被覆盖的函��C��旧�?/p>

�q�样�Q�我们就可以看到对于下面�q�样的程序，

Base *b = new Derive();

b->f();

由b所指的内存中的虚函数表的f()的位�|�已�l�被Derive::f()函数地址所取代�Q�于是在实际调用发生�Ӟ��是Derive::f()被调用了。这��实��C��多态�?/p>

多重�l�承�Q�无虚函数覆盖）

下面�Q�再让我们来看看多重�l�承中的情况�Q�假设有下面�q�样一个类的��承关�p�R��注意：子类�q�没有覆盖父�cȝ��函数�?/p>

对于子类实例中的虚函数表�Q�是下面�q�个样子�Q?/p>

我们可以看到�Q?/p>

1�Q?nbsp; 每个父类都有自己的虚表�?/p>

2�Q?nbsp; 子类的成员函数被攑ֈ�了第一个父�cȝ��表中。（所谓的�W�一个父�c�L��按照声明��序来判断的�Q?/p>

�q�样做就是�ؓ了解决不同的父类�c�d��的指针指向同一个子�c�d��例，而能够调用到实际的函数�?/p>

多重�l�承�Q�有虚函数覆盖）

下面我们再来看看�Q�如果发生虚函数覆盖的情��c�?/p>

下图中，我们在子�c�M��覆盖了父�cȝ��f()函数�?/p>

下面是对于子�c�d��例中的虚函数表的图：

我们可以看见�Q�三个父�c�虚函数表中的f()的位�|�被替换成了子类的函数指针。这��P��我们��可以�Q一静态类型的父类来指向子�c�，�q�调用子�cȝ��f()了。如�Q?/p>

Derive d;

Base1 *b1 = &d;

Base2 *b2 = &d;

Base3 *b3 = &d;

b1->f(); //Derive::f()

b2->f(); //Derive::f()

b3->f(); //Derive::f()

b1->g(); //Base1::g()

b2->g(); //Base2::g()

b3->g(); //Base3::g()

安全�?br>

每次写C++的文章，��d��不了要批判一下C++。这��文章也不例外。通过上面的讲�q�ͼ��怿�我们对虚函数表有一个比较细致的了解了。水可蝲舟，亦可覆舟。下面，让我们来看看我们可以用虚函数表来�q�点什么坏事吧�?/p>

一、通过父类型的指针讉K��子类自己的虚函数

我们知道�Q�子�c�L��有重载父�cȝ��虚函数是一件毫无意义的事情。因为多态也是要��Z��函数重蝲的。虽然在上面的图中我们可以看到Base1的虚表中有Derive的虚函数�Q�但我们�Ҏ��不可能��用下面的语句来调用子�cȝ��自有虚函敎ͼ�

Base1 *b1 = new Derive();

b1->f1(); //�~�译出错

��M��妄图使用父类指针惌��用子�c�M��的未覆盖父类的成员函数的行�ؓ都会被编译器视�ؓ非法�Q�所以，�q�样的程序根本无法编译通过。但在运行时�Q�我们可以通过指针的方式访问虚函数表来辑ֈ��q�反C++语义的行为。（关于�q�方面的��试�Q�通过阅读后面附录的代码，�怿�你可以做到这一点）

二、访问non-public的虚函数

另外�Q�如果父�cȝ��虚函数是private或是protected的，但这些非public的虚函数同样会存在于虚函数表中，所以，我们同样可以使用讉K��虚函数表的方式来讉K��q�些non-public的虚函数�Q�这是很�Ҏ��做到的�?/p>

如：

class Base {

private:

virtual void f() { cout << "Base::f" << endl; }

};

class Derive : public Base{

};

typedef void(*Fun)(void);

void main() {

Derive d;

Fun pFun = (Fun)*((int*)*(int*)(&d)+0);

pFun();

}

�l�束�?br>C++�q�门语言是一门Magic的语�a��Q�对于程序员来说�Q�我们似乎永�q�摸不清楚这门语�a�背着我们在干了什么。需要熟悉这门语�a��Q�我们就必需要了解C++里面的那些东西，需要去了解C++中那些危险的东西。不�Ӟ��q�是一�U�搬��L��头砸自己脚的�~�程语言�?/p>

在文章束之前�q�是介绍一下自己吧。我从事软�g研发有十个年头了�Q�目前是软�g开发技术主��，技术方面，��L��Unix/C/C++�Q�比较喜�Ƣ网�l�上的技术，比如分布式计��，�|�格计算�Q�P2P�Q�Ajax�{�一切和互联�|�相关的东西。管理方面比较擅长于团队��Q�技术趋势分析，��目��理。欢�q�大家和我交��，我的MSN和Email是：haoel@hotmail.com

附录一�Q�VC中查看虚函数�?br>

我们可以在VC的IDE环境中的Debug状态下展开�cȝ��实例��可以看到虚函数表了�Q��ƈ不是很完整的�Q?/p>

附录二：例程
下面是一个关于多重��承的虚函数表讉K��的例�E�：

#include

using namespace std;

class Base1 {

public:

virtual void f() { cout << "Base1::f" << endl; }

virtual void g() { cout << "Base1::g" << endl; }

virtual void h() { cout << "Base1::h" << endl; }

};

class Base2 {

public:

virtual void f() { cout << "Base2::f" << endl; }

virtual void g() { cout << "Base2::g" << endl; }

virtual void h() { cout << "Base2::h" << endl; }

};

class Base3 {

public:

virtual void f() { cout << "Base3::f" << endl; }

virtual void g() { cout << "Base3::g" << endl; }

virtual void h() { cout << "Base3::h" << endl; }

};

class Derive : public Base1, public Base2, public Base3 {

public:

virtual void f() { cout << "Derive::f" << endl; }

virtual void g1() { cout << "Derive::g1" << endl; }

};

typedef void(*Fun)(void);

int main()

{

Fun pFun = NULL;

Derive d;

int** pVtab = (int**)&d;

//Base1's vtable

//pFun = (Fun)*((int*)*(int*)((int*)&d+0)+0);

pFun = (Fun)pVtab[0][0];

pFun();

//pFun = (Fun)*((int*)*(int*)((int*)&d+0)+1);

pFun = (Fun)pVtab[0][1];

pFun();

//pFun = (Fun)*((int*)*(int*)((int*)&d+0)+2);

pFun = (Fun)pVtab[0][2];

pFun();

//Derive's vtable

//pFun = (Fun)*((int*)*(int*)((int*)&d+0)+3);

pFun = (Fun)pVtab[0][3];

pFun();

//The tail of the vtable

pFun = (Fun)pVtab[0][4];

cout<

//Base2's vtable

//pFun = (Fun)*((int*)*(int*)((int*)&d+1)+0);

pFun = (Fun)pVtab[1][0];

pFun();

//pFun = (Fun)*((int*)*(int*)((int*)&d+1)+1);

pFun = (Fun)pVtab[1][1];

pFun();

pFun = (Fun)pVtab[1][2];

pFun();

//The tail of the vtable

pFun = (Fun)pVtab[1][3];

cout<

//Base3's vtable

//pFun = (Fun)*((int*)*(int*)((int*)&d+1)+0);

pFun = (Fun)pVtab[2][0];

pFun();

//pFun = (Fun)*((int*)*(int*)((int*)&d+1)+1);

pFun = (Fun)pVtab[2][1];

pFun();

pFun = (Fun)pVtab[2][2];

pFun();

//The tail of the vtable

pFun = (Fun)pVtab[2][3];

cout<

return 0;

}

本文来自CSDN博客�Q��{载请标明出处�Q?a >http://blog.csdn.net/haoel/archive/2007/12/18/1948051.aspx

Sandy 2009-07-03 17:32 发表评论

�? C++ 对象的内存布局(�?

Sandy — Fri, 03 Jul 2009 09:21:00 GMT

C++ 对象的内存布局(�?

陈皓

http://blog.csdn.net/haoel

重复�l�承

下面我们再来看看�Q�发生重复��承的情况。所谓重复��承，也就是某个基�c�被间接地重复��承了多次�?/p>

下图是一个��承图�Q�我们重载了父类的f()函数�?/p>

其类�l�承的源代码如下所�C�。其中，每个�c�都有两个变量，一个是整�Ş�Q?字节�Q�，一个是字符�Q?字节�Q�，而且�q�有自己的虚函数�Q�自己overwrite父类的虚函数。如子类D中，f()覆盖了超�cȝ��函数�Q?f1() 和f2() 覆盖了其父类的虚函数�Q�Df()��q��虚函数�?/p>

class B

{

public:

int ib;

char cb;

public:

B():ib(0),cb('B') {}

virtual void f() { cout << "B::f()" << endl;}

virtual void Bf() { cout << "B::Bf()" << endl;}

};

class B1 : public B

{

public:

int ib1;

char cb1;

public:

B1():ib1(11),cb1('1') {}

virtual void f() { cout << "B1::f()" << endl;}

virtual void f1() { cout << "B1::f1()" << endl;}

virtual void Bf1() { cout << "B1::Bf1()" << endl;}

};

class B2: public B

{

public:

int ib2;

char cb2;

public:

B2():ib2(12),cb2('2') {}

virtual void f() { cout << "B2::f()" << endl;}

virtual void f2() { cout << "B2::f2()" << endl;}

virtual void Bf2() { cout << "B2::Bf2()" << endl;}

};

class D : public B1, public B2

{

public:

int id;

char cd;

public:

D():id(100),cd('D') {}

virtual void f() { cout << "D::f()" << endl;}

virtual void f1() { cout << "D::f1()" << endl;}

virtual void f2() { cout << "D::f2()" << endl;}

virtual void Df() { cout << "D::Df()" << endl;}

};

我们用来存取子类内存布局的代码如下所�C�：�Q�在VC++ 2003和G++ 3.4.4下）

typedef void(*Fun)(void);

int** pVtab = NULL;

Fun pFun = NULL;

D d;

pVtab = (int**)&d;

cout << "[0] D::B1::_vptr->" << endl;

pFun = (Fun)pVtab[0][0];

cout << " [0] "; pFun();

pFun = (Fun)pVtab[0][1];

cout << " [1] "; pFun();

pFun = (Fun)pVtab[0][2];

cout << " [2] "; pFun();

pFun = (Fun)pVtab[0][3];

cout << " [3] "; pFun();

pFun = (Fun)pVtab[0][4];

cout << " [4] "; pFun();

pFun = (Fun)pVtab[0][5];

cout << " [5] 0x" << pFun << endl;

cout << "[1] B::ib = " << (int)pVtab[1] << endl;

cout << "[2] B::cb = " << (char)pVtab[2] << endl;

cout << "[3] B1::ib1 = " << (int)pVtab[3] << endl;

cout << "[4] B1::cb1 = " << (char)pVtab[4] << endl;

cout << "[5] D::B2::_vptr->" << endl;

pFun = (Fun)pVtab[5][0];

cout << " [0] "; pFun();

pFun = (Fun)pVtab[5][1];

cout << " [1] "; pFun();

pFun = (Fun)pVtab[5][2];

cout << " [2] "; pFun();

pFun = (Fun)pVtab[5][3];

cout << " [3] "; pFun();

pFun = (Fun)pVtab[5][4];

cout << " [4] 0x" << pFun << endl;

cout << "[6] B::ib = " << (int)pVtab[6] << endl;

cout << "[7] B::cb = " << (char)pVtab[7] << endl;

cout << "[8] B2::ib2 = " << (int)pVtab[8] << endl;

cout << "[9] B2::cb2 = " << (char)pVtab[9] << endl;

cout << "[10] D::id = " << (int)pVtab[10] << endl;

cout << "[11] D::cd = " << (char)pVtab[11] << endl;

�E�序�q�行�l�果如下�Q?/p>

GCC 3.4.4
VC++ 2003

[0] D::B1::_vptr->

[0] D::f()

[1] B::Bf()

[2] D::f1()

[3] B1::Bf1()

[4] D::f2()

[5] 0x1

[1] B::ib = 0

[2] B::cb = B

[3] B1::ib1 = 11

[4] B1::cb1 = 1

[5] D::B2::_vptr->

[0] D::f()

[1] B::Bf()

[2] D::f2()

[3] B2::Bf2()

[4] 0x0

[6] B::ib = 0

[7] B::cb = B

[8] B2::ib2 = 12

[9] B2::cb2 = 2

[10] D::id = 100

[11] D::cd = D
[0] D::B1::_vptr->

[0] D::f()

[1] B::Bf()

[2] D::f1()

[3] B1::Bf1()

[4] D::Df()

[5] 0x00000000

[1] B::ib = 0

[2] B::cb = B

[3] B1::ib1 = 11

[4] B1::cb1 = 1

[5] D::B2::_vptr->

[0] D::f()

[1] B::Bf()

[2] D::f2()

[3] B2::Bf2()

[4] 0x00000000

[6] B::ib = 0

[7] B::cb = B

[8] B2::ib2 = 12

[9] B2::cb2 = 2

[10] D::id = 100

[11] D::cd = D

下面是对于子�c�d��例中的虚函数表的图：

我们可以看见�Q�最��端的父�c�B其成员变量存在于B1和B2中，�q�被D�l��承下��M��。而在D中，其有B1和B2的实例，于是B的成员在D的实例中存在两䆾�Q�一份是B1�l�承而来的，另一份是B2�l�承而来的。所以，如果我们使用以下语句�Q�则会��生二义性编译错误：

D d;

d.ib = 0; //二义性错�?/p>

d.B1::ib = 1; //正确

d.B2::ib = 2; //正确

注意�Q�上面例�E�中的最后两条语句存取的是两个变量。虽然我们消除了二义性的�~�译错误�Q�但B�c�d��D中还是有两个实例�Q�这�U��扉K��成了数据的重复�Q�我们叫�q�种�l�承为重复��ѝ��重复的基类数据成员可能�q�不是我们想要的。所以，C++引入了虚基类的概��c�?/p>

�ȝ��型多重虚拟��?br>

虚拟�l�承的出现就是�ؓ了解决重复��承中多个间接父类的问题的。钻矛_��的结构是其最�l�典的结构。也是我们在�q�里要讨论的�l�构�Q?/p>

上述�?#8220;重复�l�承”只需要把B1和B2�l�承B的语法中加上virtual 关键�Q�就成了虚拟�l�承�Q�其�l�承囑֦�下所�C�：

上图和前面的“重复�l�承”中的�cȝ��内部数据和接口都是完全一��L��Q�只是我们采用了虚拟�l�承�Q�其省略后的源码如下所�C�：

class B {……};

class B1 : virtual public B{……};

class B2: virtual public B{……};

class D : public B1, public B2{ …… };

在查看D之前�Q�我们先看一看单一虚拟�l�承的情��c��下面是一�D�在VC++2003下的��试�E�序�Q�（因�ؓVC++和GCC的内存而局上有一些细节上的不同，所以这里只�l�出VC++的程序，GCC下的�E�序大家可以�Ҏ��我给出的�E�序自己仿照着写一个去试一试）�Q?/p>

int** pVtab = NULL;

Fun pFun = NULL;

B1 bb1;

pVtab = (int**)&bb1;

cout << "[0] B1::_vptr->" << endl;

pFun = (Fun)pVtab[0][0];

cout << " [0] ";

pFun(); //B1::f1();

cout << " [1] ";

pFun = (Fun)pVtab[0][1];

pFun(); //B1::bf1();

cout << " [2] ";

cout << pVtab[0][2] << endl;

cout << "[1] = 0x";

cout << (int*)*((int*)(&bb1)+1) <

cout << "[2] B1::ib1 = ";

cout << (int)*((int*)(&bb1)+2) <

cout << "[3] B1::cb1 = ";

cout << (char)*((int*)(&bb1)+3) << endl; //B1::cb1

cout << "[4] = 0x";

cout << (int*)*((int*)(&bb1)+4) << endl; //NULL

cout << "[5] B::_vptr->" << endl;

pFun = (Fun)pVtab[5][0];

cout << " [0] ";

pFun(); //B1::f();

pFun = (Fun)pVtab[5][1];

cout << " [1] ";

pFun(); //B::Bf();

cout << " [2] ";

cout << "0x" << (Fun)pVtab[5][2] << endl;

cout << "[6] B::ib = ";

cout << (int)*((int*)(&bb1)+6) <

cout << "[7] B::cb = ";

其运行结果如下（我结��Z��GCC的和VC++2003的对比）�Q?/p>

GCC 3.4.4
VC++ 2003

[0] B1::_vptr ->

[0] : B1::f()

[1] : B1::f1()

[2] : B1::Bf1()

[3] : 0

[1] B1::ib1 : 11

[2] B1::cb1 : 1

[3] B::_vptr ->

[0] : B1::f()

[1] : B::Bf()

[2] : 0

[4] B::ib : 0

[5] B::cb : B

[6] NULL : 0
[0] B1::_vptr->

[0] B1::f1()

[1] B1::Bf1()

[2] 0

[1] = 0x00454310 ç该地址取值后�?4

[2] B1::ib1 = 11

[3] B1::cb1 = 1

[4] = 0x00000000

[5] B::_vptr->

[0] B1::f()

[1] B::Bf()

[2] 0x00000000

[6] B::ib = 0

[7] B::cb = B

�q�里�Q�大家可以自己对比一下。关于细节上�Q�我会在后面一�q�再说�?/p>

下面的测试程序是看子�c�D的内存布局�Q�同��h��VC++ 2003的（因�ؓVC++和GCC的内存布局上有一些细节上的不同，而VC++的相对要清楚很多�Q�所以这里只�l�出VC++的程序，GCC下的�E�序大家可以�Ҏ��我给出的�E�序自己仿照着写一个去试一试）�Q?/p>

D d;

pVtab = (int**)&d;

cout << "[0] D::B1::_vptr->" << endl;

pFun = (Fun)pVtab[0][0];

cout << " [0] "; pFun(); //D::f1();

pFun = (Fun)pVtab[0][1];

cout << " [1] "; pFun(); //B1::Bf1();

pFun = (Fun)pVtab[0][2];

cout << " [2] "; pFun(); //D::Df();

pFun = (Fun)pVtab[0][3];

cout << " [3] ";

cout << pFun << endl;

//cout << pVtab[4][2] << endl;

cout << "[1] = 0x";

cout << (int*)((&dd)+1) <

cout << "[2] B1::ib1 = ";

cout << *((int*)(&dd)+2) <

cout << "[3] B1::cb1 = ";

cout << (char)*((int*)(&dd)+3) << endl; //B1::cb1

//---------------------

cout << "[4] D::B2::_vptr->" << endl;

pFun = (Fun)pVtab[4][0];

cout << " [0] "; pFun(); //D::f2();

pFun = (Fun)pVtab[4][1];

cout << " [1] "; pFun(); //B2::Bf2();

pFun = (Fun)pVtab[4][2];

cout << " [2] ";

cout << pFun << endl;

cout << "[5] = 0x";

cout << *((int*)(&dd)+5) << endl; // ???

cout << "[6] B2::ib2 = ";

cout << (int)*((int*)(&dd)+6) <

cout << "[7] B2::cb2 = ";

cout << (char)*((int*)(&dd)+7) << endl; //B2::cb2

cout << "[8] D::id = ";

cout << *((int*)(&dd)+8) << endl; //D::id

cout << "[9] D::cd = ";

cout << (char)*((int*)(&dd)+9) << endl;//D::cd

cout << "[10] = 0x";

cout << (int*)*((int*)(&dd)+10) << endl;

//---------------------

cout << "[11] D::B::_vptr->" << endl;

pFun = (Fun)pVtab[11][0];

cout << " [0] "; pFun(); //D::f();

pFun = (Fun)pVtab[11][1];

cout << " [1] "; pFun(); //B::Bf();

pFun = (Fun)pVtab[11][2];

cout << " [2] ";

cout << pFun << endl;

cout << "[12] B::ib = ";

cout << *((int*)(&dd)+12) << endl; //B::ib

cout << "[13] B::cb = ";

cout << (char)*((int*)(&dd)+13) <

下面�l�出�q�行后的�l�果�Q�分VC++和GCC两部份）

GCC 3.4.4
VC++ 2003

[0] B1::_vptr ->

[0] : D::f()

[1] : D::f1()

[2] : B1::Bf1()

[3] : D::f2()

[4] : D::Df()

[5] : 1

[1] B1::ib1 : 11

[2] B1::cb1 : 1

[3] B2::_vptr ->

[0] : D::f()

[1] : D::f2()

[2] : B2::Bf2()

[3] : 0

[4] B2::ib2 : 12

[5] B2::cb2 : 2

[6] D::id : 100

[7] D::cd : D

[8] B::_vptr ->

[0] : D::f()

[1] : B::Bf()

[2] : 0

[9] B::ib : 0

[10] B::cb : B

[11] NULL : 0
[0] D::B1::_vptr->

[0] D::f1()

[1] B1::Bf1()

[2] D::Df()

[3] 00000000

[1] = 0x0013FDC4 ç 该地址取值后�?4

[2] B1::ib1 = 11

[3] B1::cb1 = 1

[4] D::B2::_vptr->

[0] D::f2()

[1] B2::Bf2()

[2] 00000000

[5] = 0x4539260 ç 该地址取值后�?4

[6] B2::ib2 = 12

[7] B2::cb2 = 2

[8] D::id = 100

[9] D::cd = D

[10] = 0x00000000

[11] D::B::_vptr->

[0] D::f()

[1] B::Bf()

[2] 00000000

[12] B::ib = 0

[13] B::cb = B

关于虚拟�l�承的运行结果我��׃��d��了（前面的作囑ַ��l�让我��生了很严重的厌倦感�Q�所以就偷个懒了�Q�大家见谅了�Q?/p>

在上面的输出�l�果中，我用不同的颜色做了一些标明。我们可以看到如下的几点�Q?/p>

1�Q�无论是GCC�q�是VC++�Q�除了一些细节上的不同，其大体上的对象布局是一��L��。也��是��_��先是B1�Q�黄�Ԍ��Q�然后是B2�Q�绿�Ԍ��Q�接着是D�Q�灰�Ԍ��Q�而B�q�个��类�Q�青蓝色�Q�的实例都放在最后的位置�?/p>

2�Q�关于虚函数表，��其是第一个虚表，GCC和VC++有很重大的不一栗��但仔细看下来，�q�是VC++的虚表比较清晰和有逻辑性�?/p>

3�Q�VC++和GCC都把B�q�个��类攑ֈ�了最后，而VC++有一个NULL分隔�W�把B和B1和B2的布局分开。GCC则没有�?/p>

4�Q�VC++中的内存布局有两个地址我有些不是很明白�Q�在其中我用�U�色标出了。取其内�Ҏ��-4。接道理来说�Q�这个指针应该是指向B�c�d��例的内存地址�Q�这个做法就是�ؓ了保证重复的父类只有一个实例的技术）。但取值后却不是。这�Ҏ��目前�q��ƈ不太清楚�Q�还向大家请教�?/p>

5�Q�GCC的内存布局中在B1和B2中则没有指向B的指针。这点可以理解，�~�译器可以通过计算B1和B2的size而得出B的偏�U�量�?/p>

�l�束�?br>C++�q�门语言是一门比较复杂的语言�Q�对于程序员来说�Q�我们似乎永�q�摸不清楚这门语�a�背着我们在干了什么。需要熟悉这门语�a��Q�我们就必需要了解C++里面的那些东西，需要我们去了解他后面的内存对象。这��h��们才能真正的了解C++�Q�从而能够更好的使用C++�q�门最隄��~�程语言�?/p>

本文来自CSDN博客�Q��{载请标明出处�Q?a >http://blog.csdn.net/haoel/archive/2008/10/15/3081385.aspx

Sandy 2009-07-03 17:21 发表评论

�? C++ 对象的内存布局(�?

Sandy — Fri, 03 Jul 2009 09:20:00 GMT

好文�?��怕找不到�?先�{到这�?好以后满满品�?

C++ 对象的内存布局(�?

陈皓

http://blog.csdn.net/haoel

前言

07�q?2月，我写了一��《C++虚函数表解析》的文章�Q�引起了大家的兴��。有很多朋友�Ҏ��的文章留了言�Q�有鼓励我的�Q�有批评我的�Q�还有很多问问题的。我在这里一�q�对大家的留�a�表示感谢。这也是我�ؓ什么再写一��箋�a�的原因。因为，在上一��文章中�Q�我用了的示例都是非常简单的�Q�主要是��Z��说明一些机理上的问题，也是��Z��图一些表达上方便和简单。不惻I��q�篇文章成�ؓ了打开C++对象模型内存布局的一个引子，引发了大家对C++对象的更深层�ơ的讨论。当�Ӟ��我之前的文章�q�有很多斚w��没有涉及�Q�从我个人感觉下来，在谈��函数表里�Q�至��有以下�q�些内容没有涉及�Q?/p>

1�Q�有成员变量的情��c�?/p>

2�Q�有重复�l�承的情��c�?/p>

3�Q�有虚拟�l�承的情��c�?/p>

4�Q�有�ȝ��型虚拟��承的情况�?/p>

�q�些都是我本��文章需要向大家说明的东�ѝ��所以，�q�篇文章��会是《C++虚函数表解析》的一个箋��，也是一��高�U�进阶的文章。我希望大家在读�q�篇文章之前对C++有一定的基础和了解，�q�能先读我的上一��文章。因��文章的深度可能会比较深�Q�而且会比较杂乱，我希望你在读本篇文章时不会有大脑思维紊�ؕ��D��大脑��L��的情��c�?-)

对象的媄响因�?br>

��而言之，我们一个类可能会有如下的媄响因素：

1�Q�成员变�?/p>

2�Q�虚函数�Q��生虚函数表）

3�Q�单一�l�承�Q�只�l�承于一个类�Q?/p>

4�Q�多重��承（�l�承多个�c�）

5�Q�重复��承（�l�承的多个父�c�M��其父�c�L��相同的超�c�）

6�Q�虚拟��承（使用virtual方式�l�承�Q��ؓ了保证��承后父类的内存布局只会存在一份）

上述的东襉K��常是C++�q�门语言在语义方面对对象内部的媄响因素，当然�Q�还会有�~�译器的影响�Q�比如优化）�Q�还有字节对齐的影响。在�q�里我们都不讨论�Q�我们只讨论C++语言上的影响�?/p>

本篇文章着重讨��Z��q�几个情况下的C++对象的内存布局情况�?/p>

1�Q�单一的一般��承（带成员变量、虚函数、虚函数覆盖�Q?/p>

2�Q�单一的虚拟��承（带成员变量、虚函数、虚函数覆盖�Q?/p>

3�Q�多重��承（带成员变量、虚函数、虚函数覆盖�Q?/p>

4�Q�重复多重��承（带成员变量、虚函数、虚函数覆盖�Q?/p>

5�Q�钻矛_��的虚拟多重��承（带成员变量、虚函数、虚函数覆盖�Q?/p>

我们的目标就是，让事情越来越复杂�?/p>

知识复习

我们��单地复习一下，我们可以通过对象的地址来取得虚函数表的地址�Q�如�Q?/p>

typedef void(*Fun)(void);

Base b;

Fun pFun = NULL;

cout << "虚函数表地址�Q? << (int*)(&b) << endl;

cout << "虚函数表 �?�W�一个函数地址�Q? << (int*)*(int*)(&b) << endl;

// Invoke the first virtual function

pFun = (Fun)*((int*)*(int*)(&b));

pFun();

我们同样可以用这�U�方式来取得整个对象实例的内存布局。因��些东西在内存中都是连�l�分布的�Q�我们只需要��用适当的地址偏移量，我们��可以获得整个内存对象的布局�?/p>

本篇文章中的例程或内存布局主要使用如下�~�译器和�pȝ��Q?/p>

1�Q�Windows XP �?VC++ 2003

2�Q�Cygwin �?G++ 3.4.4

单一的一般��?br>

下面�Q�我们假设有如下所�C�的一个��承关�p�：

��h��意，在这个��承关�p�M��Q�父�c�，子类�Q�孙子类都有自己的一个成员变量。而了�c�覆盖了父类的f()�Ҏ��Q�孙子类覆盖了子�cȝ��g_child()及其��类的f()�?/p>

我们的源�E�序如下所�C�：

class Parent {

public:

int iparent;

Parent ():iparent (10) {}

virtual void f() { cout << " Parent::f()" << endl; }

virtual void g() { cout << " Parent::g()" << endl; }

virtual void h() { cout << " Parent::h()" << endl; }

};

class Child : public Parent {

public:

int ichild;

Child():ichild(100) {}

virtual void f() { cout << "Child::f()" << endl; }

virtual void g_child() { cout << "Child::g_child()" << endl; }

virtual void h_child() { cout << "Child::h_child()" << endl; }

};

class GrandChild : public Child{

public:

int igrandchild;

GrandChild():igrandchild(1000) {}

virtual void f() { cout << "GrandChild::f()" << endl; }

virtual void g_child() { cout << "GrandChild::g_child()" << endl; }

virtual void h_grandchild() { cout << "GrandChild::h_grandchild()" << endl; }

};

我们使用以下�E�序作�ؓ��试�E�序�Q�（下面�E�序中，我��用了一个int** pVtab 来作为遍历对象内存布局的指针，�q�样�Q�我��可以方便地像��用数�l�一��h��遍历所有的成员包括其虚函数表了�Q�在后面的程序中�Q�我也是用这��L��Ҏ��的，请不必感到奇怪，�Q?/p>

typedef void(*Fun)(void);

GrandChild gc;

int** pVtab = (int**)&gc;

cout << "[0] GrandChild::_vptr->" << endl;

for (int i=0; (Fun)pVtab[0][i]!=NULL; i++){

pFun = (Fun)pVtab[0][i];

cout << " ["<

pFun();

}

cout << "[1] Parent.iparent = " << (int)pVtab[1] << endl;

cout << "[2] Child.ichild = " << (int)pVtab[2] << endl;

cout << "[3] GrandChild.igrandchild = " << (int)pVtab[3] << endl;

其运行结果如下所�C�：�Q�在VC++ 2003和G++ 3.4.4下）

[0] GrandChild::_vptr->

[0] GrandChild::f()

[1] Parent::g()

[2] Parent::h()

[3] GrandChild::g_child()

[4] Child::h1()

[5] GrandChild::h_grandchild()

[1] Parent.iparent = 10

[2] Child.ichild = 100

[3] GrandChild.igrandchild = 1000

使用囄��表示如下�Q?/p>

可见以下几个斚w��Q?/p>

1�Q�虚函数表在最前面的位�|��?/p>

2�Q�成员变量根据其�l�承和声明顺序依�ơ放在后面�?/p>

3�Q�在单一的��承中�Q�被overwrite的虚函数在虚函数表中得到了更新�?/p>

多重�l�承

下面�Q�再让我们来看看多重�l�承中的情况�Q�假设有下面�q�样一个类的��承关�p�R��注意：子类只overwrite了父�cȝ��f()函数�Q�而还有一个是自己的函敎ͼ�我们�q�样做的目的是�ؓ了用g1()作�ؓ一个标记来标明子类的虚函数表）。而且每个�c�M��都有一个自��q��成员变量�Q?/p>

我们的类�l�承的源代码如下所�C�：父类的成员初始�ؓ10�Q?0�Q?0�Q�子�cȝ��?00

class Base1 {

public:

int ibase1;

Base1():ibase1(10) {}

virtual void f() { cout << "Base1::f()" << endl; }

virtual void g() { cout << "Base1::g()" << endl; }

virtual void h() { cout << "Base1::h()" << endl; }

};

class Base2 {

public:

int ibase2;

Base2():ibase2(20) {}

virtual void f() { cout << "Base2::f()" << endl; }

virtual void g() { cout << "Base2::g()" << endl; }

virtual void h() { cout << "Base2::h()" << endl; }

};

class Base3 {

public:

int ibase3;

Base3():ibase3(30) {}

virtual void f() { cout << "Base3::f()" << endl; }

virtual void g() { cout << "Base3::g()" << endl; }

virtual void h() { cout << "Base3::h()" << endl; }

};

class Derive : public Base1, public Base2, public Base3 {

public:

int iderive;

Derive():iderive(100) {}

virtual void f() { cout << "Derive::f()" << endl; }

virtual void g1() { cout << "Derive::g1()" << endl; }

};

我们通过下面的程序来查看子类实例的内存布局�Q�下面程序中�Q�注意我使用了一个s变量�Q�其中用��C��sizof(Base)来找下一个类的偏�U�量。（因�ؓ我声明的是int成员�Q�所以是4个字节，所以没有对齐问题。关于内存的寚w��问题�Q�大家可以自行试验，我在�q�里��׃��多说了）

typedef void(*Fun)(void);

Derive d;

int** pVtab = (int**)&d;

cout << "[0] Base1::_vptr->" << endl;

pFun = (Fun)pVtab[0][0];

cout << " [0] ";

pFun();

pFun = (Fun)pVtab[0][1];

cout << " [1] ";pFun();

pFun = (Fun)pVtab[0][2];

cout << " [2] ";pFun();

pFun = (Fun)pVtab[0][3];

cout << " [3] "; pFun();

pFun = (Fun)pVtab[0][4];

cout << " [4] "; cout<

cout << "[1] Base1.ibase1 = " << (int)pVtab[1] << endl;

int s = sizeof(Base1)/4;

cout << "[" << s << "] Base2::_vptr->"<

pFun = (Fun)pVtab[s][0];

cout << " [0] "; pFun();

Fun = (Fun)pVtab[s][1];

cout << " [1] "; pFun();

pFun = (Fun)pVtab[s][2];

cout << " [2] "; pFun();

pFun = (Fun)pVtab[s][3];

out << " [3] ";

cout<

cout << "["<< s+1 <<"] Base2.ibase2 = " << (int)pVtab[s+1] << endl;

s = s + sizeof(Base2)/4;

cout << "[" << s << "] Base3::_vptr->"<

pFun = (Fun)pVtab[s][0];

cout << " [0] "; pFun();

pFun = (Fun)pVtab[s][1];

cout << " [1] "; pFun();

pFun = (Fun)pVtab[s][2];

cout << " [2] "; pFun();

pFun = (Fun)pVtab[s][3];

cout << " [3] ";

cout<

s++;

cout << "["<< s <<"] Base3.ibase3 = " << (int)pVtab[s] << endl;

s++;

cout << "["<< s <<"] Derive.iderive = " << (int)pVtab[s] << endl;

其运行结果如下所�C�：�Q�在VC++ 2003和G++ 3.4.4下）

[0] Base1::_vptr->

[0] Derive::f()

[1] Base1::g()

[2] Base1::h()

[3] Driver::g1()

[4] 00000000 ç 注意�Q�在GCC下，�q�里�?

[1] Base1.ibase1 = 10

[2] Base2::_vptr->

[0] Derive::f()

[1] Base2::g()

[2] Base2::h()

[3] 00000000 ç 注意�Q�在GCC下，�q�里�?

[3] Base2.ibase2 = 20

[4] Base3::_vptr->

[0] Derive::f()

[1] Base3::g()

[2] Base3::h()

[3] 00000000

[5] Base3.ibase3 = 30

[6] Derive.iderive = 100

使用囄��表示是下面这个样子：

我们可以看到�Q?/p>

1�Q?nbsp; 每个父类都有自己的虚表�?/p>

2�Q?nbsp; 子类的成员函数被攑ֈ�了第一个父�cȝ��表中�?/p>

3�Q?nbsp; 内存布局中，其父�c�d��局依次按声明顺序排列�?/p>

4�Q?nbsp; 每个父类的虚表中的f()函数都被overwrite成了子类的f()。这样做��是��Z��解决不同的父�cȝ��型的指针指向同一个子�c�d��例，而能够调用到实际的函数�?/p>

本文来自CSDN博客�Q��{载请标明出处�Q?a >http://blog.csdn.net/haoel/archive/2008/10/15/3081328.aspx

Sandy 2009-07-03 17:20 发表评论

Sandy — Thu, 16 Apr 2009 02:11:00 GMT

今天在首��늜�到的,感觉不错,摘过来保存一�?
http://www.shnenglu.com/CornerZhang/archive/2009/04/13/79004.html
内容如下:

头文件依赖，Pimpl法，加速编�?br>   举个例子:
      // File: SoundSystem.h

      #include "StreamFilter.h"
      #include "Emitters."

      class SoundSystem {
      public:
         // ...
      private:
         StreamFilter currentFilter;
         EmitModeConfig modeConfig;
      };
   一目了然的是，看得出SoundSystem实现使用了StreamFilter和EmitModeConfig的定义，所�?include 了他们的定义在此SoundSystem.h中，可是随着��目的不断推�q�，class SoundSystem中依赖的使用�c�d��会增多，它的header被引入到其它模块中，不知不觉的编译时间越来越长，改进之：
      // File: SoundSystem.h

      class StreamFilter;
      class EmitModeConfig;

      class SoundSystem {
      public:
         // ...
      private:
         StreamFilter* currentFilterPtr;
         EmitModeConfig* modeConfigPtr;
      };

      // File: SoundSystem.cpp
      #include "StreamFilter.h"
      #include "Emitters."

      SoundSystem::SoundSystem() {
         //...
         currentFilterPtr = new StreamFilter;
         modeConfigPtr = new EmitModeConfig;
      }

      SoundSystem::~SoundSystem() {
         delete currentFilterPtr;
         delete modeConfigPtr;
         //...
      }
      �q�么一来，把StreamFilter和EmitModeConfig�?include藏到了SoundSystem的实��C��码中�Q�以后对SoundSystem的部分改动不会导致其它模块的rebuild哦，不过由此可能会牺牲一�Ҏ��率吧!

      记得�Q�有位微软的C++��楚人物�Q�Herb Sutter�l�这�U�技巧称为Pimpl ( Private Implemention ), 用的恰到好处�Ӟ��可以提高��目开发速度�Q�同时模块的头文仉��?include关系得以�~�解�Q�可以避开循环依赖�Q�而且可以获得一个良好的物理设计�?br>
�ȝ��:
      Pimpl�Ҏ��感觉很不�?
      使用�q�个�Ҏ��的时�?一定要注意的是在这个地方的变化,�q�个是我�W�二遍看的时候才注意到的.
     class SoundSystem {
      public:
         // ...
      private:
         StreamFilter currentFilter;
         EmitModeConfig modeConfig;
      };

      采用Pimpl�Ҏ��?变�ؓ
     class SoundSystem {
      public:
         // ...
      private:
         StreamFilter* currentFilterPtr;
         EmitModeConfig* modeConfigPtr;
      };
      所以在.cpp文�g中就有了new和delete的操�?

      对于�q�种�Ҏ��有一个疑�?对于那种存在包含众多�cȝ��情况�?�q�种�Ҏ��的驾驭不是一般�h能够掌握的吧.或许�q�种�Ҏ��׃��太��用了,不如�{�待一�?�~�译.

Sandy 2009-04-16 10:11 发表评论

Sandy — Fri, 26 Dec 2008 10:46:00 GMT

�q�程的互斥运�?br>http://bbs.onlycpp.net/viewthread.php?tid=540&extra=page%3D1

　　正常情况下，一个进�E�的�q�行一般是不会影响到其他正在运行的�q�程的。但是对于某些有�Ҏ��要求的如以独占方式��用串行口�{�硬件设备的�E�序��p��求在其进�E�运行期间不允许其他试图使用此端口设备的�E�序�q�行的，而且此类�E�序通常也不允许�q�行同一个程序的多个实例。这��引��Z��q�程互斥的问题�?br>
　　实现�q�程互斥的核心思想比较��单：�q�程在启动时首先��查当前系�l�是否已�l�存在有此进�E�的实例�Q�如果没有，�q�程��成功创建�ƈ讄��标识实例已经存在的标记。此后再创徏�q�程时将会通过该标记而知晓其实例已经存在�Q�从而保证进�E�在�pȝ��中只能存在一个实例。具体可以采�?span class=t_tag onclick=tagshow(event) href="tag.php?name=%C4%DA%B4%E6">内存映射文�g、有名事仉��、有名互斥量以及全局�׃�n变量�{�多�U�方法来实现。下面就分别对其中具有代表性的有名互斥量和全局�׃�n变量�q�两�U�方法进行介�l�：

// 创徏互斥�?br>HANDLE m_hMutex = CreateMutex(NULL, FALSE, "Sample07");
// ��查错误代�?br>if (GetLastError() == ERROR_ALREADY_EXISTS) {
　// 如果已有互斥量存在则释放句柄�q�复位互斥量
　CloseHandle(m_hMutex);
　m_hMutex = NULL;
　// �E�序退�?br>　return FALSE;
}

　　上面�q�段代码演示了有名互斥量在进�E�互斥中�?span class=t_tag onclick=tagshow(event) href="tag.php?name=%D3%C3%B7%A8">用法。代码的核心是CreateMutex�Q�）�Ҏ��名互斥量的创建。CreateMutex�Q�）函数可用来创��Z��个有名或无名的互斥量对象�Q�其函数原型为：

HANDLE CreateMutex(
　LPSECURITY_ATTRIBUTES lpMutexAttributes, // 指向安全属性的指针
　BOOL bInitialOwner, // 初始化互斥对象的所有�?br>　LPCTSTR lpName // 指向互斥对象名的指针
);

　　如果函数成功执行�Q�将�q�回一个互斥量对象的句柄。如果在CreateMutex�Q�）执行前已�l�存在有相同名字的互斥量�Q�函数将�q�回�q�个已经存在互斥量的句柄�Q��ƈ且可以通过GetLastError�Q�）得到错误代码ERROR_ALREADY_EXIST。可见，通过寚w��误代码ERROR_ALREADY_EXIST的检��可以实现CreateMutex�Q�）对进�E�的互斥�?br>       建立互斥体，用来同步。如果一个线�E?span class=t_tag onclick=tagshow(event) href="tag.php?name=%BB%F1%C8%A1">获取了互斥体�Q�则要获取该互斥体的�W�二个线�E�将被挂��P��直到�W�一个线�E�释放该互斥体�?

参数
lpMutexAttributes
指向一个SECURITY_ATTRIBUTES�l�构的指针，�q�个�l�构军_��互斥体句柄是否被子进�E?span class=t_tag onclick=tagshow(event) href="tag.php?name=%BC%CC%B3%D0">�l�承�?nbsp;
bInitialOwner
布尔�c�d��Q�决定互斥体的创��是否�ؓ拥有�?
lpName
指向互斥体名�?span class=t_tag onclick=tagshow(event) href="tag.php?name=%D7%D6%B7%FB">字符串的指针。互斥体可以有名字�?
互斥体的好处是可以在�q�程间共�?br>心得体会�Q?br> CreateMutex() 用于有独占要求的�E�序 (在其�q�程�q�行期间不允许其他��用此端口讑֤�的程序运行，或不允许同名�E�序�q�行)。如有同名程序运行，则通过 GetLastError�Q�）得到错误代码 ERROR_ALREADY_EXIST�?br>
刚才又执行了下得出的�l�果�Q�程序名samp�Q?br>    一般情况下�Q�一�q�入调试阶段�Q�进�E�管理器中就出现了samp�q�程�Q�执行到CreateMutex时返回进�E�句柄，执行到if(GetLastError() == ERROR_ALREADY_EXISTS ) �q�行判断�Ӟ��跌��不执行if中的内容�Q�所以表�C�没有互斥�?br>    调试之前先运行debug中的samp.exe再调试：一�q�入调试阶段�Q�进�E�管理器中就出现了两个samp�q�程�Q�执行到CreateMutex时返回进�E�句柄，执行到if(GetLastError() == ERROR_ALREADY_EXISTS ) �q�行判断�Ӟ��执行if中的内容�Q�表�C�有互斥�?/font>

Sandy 2008-12-26 18:46 发表评论

�? c++ notes

Sandy — Fri, 26 Dec 2008 01:15:00 GMT

http://www.shnenglu.com/mymsdn/archive/2008/12/25/cpp-notes-3.html
21、vector的动态增长优于预先分配内存�?/p>

使用vector的时候最好动态地��d��元素。它不同于C和Java或其他语�a�的数据类型，��Z��辑ֈ��q�箋性，更有效的�Ҏ��是先初始化一个空vector对象�Q�然后再动态添加元素，而不是预先分配内存�?/p>

22、vector值初始化

内置->0

有默认构�?>调用默认构�?/p>

无默认构造，有其他构�?>�E�序员手动提供初始�?/p>

无默认构造，也无其他构�?>标准库��生一个带初值的对象

23、数�l�下标的�c�d��

C++中，数组下标的正��类型是size_t而不是int�Q�size_t是一个与机器相关的unsigned�c�d��?/p>

24、在声明指针的时候，可以用空格将�W�号*与其后的标识�W�分隔开来，string *ps与string* ps都是可以的，但后者容易��生误解，如：

string* ps1,ps2; //ps1是指针，而ps2是一个string对象

也就是说�Q��h们可能误把string和string*当作两个�c�d��Q�或者说string*被当作一�U�新�c�d��来看待，但这是错�?/u>�Q?/p>

25、一个有效的指针必然是以下三�U�状态之一�Q?/p>

保存特定的对象的地址�Q?

指向某个对象后面的另一对象�Q?

或者是0倹{��表明它不指向�Q何对象�?/li>

其中int *pi=0;与int *pi;是不同的。前者是初始化指针指�?地址的对象（即�ؓNULL�Q�（pi initialized to address to no object�Q�，后者却是未初始化的�Q�ok, but dangerous, pi is uninitialized�Q��?/p>

�~�译器可以检��出0值的指针�Q�程序可判断该指针�ƈ未指向一个对象，而未初始化的指针的��用标准�ƈ未定义，对大多数�~�译器来��_��如果使用未初始化的指针会��指针中存放的不��定��D��为地址�Q�然后操�U�该内存地址中存攄��位内容，使用未初始化的指针相当于操纵�q�个不确定的地址中存储的基础数据�Q�因此对未初始化的指针进行解引用�Ӟ��通常会导致程序崩溃�?/p>

26、void*指针

void*指针只支持几�U�有限的操作�Q?/p>

与另一个指针进行比较；
向函��C��递void*指针或从函数�q�回void*指针�Q?
�l�另一个void*指针赋倹{�?/li>

不允�怋�用void*指针操纵它所指向的对象�?/p>

27、指针和引用的比较（P105�Q?/p>

虽然使用引用�Q�reference�Q�和指针都可间接讉K��另一个��|��但它们之间有两个重要区别。第一个区别在于引用��L��指向某个对象�Q�定义引用时没有初始化是错误的。第二个重要区别则是赋��D��为的差异�Q�给引用赋��g��改的是该引用所兌��的对象的��|��而�ƈ不是使引用与另一个对象关联。引用一�l�初始化�Q�就始终指向同一个特定对象（�q�就是�ؓ什么引用必��d��定义时初始化的原因）�?/p>

28、指针与typedef�Q�P112�Q?/p>

const攑֜��c�d��前和攑֜��c�d��后都可以表示同样的意思：

const string s1;
string const s2;

s1和s2均表�C�常量字�W�串对象�?/p>

但因此就��D��了下面的句子可能产生误解�Q?/p>

typedef string *pstring;
const pstring cstr;

�Ҏ��错把typedef当成文本扩展而��生下面的理解�Q?/p>

const string *cstr; //�q��ƈ非上面例子的正确意思！�Q�错误）

应该从声明的句子看，也就是说只看const pstring cstr;�Q�在�q�里pstring是一�U�指针类型，const修饰的是�q�个�c�d��Q�因此正��的理解应该是：

string *const cstr;

而const pstring cstr;其实可以表示为pstring const cstr;�Q�这��L��写法则不�Ҏ��产生误解。从叛_��左阅�ȝ��意思就是：cstr是const pstring�c�d��Q�即指向string对象的const指针�?/p>

29、创建动态数�l�（注意点见代码注释�Q?/p>

const char *cp1 = "some value";
char *cp2 = "other value";
int *piArray1 = new int[10];    //内置�c�d��没有初始�?
int *piArray2 = new int[10]();    //内置�c�d��需要加�I�圆括号�Q�对数组元素�q�行初始�?
std::string *psArray1 = new std::string[10];    //默认构造函数初始化
std::cout<<"----------"<"*cp1\t\t:"<<*cp1<"*cp2\t\t:"<<*cp2<"*piArray1\t:"<<*piArray1<"*piArray2\t:"<<*piArray2<"*psArray1\t:"<<*psArray1<"----------"<
但是下面的结果却与概念上的不同：
////Visual Studio & MS VC++
//----------
//*cp1            :s
//*cp2            :o
//*piArray1       :-842150451
//*piArray2       :0
//*psArray1       :
//----------
////Eclipse&G++
//----------
//*cp1        :s
//*cp2        :o
//*piArray1    :4064608
//*piArray2    :4064560
//*psArray1    :
//----------
看来不同的编译器�Ҏ��的定义还是有所不同�Q�注意看*piArray2的��|��按照说明应该是初始化�?�Q�但�q�里却仍然表现出�?piArray1一��L����|��说明�q�没有发生初始化�?/p>
对于动态分配的数组�Q�其元素只能初始化�ؓ元素�c�d��的默认��|��而不能像数组变量一��P��用初始化列表为数�l�元素提供各不相同的初倹{�?/p>
30、const对象的动态数�l?/p>
//P118
//error:uninitialized const array
const int *pciArray1 = new const int[10];
//ok:value-initialized const array
const int *pciArray2 = new const int[10]();
std::cout<<*pciArray1<
上面的示例的注释来自书中�Q�但在VC++�~�译器和G++�~�译器下却不同，具体表现为：

    VC++�Q�编译正���，�W�一句输出随机地址的��|���W�二句输出初始化�?�Q�其中按�?#8220;标准”�W�一�U�因为未向const变量初始化，应该无法通过�~�译�Q�但�q�里可以�Q?
    
G++�Q�编译错误，�W�一句的错误信息�?#8220;uninitialized const in `new' of `const int'”�Q�但�W�二句按照标准应该输�?的，�q�里却输��Z��随机地址的倹{�?/li>

看来两个�~�译器对�q�一问题的看法不太一致�?/p>


Sandy 2008-12-26 09:15 发表评论

�?使用FILE和LINE定位错误

Sandy — Thu, 25 Dec 2008 05:04:00 GMT

使用__FILE__和__LINE__定位错误
转自:http://www.shnenglu.com/heath/archive/2008/12/25/58046.html#70307

[前言�Q��用__FILE__和__LINE__来定位错误已�l�屡见不鲜，然而其中一些道理又有几个�h仔细探究�q�。本文参考了Curtis Krauskopf的一��名�?a target=_blank>Using __FILE__ and __LINE__ to Report Errors的文章，希望辑ֈ�解惑之效。]

问题�Q�当�q�行旉��误��生时�Q�我怎样才能得到包含C++文�g名和行号的字�W�串信息�Q?br>回答�Q�在C++中的__FILE__预编译指�C�器包含了被�~�译的文件名�Q�而__LINE__则包含了源代码的行号。__FILE__和__LINE__的前后都包含�?span style="COLOR: red">两个下划�U�，让我们仔�l�看看__FILE__所包含的每个字�W�：

_ _ F I L E _ _

下面展示了在控制台程序中如果昄��文�g名和代码行号�?br>

#include <stdio.h>

int main(int , char**)
{
printf("This fake error is in %s on line %d\n", __FILE__, __LINE__);
return 0;
}

输出�l�果�Q?br>
This fake error is in c:\temp\test.cpp on line 5

让我们更上一层楼

我想通过一个通用函数error()来报告错误，以��当某个错误发生时我能讄��断点以及隔离错误处理�Q�例如，在屏�q�上打印错误信息或者写入日志）。因此，函数的原型应该是�q�样的吧�Q?br>

void error(const char *file, const unsigned long line, const char *msg);

调用方式如下�Q?br>

error(__FILE__, __LINE__, "my error message");

预处理魔�?br>

�q�里有三个问题需要解冻I��

__FILE__和__LINE__在每�ơ调用error时作为参��C��入�?/span>
__FILE和__LINE__前后的下划线很容易被遗忘�Q�从而导致编译错误�?/span>
__LINE__是一个整敎ͼ��q�无疑增加了error函数的复杂度。我�l�不想直接��用整型的__LINE__�Q�而通常都是��{换�ؓ字符串打印到屏幕或写入日志文件�?br>

__FILE__和__LINE__应该被自动处理，而非每次作�ؓ参数传递给error�Q�这样会让error的��用者感觉更爽些�Q�它的�Ş式可能是下面�q�样�Q?br>

error(AT, "my error message");

我希望上面的宏AT展开为："c:\temp\test.cpp:5"。而新的error函数则变成：

void error(const char *location, const char *msg);

因�ؓBorland C++ Builder�~�译器能够自动合�q�相�ȝ��字符�Ԍ��因此我把AT写成下面�q�样�Q?br>

#define AT __FILE__ ":" __LINE__

然而它却�Ş工了�Q�因为__LINE__被扩展成了整数而非字符�Ԍ��所以宏展开后变成：

"c:\temp\test.cpp" ":" 5

�q�是一个无效的字符�Ԍ��因�ؓ末尾有一个未被双引号包含的整数�?

怎么办？别着急，一个特�D�的预编译指�C�器“#”能够帮我们将一个变量�{换成字符丌Ӏ�所以重新定义宏�Q?

#define AT __FILE__ ":" #__LINE__

嘿嘿�Q�这��h��行了吧。别高兴得太早，�q�样也是不行的。因为编译器会抱�?是个无效字符。其实，问题�?预编译指�C�器只有�q�样使用才会
被正���识别：

#define symbol(X) #X

因此�Q�我把代码改为：

#define STRINGIFY(x) #x
#define AT __FILE__ ":" STRINGIFY(__LINE__)

然而，奇怪的�l�果产生了，__LINE__居然被作��Z��输出的一部分�Q?br>
c:\temp\test.cpp:__LINE__: fake error

解决�Ҏ��是再用一个宏来包装STRINGIFY()�Q?br>

#define STRINGIFY(x) #x
#define TOSTRING(x) STRINGIFY(x)
#define AT __FILE__ ":" TOSTRING(__LINE__)

OK�Q�我们用下面的代码来试试�Q?br>

#include <stdio.h>
#define STRINGIFY(x) #x
#define TOSTRING(x) STRINGIFY(x)
#define AT __FILE__ ":" TOSTRING(__LINE__)
void error(const char *location, const char *msg)
{
  printf("Error at %s: %s\n", location, msg);
}
int main(int , char**)
{
  error(AT, "fake error");
  return 0;
}

输出�l�果�Q?br>
Error at c:\temp\test\test.cpp:11: fake error

Visual Studio下的实践
在《Windows核心�~�程》中�Q�Jeffrey Richter提供了下面的宏在�~�译期输出有用信息：

#define chSTR2(x) #x
#define chSTR(x) chSTR2(x)
#define chMSG(desc) message(__FILE__ "(" chSTR(__LINE__) "):" #desc)

message是一个预�~�译指��o�Q�上面宏的��用方法是�Q?br>

#pragma chMSG(Fix this later)

�l�论

预编译指�C�器__FILE__和__LINE__能够提供有用的信息�?/span>
__LINE__的处理方式远比我们想象的要复杂�?/span>
__FILE__被处理成字符�Ԍ��l�我们带来了不少方便�?

Sandy 2008-12-25 13:04 发表评论

�? fopen打开文�g方式

Sandy — Thu, 25 Dec 2008 04:59:00 GMT

fopen打开文�g方式

http://www.shnenglu.com/iuranus/archive/2008/12/25/70315.html

     最�q�写一个文件操作类�Q�fopen的参数着实让我搞了半天，因�ؓ以前��是固定的方式读写文件的�Q�现在要做灵�z�M��Q�所以就有些参数理解不够准确。以下是关于mode参数的定义�?br>
'r' 只读方式打开�Q�将文�g指针指向文�g��_��如果文�g不存在，则File�q�回�I��?br>'r+' ��d��方式打开�Q�将文�g指针指向文�g��_��如果文�g不存在，则File�q�回�I��?
'w' 写入方式打开�Q�将文�g指针指向文�g头�ƈ��文件大��截为零。如果文件不存在则尝试创��Z��?
'w+' ��d��方式打开�Q�将文�g指针指向文�g头�ƈ��文件大��截为零。如果文件不存在则尝试创��Z��?
'a' 写入方式打开�Q�将文�g指针指向文�g末尾。如果文件不存在则尝试创��Z��?
'a+' ��d��方式打开�Q�将文�g指针指向文�g末尾。如果文件不存在则尝试创��Z��?
'x' 创徏�q�以写入方式打开�Q�将文�g指针指向文�g头。如果文件已存在�Q�则 fopen() 调用��p�|�q�返�?FALSE�?
'x' 创徏�q�以写入方式打开�Q�将文�g指针指向文�g头。如果文件已存在�Q�则 fopen() 调用��p�|�q�返�?FALSE�?br>'b' 使用字符b作�ؓ文�g�c�d��的判断，是否是binary文�g�?br>
�q�有在读文�g时最好先判断下该文�g是否存在
bool ClassA::IsFileExisted(const char* filePath)
{
   struct stat info;
   if(stat(filePath, &info) != 0)
   {
      return false;
   }
   else
      return true;
}

Sandy 2008-12-25 12:59 发表评论

C++�c�d��转换�W�的使用

Sandy — Thu, 20 Nov 2008 05:30:00 GMT

C++的四个类型�{换运��符已经有很久了,但一直没有弄清楚它们的用�?今天看到一本书上的解释,才大致地的了解了其具体的用法.

具体归纳如下:

reinterpret_cast

该函数将一个类型的指针转换为另一个类型的指针.
�q�种转换不用修改指针变量值存放格�?不改变指针变量�?,只需在编译时重新解释指针的类型就可做�?
reinterpret_cast 可以��指针��D�{换�ؓ一个整型数,但不能用于非指针�c�d��的�{�?
�?
//基本�c�d��指针的类型�{�?br>double d=9.2;
double* pd = &d;
int *pi = reinterpret_cast(pd); //相当于int *pi = (int*)pd;

//不相关的�cȝ��指针的类型�{�?br>class A{};
class B{};
A* pa = new A;
B* pb = reinterpret_cast(pa); //相当于B* pb = (B*)pa;

//指针转换为整�?br>long l = reinterpret_cast(pi); //相当于long l = (long)pi;

const_cast

该函数用于去除指针变量的帔R��属性，��它转换��Z��个对应指针类型的普通变量。反�q�来�Q�也可以��一个非帔R��的指针变量�{换�ؓ一个常指针变量�?br>�q�种转换是在�~�译期间做出的类型更攏V�?br>例：
const int* pci = 0;
int* pk = const_cast(pci); //相当于int* pk = (int*)pci;

const A* pca = new A;
A* pa = const_cast(pca); //相当于A* pa = (A*)pca;

��Z��安全性考虑�Q�const_cast无法��非指针的常量�{换�ؓ普通变量�?/p>

static_cast

该函��C��要用于基本类型之间和��h��l�承关系的类型之间的转换�?br>�q�种转换一般会更改变量的内部表�C�方式，因此�Q�static_cast应用于指针类型�{换没有太大意义�?br>例：
//基本�c�d��转换
int i=0;
double d = static_cast(i); //相当�?double d = (double)i;

//转换�l�承�cȝ��对象为基�c�d��?br>class Base{};
class Derived : public Base{};
Derived d;
Base b = static_cast(d); //相当�?Base b = (Base)d;

dynamic_cast

它与static_cast相对�Q�是动态�{换�?br>�q�种转换是在�q�行时进行�{换分析的�Q��ƈ非在�~�译时进行，明显区别于上面三个类型�{换操作�?br>该函数只能在�l�承�c�d��象的指针之间或引用之间进行类型�{换。进行�{换时�Q�会�Ҏ��当前�q�行时类型信息，判断�c�d��对象之间的�{换是否合法。dynamic_cast的指针�{换失败，可通过是否为null��，引用转换��p�|则抛��Z��个bad_cast异常�?br>例：
class Base{};
class Derived : public Base{};

//�z��c�L��针�{换�ؓ基类指针
Derived *pd = new Derived;
Base *pb = dynamic_cast(pd);

if (!pb)
cout << "�c�d��转换��p�|" << endl;

//没有�l�承关系�Q�但被�{换类有虚函数
class A(virtual ~A();) //有虚函数
class B{}:
A* pa = new A;
B* pb = dynamic_cast(pa);

如果�Ҏ��l�承关系或者没有虚函数的对象指针进行�{换、基本类型指针�{换以及基�c�L��针�{换�ؓ�z��c�L��针，都不能通过�~�译�?/p>

Sandy 2008-11-20 13:30 发表评论

转：使应用程序只能运行一个实�?

Sandy — Sun, 02 Nov 2008 14:37:00 GMT

转自�Q?br>http://topic.csdn.net/t/20020917/11/1030014.html
使应用程序只能运行一个实�?

Windows是多�q�程操作�pȝ��Q�框架生成的应用�E�序可以多次�q�行�Q��Ş成多个运行实例�?
但在有些情况下�ؓ保证应用�E�序的安全运行，要求�E�序只能�q�行一个实例，比如�E?
序要使用只能被一个进�E�单独��用的�Ҏ��g�Q�例如调制解调器�Q�时�Q�必��限制程
序只�q�行一个实例�?

�q�里涉及两个基本的问题，一是在�E�序的第二个实例启动�Ӟ��如何发现该程序已�?
一个实例在�q�行�Q�而是如何��第一个实例激�z�，而第二个实例退出�?

对于�W�一个问题，可以通过�l�应用程序设�|�信号量�Q�实例启动时首先��该信号量，
如已存在�Q�则说明�E�序已运行一个实例�?

�W�二个问题的隄��是获取第一个实例的�ȝ��对象指针或句柄，然后便可�?
SetForegroundWindow来激�z�R��虽然FindWindow函数能寻找正�q�行着的窗口，但该�?
数要求指明所��L��H�口的标题或�H�口�c�d��Q�不是实现通用�Ҏ��的途径�?
我们可以用Win32 SDK函数SetProp来给应用�E�序�ȝ��讄��一个特有的标记�?
用GetDesktopWindow 可以获取Windows�pȝ��L��H�口对象指针或句柄，所有应用程
序主�H�都可看成该�H�口的子�H�口�Q�即可用GetWindow函数来获得它们的对象指针或句
柄。用Win32 SDK函数GetProp查找每一应用�E�序�ȝ��是否包含有我们设�|�的特定�?
��C��可确定它是否我们要寻扄��W�一个实例主�H�。�ɽW�二个实例退出很��单，只要
让其应用�E�序对象的InitInstance函数�q�回FALSE卛_��。此外，当主�H�口退出时�Q�应
用RemoveProp函数删除我们为其讄��的标记�?

下面的InitInstance、OnCreate和OnDestroy函数代码��实��C��q�的操作�Q?

BOOL CEllipseWndApp::InitInstance()
{
// 用应用程序名创徏信号�?
HANDLE hSem = CreateSemaphore(NULL, 1, 1, m_pszExeName);

// 信号量已存在�Q?
// 信号量存在，则程序已有一个实例运�?
if (GetLastError() == ERROR_ALREADY_EXISTS)
{
// 关闭信号量句�?
CloseHandle(hSem);
// ��L��先前实例的主�H�口
HWND hWndPrevious = ::GetWindow(::GetDesktopWindow(),GW_CHILD);
while (::IsWindow(hWndPrevious))
{
// ��查窗口是否有预设的标�?
// 有，则是我们��L��的主�H?
if (::GetProp(hWndPrevious, m_pszExeName))
{
// �ȝ��口已最��化�Q�则恢复其大��?
if (::IsIconic(hWndPrevious))
::ShowWindow(hWndPrevious,SW_RESTORE);

// ��主�H�激�z?
::SetForegroundWindow(hWndPrevious);

// ��主�H�的对话框激�z?
::SetForegroundWindow(
::GetLastActivePopup(hWndPrevious));

// 退出本实例
return FALSE;
}
// �l�箋��L��下一个窗�?
hWndPrevious = ::GetWindow(hWndPrevious,GW_HWNDNEXT);
}
// 前一实例已存在，但找不到其主�H?
// 可能出错�?
// 退出本实例
return FALSE;
}
AfxEnableControlContainer();
// Standard initialization
// If you are not using these features and wish to reduce the size
// of your final executable, you should remove from the following
// the specific initialization routines you do not need.
#ifdef _AFXDLL
Enable3dControls(); // Call this when using MFC in a shared DLL
#else
Enable3dControlsStatic();// Call this when linking to MFC statically
#endif

CEllipseWndDlg dlg;
m_pMainWnd = &dlg;
int nResponse = dlg.DoModal();
if (nResponse == IDOK)
{
// TODO: Place code here to handle when the dialog is
// dismissed with OK
}
else if (nResponse == IDCANCEL)
{
// TODO: Place code here to handle when the dialog is
// dismissed with Cancel
}
// Since the dialog has been closed, return FALSE so that we exit the
// application, rather than start the application's message pump.
return FALSE;
}

int CEllipseWndDlg::OnCreate(LPCREATESTRUCT lpCreateStruct)
{
if (CDialog::OnCreate(lpCreateStruct) == -1)
return -1;
// 讄��L��标记
::SetProp(m_hWnd, AfxGetApp()->m_pszExeName, (HANDLE)1);
return 0;
}

void CEllipseWndDlg::OnDestroy()
{
CDialog::OnDestroy();
// 删除��L��标记
::RemoveProp(m_hWnd, AfxGetApp()->m_pszExeName);
}

对以上代码的补充�Q?
查看代码和VC的帮助后�Q�发现问题在于原文在创徏信号量和讄��L��标记时��?
的是 CWinApp 的成员变�? m_pszExeName�Q�该成员变量其实是应用程序执行文件的�?
�U�去掉扩展名后的部分�Q�而不是应用程序名�?

真正的应用程序名应�ؓ成员变量 m_pszAppName,
于是��用到m_pszExeName的三处代码均改�ؓm_pszAppName�Q�重新编译执行，情况消失�?

最后再提供一个方法和一个信息：

另一�U��应用�E�序只能�q�行一个实例的�Ҏ��Q�只需在InitInstance()的最开始添
加下列语句即可：
HANDLE m_hMutex=CreateMutex(NULL,TRUE, m_pszAppName);
if(GetLastError()==ERROR_ALREADY_EXISTS) { return FALSE; }

但这�U�方法的不��之处是不能将已经启动的实例激�z�R�?

在stingray公司整理开发的MFCFAQ软�g中也提供了一些方法。该软�g实际是一�?
MFC使用技巧的大汇集，对��用MFC极有帮助�Q�各位朋友不妨去stingray公司的主��下
载�?nbsp;

Sandy 2008-11-02 22:37 发表评论

转：深入��出Win32多线�E�设计之MFC的多�U�程(作者：宋宝�?

Sandy — Sun, 02 Nov 2008 14:36:00 GMT

转自�Q?a >http://blog.ednchina.com/hotpower/174823/message.aspx

标签�Q?无标�{?/p>

深入��出Win32多线�E�设计之MFC的多�U�程(作者：宋宝�?

1、创建和�l�止�U�程

　　在MFC�E�序中创��Z��个线�E�，宜调用AfxBeginThread函数。该函数因参��C��同而具有两�U�重载版本，分别对应工作者线�E�和用户接口�Q�UI�Q�线�E��?br>
　　工作者线�E?br>

CWinThread *AfxBeginThread(
　AFX_THREADPROC pfnThreadProc, //控制函数
　LPVOID pParam, //传递给控制函数的参�?br>　int nPriority = THREAD_PRIORITY_NORMAL, //�U�程的优先��
　UINT nStackSize = 0, //�U�程的堆栈大��?br>　DWORD dwCreateFlags = 0, //�U�程的创建标�?br>　LPSECURITY_ATTRIBUTES lpSecurityAttrs = NULL //�U�程�?a class=bluekey target=_blank>安全属�?br>);

　　工作者线�E�编�E�较为简单，只需�~�写�U�程控制函数和启动线�E�即可。下面的代码�l�出了定义一个控制函数和启动它的�q�程�Q?br>

//�U�程控制函数
UINT MfcThreadProc(LPVOID lpParam)
{
　CExampleClass *lpObject = (CExampleClass*)lpParam;
　if (lpObject == NULL || !lpObject->IsKindof(RUNTIME_CLASS(CExampleClass)))
　　return - 1; //输入参数非法
　//�U�程成功启动
　while (1)
　
　return 0;
}

//在MFC�E�序中启动线�E?br>AfxBeginThread(MfcThreadProc, lpObject);

　　UI�U�程

　　创徏用户界面�U�程�Ӟ��必须首先从CWinThread �z��c�，�q��?DECLARE_DYNCREATE �?IMPLEMENT_DYNCREATE 宏声明此�c�R�?br>
　　下面�l�出了CWinThread�cȝ��原型�Q�添加了关于光��要函数功能和是否需要被�l�承�c�重载的注释�Q�：

class CWinThread : public CCmdTarget
{
　DECLARE_DYNAMIC(CWinThread)

　public:
　　// Constructors
　　CWinThread();
　　BOOL CreateThread(DWORD dwCreateFlags = 0, UINT nStackSize = 0,
LPSECURITY_ATTRIBUTES lpSecurityAttrs = NULL);

　　// Attributes
　　CWnd* m_pMainWnd; // main window (usually same AfxGetApp()->m_pMainWnd)
　　CWnd* m_pActiveWnd; // active main window (may not be m_pMainWnd)
　　BOOL m_bAutoDelete; // enables 'delete this' after thread termination

　　// only valid while running
　　HANDLE m_hThread; // this thread's HANDLE
　　operator HANDLE() const;
　　DWORD m_nThreadID; // this thread's ID

　　int GetThreadPriority();
　　BOOL SetThreadPriority(int nPriority);

　　// Operations
　　DWORD SuspendThread();
　　DWORD ResumeThread();
　　BOOL PostThreadMessage(UINT message, WPARAM wParam, LPARAM lParam);

　　// Overridables
　　//执行�U�程实例初始化，必须重写
　　virtual BOOL InitInstance();

　　// running and idle processing
　　//控制�U�程的函敎ͼ�包含消息泵，一般不重写
　　virtual int Run();

　　//消息调度到TranslateMessage和DispatchMessage之前对其�q�行�{�选，
　　//通常不重�?br>　　virtual BOOL PreTranslateMessage(MSG* pMsg);

　　virtual BOOL PumpMessage(); // low level message pump

　　//执行�U�程特定的闲�|�时间处理，通常不重�?br>　　virtual BOOL OnIdle(LONG lCount); // return TRUE if more idle processing
　　virtual BOOL IsIdleMessage(MSG* pMsg); // checks for special messages

　　//�U�程�l�止时执行清除，通常需要重�?br>　　virtual int ExitInstance(); // default will 'delete this'

　　//截获��q��E�的消息和命令处理程序引发的未处理异常，通常不重�?br>　　virtual LRESULT ProcessWndProcException(CException* e, const MSG* pMsg);

　　// Advanced: handling messages sent to message filter hook
　　virtual BOOL ProcessMessageFilter(int code, LPMSG lpMsg);

　　// Advanced: virtual access to m_pMainWnd
　　virtual CWnd* GetMainWnd();

　　// Implementation
　public:
　　virtual ~CWinThread();
　　#ifdef _DEBUG
　　　virtual void AssertValid() const;
　　　virtual void Dump(CDumpContext& dc) const;
　　　int m_nDisablePumpCount; // Diagnostic trap to detect illegal re-entrancy
　　#endif
　　void CommonConstruct();
　　virtual void Delete();
　　// 'delete this' only if m_bAutoDelete == TRUE

　　// message pump for Run
　　MSG m_msgCur; // current message

　public:
　　// constructor used by implementation of AfxBeginThread
　　CWinThread(AFX_THREADPROC pfnThreadProc, LPVOID pParam);

　　// valid after construction
　　LPVOID m_pThreadParams; // generic parameters passed to starting function
　　AFX_THREADPROC m_pfnThreadProc;

　　// set after OLE is initialized
　　void (AFXAPI* m_lpfnOleTermOrFreeLib)(BOOL, BOOL);
　　COleMessageFilter* m_pMessageFilter;

　protected:
　　CPoint m_ptCursorLast; // last mouse position
　　UINT m_nMsgLast; // last mouse message
　　BOOL DispatchThreadMessageEx(MSG* msg); // helper
　　void DispatchThreadMessage(MSG* msg); // obsolete
};

　　启动UI�U�程的AfxBeginThread函数的原型�ؓ�Q?br>

CWinThread *AfxBeginThread(
　//从CWinThread�z��的类�?RUNTIME_CLASS
　CRuntimeClass *pThreadClass,
　int nPriority = THREAD_PRIORITY_NORMAL,
　UINT nStackSize = 0,
　DWORD dwCreateFlags = 0,
　LPSECURITY_ATTRIBUTES lpSecurityAttrs = NULL
);

　　我们可以方便��C��用VC++ 6.0�c�d��导定义一个��承自CWinThread的用��L��E�类。下面给��Z�生我们自定义的CWinThread子类CMyUIThread的方法�?br>
　　打开VC++ 6.0�c�d��|��在如下窗口中选择Base Class�c�MؓCWinThread�Q�输入子�c�d��为CMyUIThread�Q�点�?OK"按钮后就产生了类CMyUIThread�?br>

　　其源代码框架为：

/////////////////////////////////////////////////////////////////////////////
// CMyUIThread thread

class CMyUIThread : public CWinThread
{
　DECLARE_DYNCREATE(CMyUIThread)
　protected:
　　CMyUIThread(); // protected constructor used by dynamic creation

　　// Attributes
　public:

　　// Operations
　public:

　　// Overrides
　　// ClassWizard generated virtual function overrides
　　//{{AFX_VIRTUAL(CMyUIThread)
　　public:
　　　virtual BOOL InitInstance();
　　　virtual int ExitInstance();
　　//}}AFX_VIRTUAL

　　// Implementation
　protected:
　　virtual ~CMyUIThread();

　　// Generated message map functions
　　//{{AFX_MSG(CMyUIThread)
　　　// NOTE - the ClassWizard will add and remove member functions here.
　　//}}AFX_MSG

　DECLARE_MESSAGE_MAP()
};

/////////////////////////////////////////////////////////////////////////////
// CMyUIThread

IMPLEMENT_DYNCREATE(CMyUIThread, CWinThread)

CMyUIThread::CMyUIThread()
{}

CMyUIThread::~CMyUIThread()
{}

BOOL CMyUIThread::InitInstance()
{
　// TODO: perform and per-thread initialization here
　return TRUE;
}

int CMyUIThread::ExitInstance()
{
　// TODO: perform any per-thread cleanup here
　return CWinThread::ExitInstance();
}

BEGIN_MESSAGE_MAP(CMyUIThread, CWinThread)
//{{AFX_MSG_MAP(CMyUIThread)
// NOTE - the ClassWizard will add and remove mapping macros here.
//}}AFX_MSG_MAP
END_MESSAGE_MAP()

　　使用下列代码��可以启动这个UI�U�程�Q?br>

CMyUIThread *pThread;
pThread = (CMyUIThread*)
AfxBeginThread( RUNTIME_CLASS(CMyUIThread) );

　　另外�Q�我们也可以不用AfxBeginThread 创徏�U�程�Q�而是分如下两步完成：

　　�Q?�Q�调用线�E�类的构造函数创��Z��个线�E�对象；

　　�Q?�Q�调用CWinThread::CreateThread函数来启动该�U�程�?br>
　　在线�E�自�w�内调用AfxEndThread函数可以�l�止该线�E�：

void AfxEndThread(
　UINT nExitCode //the exit code of the thread
);

　　对于UI�U�程而言�Q�如果消息队列中攑օ�了WM_QUIT消息�Q�将�l�束�U�程�?br>
　　关于UI�U�程和工作者线�E�的分配�Q�最好的做法是：��所有与UI相关的操作放入主�U�程�Q�其它的�U��a的运��工作交�l�独立的��C��工作者线�E��?br>
　　候捷先生早些旉��喜欢为MDI�E�序的每个窗口创��Z��个线�E�，他后来澄清了�q�个错误。因为如果�ؓMDI�E�序的每个窗口都单独创徏一个线�E�，在窗口进行切换的时候，��进行线�E�的上下文切换！

2.�U�程间通信

　　MFC中定义了�l�承自CSyncObject�cȝ��CCriticalSection 、CCEvent、CMutex、CSemaphore�c�d��装和��化了WIN32 API所提供的��界区、事件、互斥和信号量。��用这些同步机�Ӟ��必须包含"Afxmt.h"头文件。下囄��Z��cȝ��l�承关系�Q?br>

　　作�ؓCSyncObject�cȝ��l�承�c�，我们仅仅使用基类CSyncObject的接口函数就可以方便、统一的操作CCriticalSection 、CCEvent、CMutex、CSemaphore�c�，下面是CSyncObject�cȝ��原型�Q?br>

class CSyncObject : public CObject
{
　DECLARE_DYNAMIC(CSyncObject)

　// Constructor
　public:
　　CSyncObject(LPCTSTR pstrName);

　　// Attributes
　public:
　　operator HANDLE() const;
　　HANDLE m_hObject;

　　// Operations
　　virtual BOOL Lock(DWORD dwTimeout = INFINITE);
　　virtual BOOL Unlock() = 0;
　　virtual BOOL Unlock(LONG /* lCount */, LPLONG /* lpPrevCount="NULL" */)
　　{ return TRUE; }

　　// Implementation
　public:
　　virtual ~CSyncObject();
　　#ifdef _DEBUG
　　　CString m_strName;
　　　virtual void AssertValid() const;
　　　virtual void Dump(CDumpContext& dc) const;
　　#endif
　　friend class CSingleLock;
　　friend class CMultiLock;
};

　　CSyncObject�c�L��主要的两个函数是Lock和Unlock�Q�若我们直接使用CSyncObject�c�d��其派生类�Q�我们需要非常小心地在Lock之后调用Unlock�?br>
　　MFC提供的另两个�c�CSingleLock�Q�等待一个对象）和CMultiLock�Q�等待多个对象）为我们编写应用程序提供了更灵�zȝ��机制�Q�下面以实际来阐�q�CSingleLock的用法：

class CThreadSafeWnd

　　~CThreadSafeWnd(){}
　　void SetWindow(CWnd *pwnd)
　　{
　　　m_pCWnd = pwnd;
　　}
　　void PaintBall(COLORREF color, CRect &rc);
　private:
　　CWnd *m_pCWnd;
　　CCriticalSection m_CSect;
};

void CThreadSafeWnd::PaintBall(COLORREF color, CRect &rc)
{
　CSingleLock csl(&m_CSect);
　//�~�省的Timeout是INFINITE�Q�只有m_Csect被激�z�，csl.Lock()才能�q�回
　//true�Q�这里一直等�?br>　if (csl.Lock())
;
　{
　　// not necessary
　　//AFX_MANAGE_STATE(AfxGetStaticModuleState( ));
　　CDC *pdc = m_pCWnd->GetDC();
　　CBrush brush(color);
　　CBrush *oldbrush = pdc->SelectObject(&brush);
　　pdc->Ellipse(rc);
　　pdc->SelectObject(oldbrush);
　　GdiFlush(); // don't wait to update the display
　}
}

　　上述实例讲述了用CSingleLock对Windows GDI相关对象�q�行保护的方法，下面再给��Z��个其他方面的例子�Q?br>

int array1[10], array2[10];
CMutexSection section; //创徏一个CMutex�cȝ��对象

//赋值线�E�控制函�?br>UINT EvaluateThread(LPVOID param)
{
　CSingleLock singlelock;
　singlelock(§ion);

　//互斥区域
　singlelock.Lock();
　for (int i = 0; i < 10; i++)
　　array1[i] = i;
　singlelock.Unlock();
}
//拯��U�程控制函数
UINT CopyThread(LPVOID param)
{
　CSingleLock singlelock;
　singlelock(§ion);

　//互斥区域
　singlelock.Lock();
　for (int i = 0; i < 10; i++)
　　array2[i] = array1[i];
　singlelock.Unlock();
}
}

AfxBeginThread(EvaluateThread, NULL); //启动赋值线�E?br>AfxBeginThread(CopyThread, NULL); //启动拯��U�程

　　上面的例子中启动了两个线�E�EvaluateThread和CopyThread�Q�线�E�EvaluateThread�?0个数赋值给数组array1[]�Q�线�E�CopyThread��数�l�array1[]拯��l�数�l�array2[]。由于数�l�的拯��和赋值都是整体行为，如果不以互斥形式执行代码�D�：

for (int i = 0; i < 10; i++)
array1[i] = i;

　　�?br>

for (int i = 0; i < 10; i++)
array2[i] = array1[i];

　　其结果是很难预料的！

　　除了可��用CCriticalSection、CEvent、CMutex、CSemaphore作�ؓ�U�程间同步通信的方式以外，我们�q�可以利用PostThreadMessage函数在线�E�间发送消息：

BOOL PostThreadMessage(DWORD idThread, // thread identifier
UINT Msg, // message to post
WPARAM wParam, // first message parameter
LPARAM lParam // second message parameter

3.�U�程与消息队�?br>
　　在WIN32中，每一个线�E�都对应着一个消息队列。由于一个线�E�可以��生数个窗口，所以�ƈ不是每个�H�口都对应着一个消息队列。下列几句话应该作�ؓ"定理"被记住：

　　"定理" 一

　　所有��生给某个�H�口的消息，都先由创��个窗口的�U�程处理�Q?br>
　　"定理" �?br>
　　Windows屏幕上的每一个控仉��是一个窗口，有对应的�H�口函数�?br>
　　消息的发送通常有两�U�方式，一是SendMessage�Q�一是PostMessage�Q�其原型分别为：

LRESULT SendMessage(HWND hWnd, // handle of destination window
　UINT Msg, // message to send
　WPARAM wParam, // first message parameter
　LPARAM lParam // second message parameter
);
BOOL PostMessage(HWND hWnd, // handle of destination window
　UINT Msg, // message to post
　WPARAM wParam, // first message parameter
　LPARAM lParam // second message parameter
);

　　两个函数原型中的四个参数的意义相同，但是SendMessage和PostMessage的行为有差异。SendMessage必须�{�待消息被处理后才返回，而PostMessage仅仅��消息放入消息队列。SendMessage的目标窗口如果属于另一个线�E�，则会发生�U�程上下文切换，�{�待另一�U�程处理完成消息。�ؓ了防止另一�U�程当掉�Q�导致SendMessage永远不能�q�回�Q�我们可以调用SendMessageTimeout函数�Q?br>

LRESULT SendMessageTimeout(
　HWND hWnd, // handle of destination window
　UINT Msg, // message to send
　WPARAM wParam, // first message parameter
　LPARAM lParam, // second message parameter
　UINT fuFlags, // how to send the message
　UINT uTimeout, // time-out duration
　LPDWORD lpdwResult // return value for synchronous call
);

　　4. MFC�U�程、消息队列与MFC�E�序�?生死因果"

　　分析MFC�E�序的主�U�程启动及消息队列处理的�q�程��有助于我们�q�一步理解UI�U�程与消息队列的关系�Q��ؓ此我们需要简单地叙述一下MFC�E�序�?生死因果"�Q�侯��P��《深入浅出MFC》）�?br>
　　使用VC++ 6.0的向导完成一个最��单的单文档架构MFC应用�E�序MFCThread�Q?br>
　　�Q?�Q?输入MFC EXE工程名MFCThread�Q?br>
　　�Q?�Q?选择单文档架构，不支持Document/View�l�构�Q?br>
　　�Q?�Q?ActiveX�?D container�{�其他选项都选择无�?br>
　　我们来分析这个工�E�。下面是产生的核心源代码�Q?br>
　　MFCThread.h 文�g

class CMFCThreadApp : public CWinApp
{
　public:
　　CMFCThreadApp();

　　// Overrides
　　// ClassWizard generated virtual function overrides
　　//{{AFX_VIRTUAL(CMFCThreadApp)
　　　public:
　　　　virtual BOOL InitInstance();
　　//}}AFX_VIRTUAL

　　// Implementation

　public:
　　//{{AFX_MSG(CMFCThreadApp)
　　　afx_msg void OnAppAbout();
　　　// NOTE - the ClassWizard will add and remove member functions here.
　　　// DO NOT EDIT what you see in these blocks of generated code !
　　//}}AFX_MSG
　DECLARE_MESSAGE_MAP()
};

　　MFCThread.cpp文�g

CMFCThreadApp theApp;

/////////////////////////////////////////////////////////////////////////////
// CMFCThreadApp initialization

BOOL CMFCThreadApp::InitInstance()
{
　…
　CMainFrame* pFrame = new CMainFrame;
　m_pMainWnd = pFrame;

　// create and load the frame with its resources
　pFrame->LoadFrame(IDR_MAINFRAME,WS_OVERLAPPEDWINDOW | FWS_ADDTOTITLE, NULL,NULL);
　// The one and only window has been initialized, so show and update it.
　pFrame->ShowWindow(SW_SHOW);
　pFrame->UpdateWindow();

　return TRUE;
}

　　MainFrm.h文�g

#include "ChildView.h"

class CMainFrame : public CFrameWnd
{
　public:
　　CMainFrame();
　protected:
　　DECLARE_DYNAMIC(CMainFrame)

　　// Attributes
　public:

　　// Operations
　public:
　　// Overrides
　　// ClassWizard generated virtual function overrides
　　//{{AFX_VIRTUAL(CMainFrame)
　　　virtual BOOL PreCreateWindow(CREATESTRUCT& cs);
　　　virtual BOOL OnCmdMsg(UINT nID, int nCode, void* pExtra, AFX_CMDHANDLERINFO* pHandlerInfo);
　　//}}AFX_VIRTUAL

　　// Implementation
　public:
　　virtual ~CMainFrame();
　　#ifdef _DEBUG
　　　virtual void AssertValid() const;
　　　virtual void Dump(CDumpContext& dc) const;
　　#endif
　　CChildView m_wndView;

　　// Generated message map functions
　protected:
　//{{AFX_MSG(CMainFrame)
　　afx_msg void OnSetFocus(CWnd *pOldWnd);
　　// NOTE - the ClassWizard will add and remove member functions here.
　　// DO NOT EDIT what you see in these blocks of generated code!
　//}}AFX_MSG
　DECLARE_MESSAGE_MAP()
};

　　MainFrm.cpp文�g

IMPLEMENT_DYNAMIC(CMainFrame, CFrameWnd)

BEGIN_MESSAGE_MAP(CMainFrame, CFrameWnd)
　//{{AFX_MSG_MAP(CMainFrame)
　　// NOTE - the ClassWizard will add and remove mapping macros here.
　　// DO NOT EDIT what you see in these blocks of generated code !
　　ON_WM_SETFOCUS()
　//}}AFX_MSG_MAP
END_MESSAGE_MAP()

/////////////////////////////////////////////////////////////////////////////
// CMainFrame construction/destruction

CMainFrame::CMainFrame()
{
　// TODO: add member initialization code here
}

CMainFrame::~CMainFrame()
{}

BOOL CMainFrame::PreCreateWindow(CREATESTRUCT& cs)
{
　if( !CFrameWnd::PreCreateWindow(cs) )
　　return FALSE;
　　// TODO: Modify the Window class or styles here by modifying
　　// the CREATESTRUCT cs

　cs.dwExStyle &= ~WS_EX_CLIENTEDGE;
　cs.lpszClass = AfxRegisterWndClass(0);
　return TRUE;
}

　　ChildView.h文�g

// CChildView window

class CChildView : public CWnd
{
　// Construction
　public:
　　CChildView();

　　// Attributes
　public:
　　// Operations
　public:
　　// Overrides
　　// ClassWizard generated virtual function overrides
　　//{{AFX_VIRTUAL(CChildView)
　　　protected:
　　　　virtual BOOL PreCreateWindow(CREATESTRUCT& cs);
　　//}}AFX_VIRTUAL

　　// Implementation
　public:
　　virtual ~CChildView();

　　// Generated message map functions
　protected:
　　//{{AFX_MSG(CChildView)
　　　afx_msg void OnPaint();
　　//}}AFX_MSG
　DECLARE_MESSAGE_MAP()
};

ChildView.cpp文�g
// CChildView

CChildView::CChildView()
{}

CChildView::~CChildView()
{}

BEGIN_MESSAGE_MAP(CChildView,CWnd )
//}AFX_MSG_MAP
END_MESSAGE_MAP()

/////////////////////////////////////////////////////////////////////////////
// CChildView message handlers

BOOL CChildView::PreCreateWindow(CREATESTRUCT& cs)
{
　if (!CWnd::PreCreateWindow(cs))
　　return FALSE;

　cs.dwExStyle |= WS_EX_CLIENTEDGE;
　cs.style &= ~WS_BORDER;
　cs.lpszClass = AfxRegisterWndClass(CS_HREDRAW|CS_VREDRAW|CS_DBLCLKS,::LoadCursor(NULL, IDC_ARROW),
HBRUSH(COLOR_WINDOW+1),NULL);

　return TRUE;
}

void CChildView::OnPaint()
{
　CPaintDC dc(this); // device context for painting

　// TODO: Add your message handler code here
　// Do not call CWnd::OnPaint() for painting messages
}

　　文�gMFCThread.h和MFCThread.cpp定义和实现的�c�CMFCThreadApp�l�承自CWinApp�c�，而CWinApp�c�d��l�承自CWinThread�c�（CWinThread�c�d��l�承自CCmdTarget�c�）�Q�所以CMFCThread本质上是一个MFC�U�程�c�，下图�l�出了相关的�c�d��ơ结构：

我们提取CWinApp�c�d��型的一部分�Q?br>

class CWinApp : public CWinThread
{
　DECLARE_DYNAMIC(CWinApp)
　public:
　　// Constructor
　　CWinApp(LPCTSTR lpszAppName = NULL);// default app name
　　// Attributes
　　// Startup args (do not change)
　　HINSTANCE m_hInstance;
　　HINSTANCE m_hPrevInstance;
　　LPTSTR m_lpCmdLine;
　　int m_nCmdShow;
　　// Running args (can be changed in InitInstance)
　　LPCTSTR m_pszAppName; // human readable name
　　LPCTSTR m_pszExeName; // executable name (no spaces)
　　LPCTSTR m_pszHelpFilePath; // default based on module path
　　LPCTSTR m_pszProfileName; // default based on app name

　　// Overridables
　　virtual BOOL InitApplication();
　　virtual BOOL InitInstance();
　　virtual int ExitInstance(); // return app exit code
　　virtual int Run();
　　virtual BOOL OnIdle(LONG lCount); // return TRUE if more idle processing
　　virtual LRESULT ProcessWndProcException(CException* e,const MSG* pMsg);

　public:
　　virtual ~CWinApp();
　protected:
　　DECLARE_MESSAGE_MAP()
};

　　SDK�E�序的WinMain 所完成的工作现在由CWinApp 的三个函数完成：

virtual BOOL InitApplication();
virtual BOOL InitInstance();
virtual int Run();

　　"CMFCThreadApp theApp;"语句定义的全局变量theApp是整个程式的application object�Q�每一个MFC 应用�E�序都有一个。当我们执行MFCThread�E�序的时候，�q�个全局变量被构造。theApp 配置完成后，WinMain开始执行。但是程序中�q�没有WinMain的代码，它在哪里呢？原来MFC早已准备好�ƈ由Linker直接加到应用�E�序代码中的�Q�其原型为（存在于VC++6.0安装目录下提供的APPMODUL.CPP文�g中）�Q?br>

extern "C" int WINAPI
_tWinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance,
LPTSTR lpCmdLine, int nCmdShow)
{
　// call shared/exported WinMain
　return AfxWinMain(hInstance, hPrevInstance, lpCmdLine, nCmdShow);
}

　　其中调用的AfxWinMain如下�Q�存在于VC++6.0安装目录下提供的WINMAIN.CPP文�g中）�Q?br>

int AFXAPI AfxWinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance,
LPTSTR lpCmdLine, int nCmdShow)
{
　ASSERT(hPrevInstance == NULL);

　int nReturnCode = -1;
　CWinThread* pThread = AfxGetThread();
　CWinApp* pApp = AfxGetApp();

　// AFX internal initialization
　if (!AfxWinInit(hInstance, hPrevInstance, lpCmdLine, nCmdShow))
　　goto InitFailure;

　// App global initializations (rare)
　if (pApp != NULL && !pApp->InitApplication())
　　goto InitFailure;

　// Perform specific initializations
　if (!pThread->InitInstance())
　{
　　if (pThread->m_pMainWnd != NULL)
　　{
　　　TRACE0("Warning: Destroying non-NULL m_pMainWndn");
　　　pThread->m_pMainWnd->DestroyWindow();
　　}
　　nReturnCode = pThread->ExitInstance();
　　goto InitFailure;
　}
　nReturnCode = pThread->Run();

　InitFailure:
　#ifdef _DEBUG
　　// Check for missing AfxLockTempMap calls
　　if (AfxGetModuleThreadState()->m_nTempMapLock != 0)
　　{
　　　TRACE1("Warning: Temp map lock count non-zero (%ld).n",
AfxGetModuleThreadState()->m_nTempMapLock);
　　}
　　AfxLockTempMaps();
　　AfxUnlockTempMaps(-1);
　#endif

　AfxWinTerm();
　return nReturnCode;
}

　　我们提取��d��Q�实际上�Q�这个函数做的事情主要是�Q?br>

CWinThread* pThread = AfxGetThread();
CWinApp* pApp = AfxGetApp();
AfxWinInit(hInstance, hPrevInstance, lpCmdLine, nCmdShow)
pApp->InitApplication()
pThread->InitInstance()
pThread->Run();

　　其中�Q�InitApplication 是注册窗口类别的场所�Q�InitInstance是��生窗口�ƈ昄��H�口的场所�Q�Run是提取�ƈ分派消息的场所。这��P��MFC��同WIN32 SDK�E�序对应��h��了。CWinThread::Run是程序生命的"�z�L��源头"�Q�侯��P��《深入浅出MFC》，函数存在于VC++ 6.0安装目录下提供的THRDCORE.CPP文�g中）�Q?br>

// main running routine until thread exits
int CWinThread::Run()
{
　ASSERT_VALID(this);

　// for tracking the idle time state
　BOOL bIdle = TRUE;
　LONG lIdleCount = 0;

　// acquire and dispatch messages until a WM_QUIT message is received.
　for (;;)
　{
　　// phase1: check to see if we can do idle work
　　while (bIdle && !::PeekMessage(&m_msgCur, NULL, NULL, NULL, PM_NOREMOVE))
　　{
　　　// call OnIdle while in bIdle state
　　　if (!OnIdle(lIdleCount++))
　　　　bIdle = FALSE; // assume "no idle" state
　　}

　　// phase2: pump messages while available
　　do
　　{
　　　// pump message, but quit on WM_QUIT
　　　if (!PumpMessage())
　　　　return ExitInstance();

　　　// reset "no idle" state after pumping "normal" message
　　　if (IsIdleMessage(&m_msgCur))
　　　{
　　　　bIdle = TRUE;
　　　　lIdleCount = 0;
　　　}

　　} while (::PeekMessage(&m_msgCur, NULL, NULL, NULL, PM_NOREMOVE));
　}
　ASSERT(FALSE); // not reachable
}

　　其中的PumpMessage函数又对应于�Q?br>

/////////////////////////////////////////////////////////////////////////////
// CWinThread implementation helpers

BOOL CWinThread::PumpMessage()
{
　ASSERT_VALID(this);

　if (!::GetMessage(&m_msgCur, NULL, NULL, NULL))
　{
　　return FALSE;
　}

　// process this message
　if(m_msgCur.message != WM_KICKIDLE && !PreTranslateMessage(&m_msgCur))
　
　return TRUE;
}

　　因此�Q�忽略IDLE状态，整个RUN的执行提取主�q�就是：

do while (::PeekMessage(...));

　　由此�Q�我们徏立了MFC消息获取和派生机制与WIN32 SDK�E�序之间的对应关�p�R��下面��l�分析MFC消息�?�l�行"�q�程�?br>
　　在MFC中，只要是CWnd 衍生�c�d��Q�就可以拦下��M��Windows消息。与�H�口无关的MFC�c�d��Q�例如CDocument 和CWinApp�Q�如果也惛_��理消息，必须衍生自CCmdTarget�Q��ƈ且只可能收到WM_COMMAND消息。所有能�q�行MESSAGE_MAP的类都��承自CCmdTarget�Q�如�Q?br>

　　MFC中MESSAGE_MAP的定义依赖于以下三个宏：

DECLARE_MESSAGE_MAP()

BEGIN_MESSAGE_MAP(
　theClass, //Specifies the name of the class whose message map this is
　baseClass //Specifies the name of the base class of theClass
)

END_MESSAGE_MAP()

　　我们�E�序中涉及到的有�Q�MFCThread.h、MainFrm.h、ChildView.h文�g

DECLARE_MESSAGE_MAP()
MFCThread.cpp文�g
BEGIN_MESSAGE_MAP(CMFCThreadApp, CWinApp)
//{{AFX_MSG_MAP(CMFCThreadApp)
ON_COMMAND(ID_APP_ABOUT, OnAppAbout)
// NOTE - the ClassWizard will add and remove mapping macros here.
// DO NOT EDIT what you see in these blocks of generated code!
//}}AFX_MSG_MAP
END_MESSAGE_MAP()
MainFrm.cpp文�g
BEGIN_MESSAGE_MAP(CMainFrame, CFrameWnd)
//{{AFX_MSG_MAP(CMainFrame)
// NOTE - the ClassWizard will add and remove mapping macros here.
// DO NOT EDIT what you see in these blocks of generated code !
ON_WM_SETFOCUS()
//}}AFX_MSG_MAP
END_MESSAGE_MAP()
ChildView.cpp文�g
BEGIN_MESSAGE_MAP(CChildView,CWnd )
//}AFX_MSG_MAP
END_MESSAGE_MAP()

　　��p��些宏�Q�MFC建立了一个消息映��表�Q�消息流动网�Q�，按照消息��动�|�匹配对应的消息处理函数�Q�完成整个消息的"�l�行"�?br>
　　看到�q�里�怿�你有�q�样的疑问：�E�序定义了CWinApp�cȝ��theApp全局变量�Q�可是从来没有调用AfxBeginThread或theApp.CreateThread启动�U�程呀�Q�theApp对应的线�E�是怎么启动的？

　　�{�：MFC在这里用了很高明的一招。实际上�Q�程序开始运行，�W�一个线�E�是�?a class=bluekey target=_blank>操作�pȝ��Q�OS�Q�启动的�Q�在CWinApp的构造函数里�Q�MFC��theApp"对应"向了�q�个�U�程�Q�具体的实现是这��L��Q?br>

CWinApp::CWinApp(LPCTSTR lpszAppName)
{
　if (lpszAppName != NULL)
　　m_pszAppName = _tcsdup(lpszAppName);
　else
　　m_pszAppName = NULL;

　// initialize CWinThread state
　AFX_MODULE_STATE *pModuleState = _AFX_CMDTARGET_GETSTATE();
　AFX_MODULE_THREAD_STATE *pThreadState = pModuleState->m_thread;
　ASSERT(AfxGetThread() == NULL);
　pThreadState->m_pCurrentWinThread = this;
　ASSERT(AfxGetThread() == this);
　m_hThread = ::GetCurrentThread();
　m_nThreadID = ::GetCurrentThreadId();

　// initialize CWinApp state
　ASSERT(afxCurrentWinApp == NULL); // only one CWinApp object please
　pModuleState->m_pCurrentWinApp = this;
　ASSERT(AfxGetApp() == this);

　// in non-running state until WinMain
　m_hInstance = NULL;
　m_pszHelpFilePath = NULL;
　m_pszProfileName = NULL;
　m_pszRegistryKey = NULL;
　m_pszExeName = NULL;
　m_pRecentFileList = NULL;
　m_pDocManager = NULL;
　m_atomApp = m_atomSystemTopic = NULL; //微��Y懒鬼�Q�或者他认�ؓ
　//�q�样�q�等含义更明��？
　m_lpCmdLine = NULL;
　m_pCmdInfo = NULL;

　// initialize wait cursor state
　m_nWaitCursorCount = 0;
　m_hcurWaitCursorRestore = NULL;

　// initialize current printer state
　m_hDevMode = NULL;
　m_hDevNames = NULL;
　m_nNumPreviewPages = 0; // not specified (defaults to 1)

　// initialize DAO state
　m_lpfnDaoTerm = NULL; // will be set if AfxDaoInit called

　// other initialization
　m_bHelpMode = FALSE;
　m_nSafetyPoolSize = 512; // default size
}

　　很显�Ӟ��theApp成员变量都被赋予OS启动的这个当前线�E�相关的��|��如代码：

m_hThread = ::GetCurrentThread();//theApp的线�E�句柄等于当前线�E�句�?
m_nThreadID = ::GetCurrentThreadId();//theApp的线�E�ID�{�于当前�U�程ID

　　所以CWinApp�c�d��乎只是�ؓMFC�E�序的第一个线�E�量�w�定制的�Q�它不需要也不能被AfxBeginThread或theApp.CreateThread"再次"启动。这��是CWinApp�c�d��theApp全局变量的内涵！如果你要再增加一个UI�U�程�Q�不要��承类CWinApp�Q�而应�l�承�c�CWinThread。而参考第1节，�׃��我们一般以�ȝ��E�（在MFC�E�序里实际上��是OS启动的第一个线�E�）处理所有窗口的消息�Q�所以我们几乎没有再启动UI�U�程的需求！

Sandy 2008-11-02 22:36 发表评论

转：Windows多线�E�多��d��设计初步

Sandy — Sun, 02 Nov 2008 14:35:00 GMT

转自�Q?a href="http://www.shnenglu.com/ivenher/articles/983.html">http://www.shnenglu.com/ivenher/articles/983.html
�Q�d��a��Q�］当前��行的Windows操作�pȝ��Q�它能同时运行几个程�?独立�q�行的程序又�U�C��E?�Q�对于同一个程序，它又可以分成若干个独立的执行��，我们�U�C��为线�E�，�U�程提供了多��d��处理的能力。用�q�程和线�E�的观点来研�I��Y件是当今普遍采用的方法，�q�程和线�E�的概念的出玎ͼ��Ҏ��高��Y件的�q�行性有着重要的意义。现在的应用软�g无一不是多线�E�多��d��处理�Q�单�U�城的��Y件是不可惌��的。因此掌握多�U�程多�Q务设计方法对每个�E�序员都是必需要掌握的。本文针对多�U�程技术在应用中经帔R��到的问题�Q�如�U�程间的通信、同步等�Q�对它们分别�q�行探讨�?

　　一�?理解�U�程

　　要讲解线�E�，不得不说一下进�E�，�q�程是应用程序的执行实例�Q�每个进�E�是��q��有的虚拟地址�I�间、代码、数据和其它�pȝ��资源�l�成。进�E�在�q�行时创建的资源随着�q�程的终止而死亡。线�E�的基本思想很简单，它是一个独立的执行��，是进�E�内部的一个独立的执行单元�Q�相当于一个子�E�序�Q�它对应Visual C++中的CwinThread�cȝ��对象。单独一个执行程序运行时�Q�缺省的�q�行包含的一个主�U�程�Q�主�U�程以函数地址的�Ş式，如main或WinMain函数�Q�提供程序的启动点，当主�U�程�l�止�Ӟ��q�程也随之终止，但根据需要，应用�E�序又可以分解成许多独立执行的线�E�，每个�U�程�q�行的运行在同一�q�程中�?

　　一个进�E�中的所有线�E�都在该�q�程的虚拟地址�I�间中，使用该进�E�的全局变量和系�l�资源。操作系�l�给每个�U�程分配不同的CPU旉��片，在某一个时刻，CPU只执行一个时间片内的�U�程�Q�多个时间片中的相应�U�程在CPU内轮��执行，�׃��每个旉��片时间很短，所以对用户来说�Q�仿佛各个线�E�在计算��Z��是�ƈ行处理的。操作系�l�是�Ҏ��U�程的优先��来安排CPU的时��_��优先�U�高的线�E�优先运行，优先�U�低的线�E�则�l�箋�{�待�?

　　 �U�程被分��Z��U�：用户界面�U�程和工作线�E�（又称为后台线�E�）。用��L��面线�E�通常用来处理用户的输入�ƈ响应各种事�g和消息，其实�Q�应用程序的��L��行线�E�CWinAPP对象��是一个用��L��面线�E�，当应用程序启动时自动创徏和启动，同样它的�l�止也意味着该程序的�l�束�Q�进城终止。工作者线�E�用来执行程序的后台处理��d��Q�比如计��、调度、对串口的读写操作等�Q�它和用��L��面线�E�的区别是它不用从CwinThread�c�L��生来创徏�Q�对它来说最重要的是如何实现工作�U�程��d��的运行控制函数。工作线�E�和用户界面�U�程启动时要调用同一个函数的不同版本�Q�最后需要读者明白的是，一个进�E�中的所有线�E�共享它们父�q�程的变量，但同时每个线�E�可以拥有自��q��变量�?
　　二�?�U�程的管理和操作

　　 1�Q?�U�程的启�?

　　创徏一个用��L��面线�E�，首先要从�c�CwinThread产生一个派生类�Q�同时必��M��用DECLARE_DYNCREATE和IMPLEMENT_DYNCREATE来声明和实现�q�个CwinThread�z��c�R�?

　　 �W�二步是�Ҏ��需要重载该�z��cȝ��一些成员函数如�Q�ExitInstance()�Q�InitInstance()�Q�OnIdle();PreTranslateMessage()�{�函敎ͼ�最后启动该用户界面�U�程�Q�调用AfxBeginThread()函数的一个版本：CWinThread* AfxBeginThread( CRuntimeClass* pThreadClass, int nPriority = THREAD_PRIORITY_NORMAL, UINT nStackSize = 0, DWORD dwCreateFlags = 0, LPSECURITY_ATTRIBUTES lpSecurityAttrs = NULL );其中�W�一个参��Cؓ指向定义的用��L��面线�E�类指针变量�Q�第二个参数为线�E�的优先�U�，�W�三个参��Cؓ�U�程所对应的堆栈大��，�W�四个参��Cؓ�U�程创徏时的附加标志�Q�缺省�ؓ正常状态，如�ؓCREATE_SUSPENDED则线�E�启动后为挂��L��态�?

　　对于工作�U�程来说�Q�启动一个线�E�，首先需要编写一个希望与应用�E�序的其余部分�ƈ行运行的函数如Fun1()�Q�接着定义一个指向CwinThread对象的指针变�?pThread,调用AfxBeginThread(Fun1,param,priority)函数�Q�返回��g��l�pThread变量的同时一�q�启动该�U�程来执行上面的Fun1()函数�Q�其中Fun1是线�E�要�q�行的函数的名字�Q�也既是上面所说的控制函数的名字，param是准备传送给�U�程函数Fun1的�Q�?2位��|��priority则是定义该线�E�的优先�U�别�Q�它是预定义的常敎ͼ�读者可参考MSDN�?

　　 2�Q�线�E�的优先�U?

　　以下的CwinThread�cȝ��成员函数用于�U�程优先�U�的操作�Q?

int GetThreadPriority();
BOOL SetThradPriority()(int nPriority);

上述的二个函数分别用来获取和讄��U�程的优先��Q�这里的优先�U�，是相对于该线�E�所处的优先权层�ơ而言的，处于同一优先权层�ơ的�U�程�Q�优先��高的�U�程先运行；处于不同优先权层�ơ上的线�E�，谁的优先权层�ơ高�Q�谁先运行。至于优先��讄��所需的常敎ͼ�自己参考MSDN��可以了�Q�要注意的是要想讄��U�程的优先��Q�这个线�E�在创徏时必��d��有THREAD_SET_INFORMATION讉K��权限。对于线�E�的优先权层�ơ的讄��Q�CwinThread�c�L��有提供相应的函数�Q�但是可以通过Win32 SDK函数GetPriorityClass()和SetPriorityClass()来实现�?

　　 3�Q�线�E�的悬挂、恢�?

　　 CwinThread�c�M��包含了应用程序悬挂和恢复它所创徏的线�E�的函数�Q�其中SuspendThread()用来悬挂�U�程�Q�暂停线�E�的执行�Q�ResumeThread()用来恢复�U�程的执行。如果你对一个线�E�连�l�若�q�次执行SuspendThread()�Q�则需要连�l�执行相应次的ResumeThread()来恢复线�E�的�q�行�?

　　 4�Q�结束线�E?

　　 �l�止�U�程有三�U�途径�Q�线�E�可以在自��n内部调用AfxEndThread()来终止自�w�的�q�行�Q�可以在�U�程的外部调用BOOL TerminateThread( HANDLE hThread, DWORD dwExitCode )来强行终止一个线�E�的�q�行�Q�然后调用CloseHandle�Q�）函数释放�U�程所占用的堆栈；�W�三�U�方法是改变全局变量�Q��ɾU�程的执行函数返回，则该�U�程�l�止。下面以�W�三�U�方法�ؓ例，�l�出部分代码�Q?

////////////////////////////////////////////////////////////////
//////CtestView message handlers
/////Set to True to end thread
Bool bend=FALSE;//定义的全局变量�Q�用于控制线�E�的�q�行
//The Thread Function
UINT ThreadFunction(LPVOID pParam)//�U�程函数
{
while(!bend)
{Beep(100,100);
Sleep(1000);
}
return 0;
}
CwinThread *pThread;
HWND hWnd;
/////////////////////////////////////////////////////////////
Void CtestView::OninitialUpdate()
{
hWnd=GetSafeHwnd();
pThread=AfxBeginThread(ThradFunction,hWnd);//启动�U�程
pThread->m_bAutoDelete=FALSE;//�U�程为手动删�?
Cview::OnInitialUpdate();
}
////////////////////////////////////////////////////////////////
Void CtestView::OnDestroy()
{ bend=TRUE;//改变变量�Q�线�E�结�?
WaitForSingleObject(pThread->m_hThread,INFINITE);//�{�待�U�程�l�束
delete pThread;//删除�U�程
Cview::OnDestroy();
}
　　三�?�U�程之间的通信

　　通常情况下，一个次�U�线�E�要��Z��U�程完成某种特定�c�d��的�Q务，�q�就隐含着表示在主�U�程和次�U�线�E�之间需要徏立一个通信的通道。一般情况下�Q�有下面的几�U�方法实现这�U�通信��d��Q��用全局变量�Q�上一节的例子其实使用的就是这�U�方法）、��用事件对象、��用消息。这里我们主要介�l�后两种�Ҏ��?

　　 1�Q?利用用户定义的消息通信

　　在Windows�E�序设计中，应用�E�序的每一个线�E�都拥有自己的消息队列，甚至工作�U�程也不例外�Q�这样一来，��׃��得线�E�之间利用消息来传递信息就变的非常��单。首先用戯��定义一个用��h��息，如下所�C�：#define WM_USERMSG WMUSER+100�Q�在需要的时候，在一个线�E�中调用

�Q�：PostMessage((HWND)param,WM_USERMSG,0,0)
�?
CwinThread::PostThradMessage()

来向另外一个线�E�发送这个消息，上述函数的四个参数分别是消息��要发送到的目的窗口的句柄、要发送的消息标志�W�、消息的参数WPARAM和LPARAM。下面的代码是对上节代码的修改，修改后的�l�果是在�U�程�l�束时显�C�Z��个对话框�Q�提�C�线�E�结束：

UINT ThreadFunction(LPVOID pParam)
{
while(!bend)
{
Beep(100,100);
Sleep(1000);
}
�Q�：PostMessage(hWnd,WM_USERMSG,0,0)�Q?
return 0;
}
////////WM_USERMSG消息的响应函��CؓOnThreadended(WPARAM wParam,LPARAM lParam)
LONG CTestView::OnThreadended(WPARAM wParam,LPARAM lParam)
{
AfxMessageBox("Thread ended.");
Retrun 0;
}

上面的例子是工作者线�E�向用户界面�U�程发送消息，对于工作者线�E�，如果它的设计模式也是消息驱动的，那么调用者可以向它发送初始化、退出、执行某�U�特定的处理�{�消息，让它在后台完成。在控制函数中可以直接��用：�Q�GetMessage()�q�个SDK函数�q�行消息分检和处理，自己实现一个消息��@环。GetMessage()函数在判断该�U�程的消息队列�ؓ�I�时�Q�线�E�将�pȝ��分配�l�它的时间片让给其它�U�程�Q�不无效的占用CPU的时��_��如果消息队列不�ؓ�I�，��p��取这个消息，判断�q�个消息的内容�ƈ�q�行相应的处理�?

　　 2�Q�用事�g对象实现通信

　　在线�E�之间传递信可��行通信比较复杂的方法是使用事�g对象�Q�用MFC的Cevent�cȝ��对象来表�C�。事件对象处于两�U�状态之一�Q�有信号和无信号�Q�线�E�可以监视处于有信号状态的事�g�Q�以便在适当的时候执行对事�g的操作。上�q�C��子代码修改如下：

////////////////////////////////////////////////////////////////////
Cevent threadStart,threadEnd;
////////////////////////////////////////////////////////////////////
UINT ThreadFunction(LPVOID pParam)
{
�Q�：WaitForSingleObject(threadStart.m_hObject,INFINITE);
AfxMessageBox("Thread start.");
while(!bend)
{
Beep(100,100);
Sleep(1000);
Int result=::WaitforSingleObject(threadEnd.m_hObject,0);
//�{�待threadEnd事�g有信��P��无信��h��U�程在这里悬�?
If(result==Wait_OBJECT_0)
Bend=TRUE;
}
�Q�：PostMessage(hWnd,WM_USERMSG,0,0)�Q?
return 0;
}
/////////////////////////////////////////////////////////////
Void CtestView::OninitialUpdate()
{
hWnd=GetSafeHwnd();
threadStart.SetEvent();//threadStart事�g有信�?
pThread=AfxBeginThread(ThreadFunction,hWnd);//启动�U�程
pThread->m_bAutoDelete=FALSE;
Cview::OnInitialUpdate();
}
////////////////////////////////////////////////////////////////
Void CtestView::OnDestroy()
{ threadEnd.SetEvent();
WaitForSingleObject(pThread->m_hThread,INFINITE);
delete pThread;
Cview::OnDestroy();
}

�q�行�q�个�E�序�Q�当关闭�E�序�Ӟ��才显�C�提�C�框�Q�显�C?Thread ended"
　　四�?�U�程之间的同�?

　　前面我们讲过�Q�各个线�E�可以访问进�E�中的公共变量，所以��用多�U�程的过�E�中需要注意的问题是如何防止两个或两个以上的线�E�同时访问同一个数据，以免破坏数据的完整性。保证各个线�E�可以在一起适当的协调工作称为线�E�之间的同步。前面一节介�l�的事�g对象实际上就是一�U�同步�Ş式。Visual C++中��用同步类来解��x��作系�l�的�q�行性而引��L��数据不安全的问题�Q�MFC支持的七个多�U�程的同步类可以分成两大�c�：同步对象�Q�CsyncObject、Csemaphore、Cmutex、CcriticalSection和Cevent�Q�和同步讉K��对象�Q�CmultiLock和CsingleLock�Q�。本节主要介�l��界区�Q�critical section�Q�、互斥（mutexe�Q�、信号量�Q�semaphore�Q�，�q�些同步对象使各个线�E�协调工作，�E�序�q�行��h��更安全�?

　　 1�Q?临界�?

　　临界区是保证在某一个时间只有一个线�E�可以访问数据的�Ҏ��。��用它的过�E�中�Q�需要给各个�U�程提供一个共享的临界区对象，无论哪个�U�程占有临界区对象，都可以访问受��C��护的数据�Q�这时候其它的�U�程需要等待，直到该线�E�释放��界区对象为止�Q��界区被释攑֐��Q�另外的�U�程可以强占�q�个临界区，以便讉K��׃�n的数据。��界区对应着一个CcriticalSection对象�Q�当�U�程需要访问保护数据时�Q�调用��界区对象的Lock()成员函数�Q�当对保护数据的操作完成之后�Q�调用��界区对象的Unlock()成员函数释放对��界区对象的拥有权�Q�以使另一个线�E�可以夺取��界区对象�q�访问受保护的数据。同时启动两个线�E�，它们对应的函数分别�ؓWriteThread()和ReadThread()�Q�用以对公共数组�l�array[]操作�Q�下面的代码说明了如何��用��界区对象�Q?

#include "afxmt.h"
int array[10],destarray[10];
CCriticalSection Section;
////////////////////////////////////////////////////////////////////////
UINT WriteThread(LPVOID param)
{Section.Lock();
for(int x=0;x<10;x++)
array[x]=x;
Section.Unlock();
}
UINT ReadThread(LPVOID param)
{
Section.Lock();
For(int x=0;x<10;x++)
Destarray[x]=array[x];
Section.Unlock();
}

上述代码�q�行的结果应该是Destarray数组中的元素分别�?-9�Q�而不是杂乱无章的敎ͼ�如果不��用同步，则不是这个结果，有兴��的读者可以实验一下�?
　　 2�Q?互斥

　　互斥与��界区很相��|��但是使用时相对复杂一些，它不仅可以在同一应用�E�序的线�E�间实现同步�Q�还可以在不同的�q�程间实现同步，从而实现资源的安全�׃�n。互斥与Cmutex�cȝ��对象相对应，使用互斥对象�Ӟ��必须创徏一个CSingleLock或CMultiLock对象�Q�用于实际的讉K��控制�Q�因��里的例子只处理单个互斥，所以我们可以��用CSingleLock对象�Q�该对象的Lock()函数用于占有互斥�Q�Unlock()用于释放互斥。实��C��码如下：

#include "afxmt.h"
int array[10],destarray[10];
CMutex Section;

/////////////////////////////////////////////////////////////
UINT WriteThread(LPVOID param)
{ CsingleLock singlelock;
singlelock (&Section);
singlelock.Lock();
for(int x=0;x<10;x++)
array[x]=x;
singlelock.Unlock();
}
UINT ReadThread(LPVOID param)
{ CsingleLock singlelock;
singlelock (&Section);
singlelock.Lock();

For(int x=0;x<10;x++)
Destarray[x]=array[x];
singlelock.Unlock();

}

　　 3�Q?信号�?

　　信号量的用法和互斥的用法很相��|��不同的是它可以同一时刻允许多个�U�程讉K��同一个资源，创徏一个信号量需要用Csemaphore�c�d��明一个对象，一旦创��Z��一个信号量对象�Q�就可以用它来对资源的访问技术。要实现计数处理�Q�先创徏一个CsingleLock或CmltiLock对象�Q�然后用该对象的Lock()函数减少�q�个信号量的计数��|��Unlock()反之。下面的代码分别启动三个�U�程�Q�执行时同时昄��二个消息框，然后10�U�后�W�三个消息框才得以显�C��?

/////////////////////////////////////////////////////////////////
Csemaphore *semaphore;
Semaphore=new Csemaphore(2,2);
HWND hWnd=GetSafeHwnd();
AfxBeginThread(threadProc1,hWnd);
AfxBeginThread(threadProc2,hWnd);
AfxBeginThread(threadProc3,hWnd);
//////////////////////////////////////////////////////////////////////
UINT ThreadProc1(LPVOID param)
{CsingleLock singelLock(semaphore);
singleLock.Lock();
Sleep(10000);
::MessageBox((HWND)param,"Thread1 had access","Thread1",MB_OK);
return 0;
}
UINT ThreadProc2(LPVOID param)
{CSingleLock singelLock(semaphore);
singleLock.Lock();
Sleep(10000);
::MessageBox((HWND)param,"Thread2 had access","Thread2",MB_OK);
return 0;
}
UINT ThreadProc3(LPVOID param)
{CsingleLock singelLock(semaphore);
singleLock.Lock();
Sleep(10000);
::MessageBox((HWND)param,"Thread3 had access","Thread3",MB_OK);
return 0;
}

　　对复杂的应用�E�序来说�Q�线�E�的应用�l�应用程序提供了高效、快速、安全的数据处理能力。本文讲�q�C��U�程中经帔R��到的问题�Q�希望对读者朋友有一定的帮助�?

Sandy 2008-11-02 22:35 发表评论

转：一个跨�q�_��?C++ 内存泄漏��器

Sandy — Sun, 02 Nov 2008 02:56:00 GMT

http://www-128.ibm.com/developerworks/cn/linux/l-mleak2/index.html

内存泄漏对于C/C++�E�序员来说也可以��作是个永恒的话题了吧。在Windows下，MFC的一个很有用的功能就是能在程序运行结束时报告是否发生了内存泄漏。在Linux下，相对来说��没有那么容易��用的解决�Ҏ��了：像mpatrol之类的现有工��P��易用性、附加开销和性能都不是很理想。本文实��C��个极易于使用、跨�q�_��的C++内存泄漏��器。�ƈ对相关的技术问题作一下探讨�?/p>

基本使用

对于下面�q�样的一个简单程序test.cpp�Q?/p>

int main()
            {
            int* p1 = new int;
            char* p2 = new char[10];
            return 0;
            }

我们的基本需求当然是对于该程序报告存在两处内存泄漏。要做到�q�点的话�Q�非常简单，只要把debug_new.cpp也编译、链接进��d��可以了。在Linux下，我们使用�Q?/p>

g++ test.cpp debug_new.cpp -o test

输出�l�果如下所�C�：

Leaked object at 0x805e438 (size 10, :0)
            Leaked object at 0x805e410 (size 4, :0)

如果我们需要更清晰的报告，也很��单，在test.cpp开头加一�?/p>

#include "debug_new.h"

卛_��。添加该行后的输出如下：

Leaked object at 0x805e438 (size 10, test.cpp:5)
            Leaked object at 0x805e410 (size 4, test.cpp:4)

非常��单！

回页�?/font>

背景知识

在new/delete操作中，C++为用户��生了对operator new和operator delete的调用。这是用户不能改变的。operator new和operator delete的原型如下所�C�：

void *operator new(size_t) throw(std::bad_alloc);
            void *operator new[](size_t) throw(std::bad_alloc);
            void operator delete(void*) throw();
            void operator delete[](void*) throw();

对于"new int"�Q�编译器会��生一个调�?operator new(sizeof(int))"�Q�而对�?new char[10]"�Q�编译器会��?operator new[](sizeof(char) * 10)"�Q�如果new后面跟的是一个类名的话，当然�q�要调用该类的构造函敎ͼ�。类似地�Q�对�?delete ptr"�?delete[] ptr"�Q�编译器会��?operator delete(ptr)"调用�?operator delete[](ptr)"调用�Q�如果ptr的类型是指向对象的指针的话，那在operator delete之前�q�要调用对象的析构函敎ͼ�。当用户没有提供�q�些操作�W�时�Q�编译系�l�自动提供其定义�Q�而当用户自己提供了这些操作符�Ӟ��p��盖了�~�译�pȝ��提供的版本，从而可获得对动态内存分配操作的�_��跟踪和控制�?/p>

同时�Q�我们还可以使用placement new操作�W�来调整operator new的行为。所谓placement new�Q�是指带有附加参数的new操作�W�，比如�Q�当我们提供了一个原型�ؓ

void* operator new(size_t size, const char* file, int line);

的操作符�Ӟ��我们��可以��?new("hello", 123) int"来��生一个调�?operator new(sizeof(int), "hello", 123)"。这可以是相当灵�zȝ��。又如，C++标准要求�~�译器提供的一个placement new操作�W�是

void* operator new(size_t size, const std::nothrow_t&);

其中�Q�nothrow_t通常是一个空�l�构�Q�定义�ؓ"struct nothrow_t {};"�Q�，其唯一目的是提供编译器一个可�Ҏ��重蝲规则识别具体调用的类型。用户一般简单地使用"new(std::nothrow) �c�d��"�Q�nothrow是一个nothrow_t�c�d��的常量）来调用这个placement new操作�W�。它与标准new的区别是�Q�new在分配内存失败时会抛出异常，�?new(std::nothrow)"在分配内存失败时会返回一个空指针�?/p>

要注意的是，没有对应�?delete(std::nothrow) ptr"的语法；不过后文会提到另一个相关问题�?/p>

要进一步了解以上关于C++语言�Ҏ��的信息�Q�请参阅[Stroustrup1997]�Q�特别是6.2.6�?0.4.11�?5.6�?9.4.5和B.3.4节。这些C++语言�Ҏ��是理解本实现的关键�?/p>

回页�?/font>

��原�?/span>

和其它一些内存泄漏检��的方式�c�M��Q�debug_new中提供了operator new重蝲�Q��ƈ使用了宏在用��L��序中�q�行替换。debug_new.h中的相关部分如下�Q?/p>

void* operator new(size_t size, const char* file, int line);
            void* operator new[](size_t size, const char* file, int line);
            #define new DEBUG_NEW
            #define DEBUG_NEW new(__FILE__, __LINE__)

拿上面加入debug_new.h包含后的test.cpp来说�Q?new char[10]"在预处理后会变成"new("test.cpp", 4) char[10]"�Q�编译器会据此��生一�?operator new[](sizeof(char) * 10, "test.cpp", 4)"调用。通过在debug_new.cpp中自定义"operator new(size_t, const char*, int)"�?operator delete(void*)"�Q�以�?operator new[]…"�?operator delete[]…"�Q��ؓ避免行文累赘�Q�以下不特别指出�Q�说到operator new和operator delete均同时包含数�l�版本）�Q�我可以跟踪所有的内存分配调用�Q��ƈ在指定的��查点上对不匹配的new和delete操作�q�行报警。实现可以相当简单，用map记录所有分配的内存指针��可以了�Q�new时往map里加一个指针及其对应的信息�Q�delete时删除指针及对应的信息；delete时如果map里不存在该指针�ؓ错误删除�Q�程序退出时如果map里还存在未删除的指针则说明有内存泄漏�?/p>

不过�Q�如果不包含debug_new.h�Q�这�U�方法就起不了作用了。不仅如此，部分文�g包含debug_new.h�Q�部分不包含debug_new.h都是不可行的。因��然我们��用了两种不同的operator new --"operator new(size_t, const char*, int)"�?operator new(size_t)"-- 但可用的"operator delete"�q�是只有一�U�！使用我们自定义的"operator delete"�Q�当我们删除�?operator new(size_t)"分配的指针时�Q�程序将认�ؓ被删除的是一个非法指针！我们处于一个两隑֢�圎ͼ�要么对这�U�情况��生误报，要么寚w��复删除同一指针两次不予报警�Q�都不是可接受的良好行�ؓ�?/p>

看来�Q�自定义全局"operator new(size_t)"也是不可避免的了。在debug_new中，我是�q�样做的�Q?/p>

void* operator new(size_t size)
            {
            return operator new(size, "", 0);
            }

但前面描�q�的方式��d��现内存泄漏检��器�Q�在某些C++的实��C��Q�如GCC 2.95.3中带的SGI STL�Q�工作正常，但在另外一些实��C��会莫名其妙地崩溃。原因也不复杂，SGI STL使用了内存池�Q�一�ơ分配一大片内存�Q�因而��利用map成�ؓ可能�Q�但在其他的实现可能没这样做�Q�在map中添加数据会调用operator new�Q�而operator new会在map中添加数据，从而构成一个死循环�Q�导致内存溢出，应用�E�序立即崩溃。因此，我们不得不停止��用方便的STL模板�Q�而��用手工构建的数据�l�构�Q?/p>

struct new_ptr_list_t
            {
            new_ptr_list_t*		next;
            const char*			file;
            int					line;
            size_t				size;
            };

我最初的实现�Ҏ��是每次在��用new分配内存�Ӟ��调用malloc多分�?sizeof(new_ptr_list_t) 个字节，把分配的内存全部串成一个一个链表（利用next字段�Q�，把文件名、行受��对象大��信息分别存入file、line和size字段中，然后�q�回(malloc�q�回的指�?+ sizeof(new_ptr_list_t))。在delete�Ӟ��则在链表中搜索，如果扑ֈ�的话�Q?char*)链表指针 + sizeof(new_ptr_list_t) == 待释攄��指针�Q�，则调整链表、释攑ֆ�存，找不到的话报告删除非法指针�ƈabort�?/p>

至于自动��内存泄漏，我的做法是生成一个静态全局对象�Q�根据C++的对象生命期�Q�在�E�序初始化时会调用该对象的构造函敎ͼ�在其退出时会调用该对象的析构函敎ͼ��Q�在其析构函��C��调用��内存泄漏的函数。用��h��工调用内存泄漏检��函数当然也是可以的�?/p>

基本实现大体��是如此�?/p>

回页�?/font>

可用性改�q?/span>

上述�Ҏ��最初工作得相当好，直到我开始创建大量的对象为止。由于每�ơdelete旉��要在链表中进行搜索，�q�_��搜烦�ơ数�?链表长度/2)�Q�程序很快就慢得像乌龟爬。虽说只是用于调试，速度太慢也是不能接受的。因此，我做了一个小更改�Q�把指向链表头部的new_ptr_list�Ҏ��了一个数�l�，一个对象指针放在哪一个链表中则由它的哈希值决定�?-用户可以更改宏DEBUG_NEW_HASH和DEBUG_NEW_HASHTABLESIZE的定义来调整debug_new的行为。他们的当前值是我测试下来比较满意的定义�?/p>

使用中我们发玎ͼ�在某些特�D�情况下�Q�请直接参看debug_new.cpp中关于DEBUG_NEW_FILENAME_LEN部分的注释）�Q�文件名指针会失效。因此，目前的debug_new的缺省行��Z��复制文�g名的�?0个字�W�，而不只是存储文�g名的指针。另外，��h��意原先new_ptr_list_t的长度�ؓ16字节�Q�现在是32字节�Q�都能保证在通常情况下内存对齐�?/p>

此外�Q��ؓ了允许程序能�?new(std::nothrow) 一起工作，我也重蝲了operator new(size_t, const std::nothrow_t&) throw()�Q�不然的话，debug_new会认为对应于 new(nothrow) 的delete调用删除的是一个非法指针。由于debug_new不抛出异常（内存不��时程序直接报警退出）�Q�所以这一重蝲的操作只不过是调�?operator new(size_t) 而已。这��׃��用多说了�?/p>

前面已经提到�Q�要得到�_��的内存泄漏检��报告，可以在文件开头包�?debug_new.h"。我的惯常做法可以用作参考：

#ifdef _DEBUG
            #include "debug_new.h"
            #endif

包含的位�|�应当尽可能早，除非跟系�l�的头文�Ӟ��典型情况是STL的头文�g�Q�发生了冲突。在某些情况下，可能会不希望debug_new重定义new�Q�这时可以在包含debug_new.h之前定义DEBUG_NEW_NO_NEW_REDEFINITION�Q�这��L��话，在用户应用程序中应��用debug_new来代替new�Q�顺便提一句，没有定义DEBUG_NEW_NO_NEW_REDEFINITION时也可以使用debug_new代替new�Q�。在源文件中也许��p��q�样写：

#ifdef _DEBUG
            #define DEBUG_NEW_NO_NEW_REDEFINITION
            #include "debug_new.h"
            #else
            #define debug_new new
            #endif

�q�在需要追�t�内存分配的时候全部��用debug_new�Q�考虑使用全局替换�Q��?/p>

用户可以选择定义DEBUG_NEW_EMULATE_MALLOC�Q�这样debug_new.h会��用debug_new和delete来模拟malloc和free操作�Q��得用��L��序中的malloc和free操作也可以被跟踪。在使用某些�~�译器的时候（如Digital Mars C++ Compiler 8.29和Borland C++ Compiler 5.5.1�Q�，用户必须定义NO_PLACEMENT_DELETE�Q�否则编译无法通过。用戯��可以使用两个全局布尔量来调整debug_new的行为：new_verbose_flag�Q�缺省�ؓfalse�Q�定义�ؓtrue时能在每�ơnew/delete时向标准错误输出昄��跟踪信息�Q�new_autocheck_flag�Q�缺省�ؓtrue�Q�即在程序退出时自动调用check_leaks��查内存泄漏，改�ؓfalse的话用户必须手工调用check_leaks来检查内存泄漏�?/p>

需要注意的一�Ҏ��Q�由于自动调用check_leaks是在debug_new.cpp中的静态对象析构时�Q�因此不能保证用��L��全局对象的析构操作发生在check_leaks调用之前。对于Windows上的MSVC�Q�我使用�?#pragma init_seg(lib)"来调整对象分配释攄��序�Q�但很遗憾，我不知道在其他的一些编译器中（特别是，我没能成功地在GCC中解册��一问题�Q�怎么做到�q�一炏V��ؓ了减��误报警�Q�我采取的方式是在自动调用了check_leaks之后设new_verbose_flag为true�Q�这��P��q��误报告了内存泄漏�Q�随后的delete操作�q�是会被打印昄��出来。只要泄漏报告和delete报告的内容一��_��我们仍可以判断出没有发生内存泄漏�?/p>

Debug_new也能��对同一指针重复调用delete�Q�或delete无效指针�Q�的错误。程序将昄��错误的指针��|��q�强制调用abort退出�?/p>

�q�有一个问题是异常处理。这值得用专门的一节来�q�行说明�?/p>

回页�?/font>

构造函��C��的异�?/span>

我们看一下以下的��单程序示例：

#include 
            #include 
            void* operator new(size_t size, int line)
            {
            printf("Allocate %u bytes on line %d\\n", size, line);
            return operator new(size);
            }
            class Obj {
            public:
            Obj(int n);
            private:
            int _n;
            };
            Obj::Obj(int n) : _n(n)
            {
            if (n == 0) {
            throw std::runtime_error("0 not allowed");
            }
            }
            int main()
            {
            try {
            Obj* p = new(__LINE__) Obj(0);
            delete p;
            } catch (const std::runtime_error& e) {
            printf("Exception: %s\\n", e.what());
            }
            }

看出代码中有什么问题了吗？实际上，如果我们用MSVC�~�译的话�Q�编译器的警告信息已�l�告诉我们发生了什么：

test.cpp(27) : warning C4291: 'void *__cdecl operator new(unsigned int,int)' :
            no matching operator delete found; memory will not be freed if initialization throws an exception

好，把debug_new.cpp链接�q�去。运行结果如下：

Allocate 4 bytes on line 27 Exception: 0 not allowed Leaked object at 00342BE8 (size 4, :0)

啊哦�Q�内存泄漏了不是�Q?/p>

当然�Q�这�U�情况�ƈ非很常见。可是，随着对象��来��复杂，谁能够保证一个对象的子对象的构造函数或者一个对象在构造函��C��调用的所有函数都不会抛出异常�Q��ƈ且，解决该问题的�Ҏ��q�不复杂�Q�只是需要编译器�?C++ 标准有较好支持，允许用户定义 placement delete ��符�Q�[C++1998]�Q?.3.4节；�|�上可以扑ֈ�1996�q�的标准草案�Q�比如下面的�|�址 http://www.comnets.rwth-aachen.de/doc/c++std/expr.html#expr.new�Q�。在我测试的�~�译器中�Q�GCC�Q?.95.3或更高版本，Linux/Windows�Q�和MSVC�Q?.0或更高版本）没有问题�Q�而Borland C++ Compiler 5.5.1和Digital Mars C++ Compiler�Q�到v8.38为止的所有版本）则不支持该项�Ҏ��。在上面的例子中�Q�如果编译器支持的话�Q�我们就需要声明�ƈ实现 operator delete(void*, int) 来回收new分配的内存。编译器不支持的话，需要��用宏让编译器忽略相关的声明和实现。如果要让debug_new在Borland C++ Compiler 5.5.1或Digital Mars C++ Compiler下编译的话，用户必须定义宏NO_PLACEMENT_DELETE�Q�当�Ӟ��用户得自己注意小心构造函��C��抛出异常�q�个问题了�?

回页�?/font>

�Ҏ��比较

IBM developerWorks上刊载了�z�琨先生设计实现的一个Linux上的内存泄漏��方法（[�z�琨2003]�Q�。我的方案与其相比，主要区别如下�Q?/p>

优点�Q?

跨��^収ͼ�只��用标准函敎ͼ��q�且在GCC 2.95.3/3.2�Q�Linux/Windows�Q�、MSVC 6、Digital Mars C++ 8.29、Borland C++ 5.5.1�{�多个编译器下调试通过。（虽然Linux是我的主要开发��^収ͼ�但我发现�Q�有时候能在Windows下编译运行代码还是非常方便的。）
易用性：�׃��重蝲了operator new(size_t)--�z�琨先生只重载了operator new(size_t, const char*, int)--即��不包含我的头文�g也能��内存泄漏；�E�序退出时能自动检��内存泄漏；可以��用��L��序（不包括系�l?库文�Ӟ��中malloc/free产生的内存泄漏�?
灉|��性：有多个灵�zȝ��可配�|�项�Q�可使用宏定义进行编译时选择�?
可重入性：不��用全局变量�Q�没有嵌套delete问题�?
异常安全性：在编译器支持的情况下�Q�能够处理构造函��C��抛出的异常而不发生内存泄漏�?

�~�点�Q?

单线�E�模型：跨��^台的多线�E�实现较为麻烦，�Ҏ��目的实际需要，也�ؓ了代码清晰简单�v见，我的�Ҏ��不是�U�程安全的；换句话说�Q�如果多个线�E�中同时�q�行new或delete操作的话�Q�后果未定义�?
未实现运行中内存泄漏��报告机�Ӟ��没有遇到�q�个需求J�Q�不�q�，如果要手工调用check_leaks函数实现的话也不困难�Q�只是跨�q�_��性就有点问题了�?
不能��带 [] ��符和不�?[] ��符��L��的不匚w��Q�主要也是需求问题（如果要修改实现的话�ƈ不困难）�?
不能在错误的delete调用时显�C�文件名和行��P��应该不是大问题；�׃��我重载了operator new(size_t)�Q�可以保证delete出错时程序必然有问题�Q�因而我不只是显�C��告信息，而且会强制程序abort�Q�可以通过跟踪�E�序、检查abort时程序的调用栈知道问题出在哪�ѝ�?

另外�Q�现在已存在不少商业和Open Source的内存泄漏检��器�Q�本文不打算一一再做比较。Debug_new与它们相比，功能上�ȝ��来说仍较弱，但是�Q�其良好的易用性和跨��^台性、低廉的附加开销�q�是��h��很大优势的�?/p>

回页�?/font>

�ȝ��和讨�?/span>

以上�D�落基本上已�l�说明了debug_new的主要特炏V��下面做一个小��的�ȝ��?/p>

重蝲的算�W�：

operator new(size_t, const char*, int)
operator new[](size_t, const char*, int)
operator new(size_t)
operator new[](size_t)
operator new(size_t, const std::nothrow_t&)
operator new[](size_t, const std::nothrow_t&)
operator delete(void*)
operator delete[](void*)
operator delete(void*, const char*, int)
operator delete[](void*, const char*, int)
operator delete(void*, const std::nothrow_t&)
operator delete[](void*, const std::nothrow_t&)

提供的函敎ͼ�

check_leaks()
��查是否发生内存泄�?

提供的全局变量

new_verbose_flag
是否在new和delete�?�|�嗦"地显�C�Z��?
new_autocheck_flag
是否在程序退出是自动��一�ơ内存泄�?

可重定义的宏�Q?

NO_PLACEMENT_DELETE
假设�~�译器不支持placement delete�Q�全局有效�Q?
DEBUG_NEW_NO_NEW_REDEFINITION
不重定义new�Q�假讄��户会自己使用debug_new�Q�包含debug_new.h时有效）
DEBUG_NEW_EMULATE_MALLOC
重定义malloc/free�Q��用new/delete�q�行模拟�Q�包含debug_new.h时有效）
DEBUG_NEW_HASH
改变内存块链表哈希值的��法�Q�编译debug_new.cpp时有效）
DEBUG_NEW_HASHTABLE_SIZE
改变内存块链表哈希桶的大��（�~�译debug_new.cpp时有效）
DEBUG_NEW_FILENAME_LEN
如果在分配内存时复制文�g名的话，保留的文件名长度�Q��ؓ0时则自动定义DEBUG_NEW_NO_FILENAME_COPY�Q�编译debug_new.cpp时有效；参见文�g中的注释�Q?
DEBUG_NEW_NO_FILENAME_COPY
分配内存时不�q�行文�g名复�Ӟ��而只是保存其指针�Q�效率较高（�~�译debug_new.cpp时有效；参见文�g中的注释�Q?

我本��为，debug_new目前的一个主要缺��h��不支持多�U�程。对于某一特定�q�_��Q�要加入多线�E�支持�ƈ不困难，隑ְ�隑֜�通用上（当然�Q�条件编译是一个办法，虽然不够优雅�Q�。等到C++标准中包含线�E�模型时�Q�这个问题也许能比较完美地解军_��。另一个办法是使用像boost�q�样的程序库中的�U�程��装�c�，不过�Q�这又会增加对其它库的依赖�?-毕竟boost�q�不是C++标准的一部分。如果项目本�w��ƈ不用boost�Q�单��Z��q�一个目的��用另外一个程序库��g��q�不值得。因此，我自己暂时就不做�q�进一步的改进了�?/p>

另外一个可能的修改是保留标准operator new的异常行为，使其在内存不��的情况下抛出异常（普通情况）或是�q�回NULL�Q�nothrow情况�Q�，而不是像现在一��L��止程序运行（参见debug_new.cpp的源代码�Q�。这一做法的难度主要在于后者：我没惛_��什么方法，可以保留 new(nothrow) 的语法，同时能够报告文�g名和行号�Q��ƈ且还能够使用普通的new。不�q�，如果不��用标准语法，一律��用debug_new和debug_new_nothrow的话�Q�那�q�是非常�Ҏ��实现的�?/p>

如果大家有改�q�意见或其它��x��的话�Q�欢�q�来信讨论�?/p>

debug_new 的源代码目前可以�?dbg_new.zip处下载�?

在这��文章的写完之后�Q�我�l�于�q�是实现了一个线�E�安全的版本。该版本使用了一个轻量��的跨�q�_��互斥体类fast_mutex�Q�目前支持Win32和POSIX�U�程�Q�在使用GCC�Q�Linux/MinGW�Q�、MSVC时能通过命��o行参数自动检��线�E�类型）。有兴趣的话可在 http://mywebpage.netscape.com/yongweiwu/dbg_new.tgz下蝲�?

参考资�?

[C++1998] ISO/IEC 14882. Programming Languages-C++, 1st Edition. International Standardization Organization, International Electrotechnical Commission, American National Standards Institute, and Information Technology Industry Council, 1998

[Stroustrup1997] Bjarne Stroustrup. The C++ Programming Language, 3rd Edition. Addison-Wesley, 1997

[�z�琨2003] �z�琨�?《如何在 linux 下检��内存泄漏�?/font>�Q�IBM developerWorks 中国�|�站�?

Sandy 2008-11-02 10:56 发表评论

Sandy — Sun, 02 Nov 2008 02:54:00 GMT

http://www.vczx.com/article/show.php?id=68

��内存泄漏：
��内存泄漏的关键是要能截获住对分配内存和释放内存的函数的调用。截获住�q�两个函敎ͼ�我们��p��跟踪每一块内存的生命周期�Q�比如，每当成功的分配一块内存后�Q�就把它的指针加入一个全局的list中；每当释放一块内存，再把它的指针从list中删除。这��P��当程序结束的时候，list中剩余的指针��是指向那些没有被释攄��内存。这里只是简单的描述了检��内存泄漏的基本原理�Q�详�l�的��法可以参见Steve Maguire�?lt;>�?
如果要检��堆内存的泄漏，那么需要截获住malloc/realloc/free和new/delete��可以了�Q�其实new/delete最�l�也是用malloc/free的，所以只要截获前面一�l�即可）。对于其他的泄漏�Q�可以采用类似的�Ҏ��Q�截获住相应的分配和释放函数。比如，要检��BSTR的泄漏，��需要截获SysAllocString/SysFreeString�Q�要��HMENU的泄漏，��需要截获CreateMenu/ DestroyMenu。（有的资源的分配函数有多个�Q�释攑և�数只有一个，比如�Q�SysAllocStringLen也可以用来分配BSTR�Q�这时就需要截获多个分配函敎ͼ�
在Windows�q�_��下，��内存泄漏的工具常用的一般有三种�Q�MS C-Runtime Library内徏的检��功能；外挂式的��工��P��诸如�Q�Purify�Q�BoundsChecker�{�；利用Windows NT自带的Performance Monitor。这三种工具各有优缺点，MS C-Runtime Library虽然功能上较之外挂式的工兯��弱，但是它是免费的；Performance Monitor虽然无法标示出发生问题的代码�Q�但是它能检��出隐式的内存泄漏的存在�Q�这是其他两�c�d��h��能�ؓ力的地方�?
以下我们详细讨论�q�三�U�检��工��P��
VC下内存泄漏的��方�?
用MFC开发的应用�E�序�Q�在DEBUG版模式下�~�译后，都会自动加入内存泄漏的检��代码。在�E�序�l�束后，如果发生了内存泄漏，在Debug�H�口中会昄��出所有发生泄漏的内存块的信息�Q�以下两行显�C�Z��一块被泄漏的内存块的信息：
E:\TestMemLeak\TestDlg.cpp(70)     : {59} normal block at 0x00881710, 200 bytes long.
Data:      61 62 63 64 65 66 67 68 69 6A 6B 6C 6D 6E 6F 70
�W�一行显�C��内存块由TestDlg.cpp文�g�Q�第70行代码分配，地址�?x00881710�Q�大��ؓ200字节�Q�{59}是指调用内存分配函数的Request Order�Q�关于它的详�l�信息可以参见MSDN中_CrtSetBreakAlloc()的帮助。第二行昄��该内存块�?6个字节的内容�Q�尖括号内是以ASCII方式昄��Q�接着的是�?6�q�制方式昄��?
一般大安��误以��些内存泄漏的��功能是由MFC提供的，其实不然。MFC只是��装和利用了MS C-Runtime Library的Debug Function。非MFC�E�序也可以利用MS C-Runtime Library的Debug Function加入内存泄漏的检��功能。MS C-Runtime Library在实现malloc/free�Q�strdup�{�函数时已经内徏了内存泄漏的��功能�?
注意观察一下由MFC Application Wizard生成的项目，在每一个cpp文�g的头部都有这样一�D�宏定义�Q?
#ifdef     _DEBUG
#define     new DEBUG_NEW
#undef     THIS_FILE
static     char THIS_FILE[] = __FILE__;
#endif
有了�q�样的定义，在编译DEBUG版时�Q�出现在�q�个cpp文�g中的所有new都被替换成DEBUG_NEW了。那么DEBUG_NEW是什么呢�Q�DEBUG_NEW也是一个宏�Q�以下摘自afx.h�Q?632�?
#define     DEBUG_NEW new(THIS_FILE, __LINE__)
所以如果有�q�样一行代码：
char*     p = new char[200];
�l�过宏替换就变成了：
char*     p = new( THIS_FILE, __LINE__)char[200];
�Ҏ��C++的标准，对于以上的new的��用方法，�~�译器会��L��q�样定义的operator new�Q?
void*     operator new(size_t, LPCSTR, int)
我们在afxmem.cpp 63行找��C��一个这��L��operator new 的实�?
void*     AFX_CDECL operator new(size_t nSize, LPCSTR lpszFileName, int nLine)
{
    return     ::operator new(nSize, _NORMAL_BLOCK, lpszFileName, nLine);
}
void*     __cdecl operator new(size_t nSize, int nType, LPCSTR lpszFileName, int     nLine)
{
    …
           pResult = _malloc_dbg(nSize, nType,     lpszFileName, nLine);
           if (pResult != NULL)
               return pResult;
    …
}
�W�二个operator new函数比较长，��Z��单期��_��我只摘录了部分。很昄��最后的内存分配�q�是通过_malloc_dbg函数实现的，�q�个函数属于MS C-Runtime Library 的Debug Function。这个函��C��但要求传入内存的大小�Q�另外还有文件名和行号两个参数。文件名和行号就是用来记录此�ơ分配是由哪一�D�代码造成的。如果这块内存在�E�序�l�束之前没有被释放，那么�q�些信息��׃��输出到Debug�H�口里�?
�q�里��Z��提一下THIS_FILE�Q�__FILE和__LINE__。__FILE__和__LINE__都是�~�译器定义的宏。当��到__FILE__�Ӟ��~�译器会把__FILE__替换成一个字�W�串�Q�这个字�W�串��是当前在编译的文�g的�\径名。当��到__LINE__�Ӟ��~�译器会把__LINE__替换成一个数字，�q�个数字��是当前�q�行代码的行受��在DEBUG_NEW的定义中没有直接使用__FILE__�Q�而是用了THIS_FILE�Q�其目的是�ؓ了减��目标文件的大小。假讑֜�某个cpp文�g中有100处��用了new�Q�如果直接��用__FILE__�Q�那�~�译器会产生100个常量字�W�串�Q�这100个字�W�串都是�q�个cpp文�g的�\径名�Q�显然十分冗余。如果��用THIS_FILE�Q�编译器只会产生一个常量字�W�串�Q�那100处new的调用��用的都是指向帔R��字符串的指针�?
再次观察一下由MFC Application Wizard生成的项目，我们会发现在cpp文�g中只对new做了映射�Q�如果你在程序中直接使用malloc函数分配内存�Q�调用malloc的文件名和行��h��不会被记录下来的。如果这块内存发生了泄漏�Q�MS C-Runtime Library仍然能检��到�Q�但是当输出�q�块内存块的信息�Q�不会包含分配它的的文�g名和行号�?
要在非MFC�E�序中打开内存泄漏的检��功能非常容易，你只要在�E�序的入口处加入以下几行代码�Q?
int     tmpFlag = _CrtSetDbgFlag( _CRTDBG_REPORT_FLAG );
tmpFlag     |= _CRTDBG_LEAK_CHECK_DF;
_CrtSetDbgFlag(     tmpFlag );
�q�样�Q�在�E�序�l�束的时候，也就是winmain�Q�main或dllmain函数�q�回之后�Q�如果还有内存块没有释放�Q�它们的信息会被打印到Debug�H�口里�?
如果你试着创徏了一个非MFC应用�E�序�Q�而且在程序的入口处加入了以上代码�Q��ƈ且故意在�E�序中不释放某些内存块，你会在Debug�H�口里看��C��下的信息�Q?
{47}     normal block at 0x00C91C90, 200 bytes long.
Data: <            > 00 01 02 03 04 05 06 07 08 09 0A 0B 0C 0D 0E 0F
内存泄漏的确��到了，但是和上面MFC�E�序的例子相比，�~�少了文件名和行受��对于一个比较大的程序，没有�q�些信息�Q�解决问题将变得十分困难�?
��Z��能够知道泄漏的内存块是在哪里分配的，你需要实现类似MFC的映��功能，把new�Q�maolloc�{�函数映��到_malloc_dbg函数上。这里我不再赘述�Q�你可以参考MFC的源代码�?
�׃��Debug Function实现在MS C-RuntimeLibrary中，所以它只能��到堆内存的泄漏�Q�而且只限于malloc�Q�realloc或strdup�{�分配的内存�Q�而那些系�l�资源，比如HANDLE�Q�GDI Object�Q�或是不通过C-Runtime Library分配的内存，比如VARIANT�Q�BSTR的泄漏，它是无法��到的，�q�是�q�种��法的一个重大的局限性。另外，��Z��能记录内存块是在哪里分配的，源代码必��ȝ��应的配合�Q�这在调试一些老的�E�序非常�ȝ��Q�毕竟修�Ҏ��代码不是一件省心的事，�q�是�q�种��法的另一个局限性�?
对于开发一个大型的�E�序�Q�MS C-Runtime Library提供的检��功能是�q�远不够的。接下来我们��q��看外挂式的检��工兗��我用的比较多的是BoundsChecker�Q�一则因为它的功能比较全面，更重要的是它的稳定性。这�c�d��具如果不�E�_��Q�反而会忙里��Mؕ。到底是��鼎鼎大名的NuMega�Q�我用下来基本上没有什么大问题�?

Sandy 2008-11-02 10:54 发表评论

转：内存泄露��?

Sandy — Sun, 02 Nov 2008 02:53:00 GMT

http://www.shnenglu.com/Ipedo/archive/2005/10/27/867.aspx

c�Q�＋中检��内存泄漏可以引入系�l�定义的宏来查看�Q�内存在哪个位置泄漏

文�g开始处加入下列定义
#define _CRTDBG_MAP_ALLOC
#include
#include

�E�序退出时加入以下函数�Q?br>
_CrtDumpMemoryLeaks();

如果有泄漏会昄��
e:\myproject\mltithrd.14\mltithrd.cpp(95) : {68} client block at 0x00372550, subtype c0, 144 bytes long.
a CMultiDocTemplate object at $00372550, 144 bytes long

Sandy 2008-11-02 10:53 发表评论

转：��内存泄露的工具�Q�debugnew

Sandy — Sun, 02 Nov 2008 02:52:00 GMT

��内存泄露的工具�Q�debugnew
http://dev.csdn.net/article/58/58407.shtm

�|�上有一个流传甚�q�的��内存泄露的工具�Q�debugnew(debugnew.h/debugnew.cpp)
用法很简单，把debugnew.cpp攑֜��目里一��L��译，需要检��的文�g把debugnew.h嵌在文�g的最前面�?br>
为方便��用，�Ҏ��代码做了一些小的改动�?br>
下面是一些简单的说明�Q?/p>

1、new 的重�?/font>
void* operator new (size_t size, const char* file, int line)�Q�　　　　　　　　�?br>void* operator new [] (size_t size, const char* file, int line)�Q�　　　　　　�?/p>

在需要检��的文�g里，重定义new
#define new new(__FILE__, __LINE__)

造成的结果：
ClassName *p = new ClassName; => ClassName *p = new(__FILE__, __LINE__) ClassName;
// 实际会调用void* operator new (size_t size, const char* file, int line)�Q?/p>

ClassName **pp = new classname[count]; => ClassName **pp = new(__FILE__, __LINE__) ClassName[count];
// 实际会调用void* operator new [] (size_t size, const char* file, int line)�Q?/p>

�q�其实是利用了placement new的语法，通过一个简单的宏，��可以把普通的new操作对应到相应的重蝲( �?�?)上去�?/p>

2、delete 的重�?/strong>
void operator delete (void* p, const char* file, int line); �?br>void operator delete [] (void* p, const char* file, int line); �?br>void operator delete (void* p); �?br>void operator delete [] (void* p); �?/p>

因�ؓ没有�c�M��于placement new的语法，所以就不能用一个宏来替换替换delete了。要调用带有更多信息的delete操作�W�，只能修改源代码了�?br>delete p; => delete ( p, __FILE__, __LINE__ );
delete []pp; => delete [] ( pp, __FILE__, __LINE__ );
但这个工作很烦琐�Q�如果�ƈ不需要多余的信息的话�Q�简单地重蝲delete( �?�?)��可以了�?/p>

3、检��和�l�计
�E�序开始时�Q�在debugnew.cpp中会创徏一个DebugNewTracer对象
在重载的new操作�W? �?�?)中，每一�ơ内存分配都会被记录�Q�而在delete( �?�?�?�?)中则会删除相应的记录�?br>当程序结束，DebugNewTracer对象被销毁，它的析构函数会dump剩余的记录，�q�就是泄露的内存了�?/p>

在原有代码的基础上，增加了记录size的功能，�q�样可以在每�ơnew和delete�Ӟ��看到实际占用的内存。所有信息可以dump出来�Q�也可以写入log�?br>

5、源代码

********************************************************
debugnew.h:

/*
filename: debugnew.h

This code is based on code retrieved from a web site. The
author was not identified, so thanks go to anonymous.

This is used to substitute a version of the new operator that
can be used for debugging memory leaks. To use it:

- In any (all?) code files #include debugnew.h. Make sure all
  system files (i.e. those in <>'s) are #included before
  debugnew.h, and that any header files for your own code
  are #included after debugnew.h. The reason is that some
  system files refer to ::new, and this will not compile
  if debugnew is in effect. You may still have problems
  if any of your own code refers to ::new, or if any
  of your own files #include system files that use ::new
  and which have not already been #included before
  debugnew.h.
- Add debugnew.cpp to the CodeWarrior project or compile
  it into your Linux executable. If debugnew.cpp is in the
  project, then debugnew.h must be #included in at least
  one source file
*/

#ifndef __DEBUGNEW_H__
#define __DEBUGNEW_H__

#include

#define LOG_FILE

#if defined(LOG_FILE)
#define LOG_FILE_NAME "./debugnew.log"
#endif

void* operator new (std::size_t size, const char* file, int line);
void operator delete (void* p, const char* name, int line);
void* operator new [] (std::size_t size, const char* file, int line);
void operator delete [] (void* p, const char* name, int line);

class DebugNewTracer {
private:

class Entry {
public:
  Entry (char const* file, int line) : _file (file), _line (line) {}
  Entry (char const* file, int line, int size) : _file (file), _line (line), _size (size) {}
  Entry () : _file (0), _line (0), _size (0) {}
  const char* File () const { return _file; }
  int Line () const { return _line; }
  size_t Size () const { return _size; }
private:
  char const* _file;
  int _line;
  size_t _size;
};

class Lock {
public:
  Lock (DebugNewTracer & DebugNewTracer) : _DebugNewTracer (DebugNewTracer) {
   _DebugNewTracer.lock ();
  }
  ~Lock () {
   _DebugNewTracer.unlock ();
  }
private:
  DebugNewTracer & _DebugNewTracer;
};
typedef std::map::iterator iterator;
friend class Lock;
public:
DebugNewTracer ();
~DebugNewTracer ();
void Add (void* p, const char* file, int line);
void Add (void* p, const char* file, int line, size_t size);
void Remove (void* p);
void Dump ();

static bool Ready;

private:
void lock () { _lockCount++; }
void unlock () { _lockCount--; }

private:

std::map _map;
int _lockCount;
size_t _totalsize;
#if defined(LOG_FILE)
FILE* _logfp;
#endif
};

// The file that implements class DebugNewTracer
// does NOT want the word "new" expanded.
// The object DebugNewTrace is defined in that
// implementation file but only declared in any other file.
#ifdef DEBUGNEW_CPP
DebugNewTracer DebugNewTrace;
#else
#define new new(__FILE__, __LINE__)
extern DebugNewTracer DebugNewTrace;
#endif

#endif//#ifndef __DEBUGNEW_H__

********************************************************
debugnew.cpp:

/*
filename: debugnew.cpp

This is used to substitute a version of the new operator that
can be used for debugging memory leaks. In any (all?) code
files #include debugnew.h. Add debugnew.cpp to the project.
*/

#include
#include

using namespace std;

// This disables macro expansion of "new".
// This statement should only appear in this file.
#define DEBUGNEW_CPP

#include "debugnew.h"

DebugNewTracer::DebugNewTracer () : _lockCount (0)
{
  // Once this object is constructed all calls to
  // new should be traced.

Ready = true;
_totalsize = 0;
#if defined(LOG_FILE)
if( (_logfp=fopen(LOG_FILE_NAME,"wt")) == NULL )
{
  printf(" Error! file: debugnew.log can not open@!\n");
  return;
}
fprintf(_logfp,"new, delete list:\n");
fflush(_logfp);
#endif

}

void DebugNewTracer::Add (void* p, const char* file, int line)
{
  // Tracing must not be done a second time
  // while it is already
  // in the middle of executing
if (_lockCount > 0)
  return;

   // Tracing must be disabled while the map
   // is in use in case it calls new.
DebugNewTracer::Lock lock (*this);
_map [p] = Entry (file, line);
}

void DebugNewTracer::Add (void* p, const char* file, int line, size_t size)
{
// Tracing must not be done a second time
// while it is already
// in the middle of executing
if (_lockCount > 0)
  return;

  // Tracing must be disabled while the map
  // is in use in case it calls new.
DebugNewTracer::Lock lock (*this);
#if 1
//´ÓÈ«Â·¾¶ÖÐÌáÈ¡ÎÄ¼þÃû
//linuxÏÂµÄgcc,__FILE__½ö½ö°üÀ¨ÎÄ¼þÃû£¬windowsÏÂµÄvc,__FILE__°üÀ¨È«Â·¾¶,ËùÒÔÓÐÕâÑùµÄ´¦Àí
file = strrchr(file,'\\')== NULL?file:strrchr(file,'\\')+1;
#endif
_map [p] = Entry (file, line, size);
_totalsize += size;
#if defined(LOG_FILE)
fprintf(_logfp,"*N p = 0x%08x, size = %6d, %-22s, Line: %4d. totalsize =%8d\n", p, size, file, line, _totalsize);
fflush(_logfp);
#endif
}

void DebugNewTracer::Remove (void* p)
{
// Tracing must not be done a second time
// while it is already
// in the middle of executing
if (_lockCount > 0)
  return;

  // Tracing must be disabled while the map
  // is in use in case it calls new.
DebugNewTracer::Lock lock (*this);

iterator it = _map.find (p);

if (it != _map.end ())
{
  size_t size = (*it).second.Size();
  _totalsize -= size;
#if defined(LOG_FILE)
  fprintf(_logfp,"#D p = 0x%08x, size = %6u.%39stotalsize =%8d\n", p, size, "----------------------------------- ", _totalsize );
  fflush(_logfp);
#endif
  _map.erase (it);
}
else
{
#if defined(LOG_FILE)
  fprintf(_logfp,"#D p = 0x%08x. error point!!!\n", p );
  fflush(_logfp);
#endif
}
}

DebugNewTracer::~DebugNewTracer ()
{
// Trace must not be called if Dump indirectly
// invokes new, so it must be disabled before
// Dump is called. After this destructor executes
// any other global objects that get destructed
// should not do any tracing.
Ready = false;
Dump ();
#if defined(LOG_FILE)
fclose(_logfp);
#endif
}

// If some global object is destructed after DebugNewTracer
// and if that object calls new, it should not trace that
// call to new.
void DebugNewTracer::Dump ()
{
if (_map.size () != 0)
{
  std::cout << _map.size () << " memory leaks detected\n";
#if defined(LOG_FILE)
  fprintf(_logfp, "\n\n***%d memory leaks detected\n", _map.size ());
  fflush(_logfp);
#endif
  for (iterator it = _map.begin (); it != _map.end (); ++it)
  {
   char const * file = it->second.File ();
   int line = it->second.Line ();
   int size = it->second.Size ();
   std::cout << file << ", " << line << std::endl;
#if defined(LOG_FILE)
   fprintf(_logfp,"%s, %d, size=%d\n", file, line, size);
   fflush(_logfp);
#endif
  }
}
else
{
  std::cout << "no leaks detected\n";
#if defined(LOG_FILE)
  fprintf(_logfp,"no leaks detected\n");
  fflush(_logfp);
#endif
}

}

// If some global object is constructed before DebugNewTracer
// and if that object calls new, it should not trace that
// call to new.
bool DebugNewTracer::Ready = false;

void* operator new (size_t size, const char* file, int line)
{
void * p = malloc (size);
if (DebugNewTracer::Ready)
  DebugNewTrace.Add (p, file, line, size);
return p;
}

void operator delete (void* p, const char* file, int line)
{
file = 0; // avoid a warning about argument not used in function
line = 0; // avoid a warning about argument not used in function

if (DebugNewTracer::Ready)
  DebugNewTrace.Remove (p);
free (p);
}

void* operator new [] (size_t size, const char* file, int line)
{
void * p = malloc (size);
if (DebugNewTracer::Ready)
  DebugNewTrace.Add (p, file, line, size);
return p;
}

void operator delete [] (void* p, const char* file, int line)
{
file = 0; // avoid a warning about argument not used in function
line = 0; // avoid a warning about argument not used in function

if (DebugNewTracer::Ready)
   DebugNewTrace.Remove (p);
free (p);
}

void* operator new (size_t size)
{
void * p = malloc (size);
// When uncommented these lines cause entries in the map for calls to new
// that were not altered to the debugnew version. These are likely calls
// in library functions and the presence in the dump of these entries
// is usually misleading.
// if (DebugNewTracer::Ready)
//   DebugNewTrace.Add (p, "?", 0);
return p;
}

void operator delete (void* p)
{
if (DebugNewTracer::Ready)
  DebugNewTrace.Remove (p);
free (p);
}

//add by yugang
void operator delete [] (void* p)
{
if (DebugNewTracer::Ready)
  DebugNewTrace.Remove (p);
free (p);
}

Sandy 2008-11-02 10:52 发表评论

虚��承与虚基�cȝ��本质

Sandy — Thu, 16 Oct 2008 14:19:00 GMT
                  虚��承与虚基�cȝ��本质
    虚��承和虚基�cȝ��定义是非常的��单的�Q�同时也是非常容易判断一个��承是否是虚��?br>的，虽然�q�两个概�늚�定义是非常的��单明��的�Q�但是在C++语言中虚�l�承作�ؓ一个比较生
�ȝ��但是又是�l�对必要的组成部份而存在着�Q��ƈ且其行�ؓ和模型均表现出和一般的�l�承体系
之间的巨大的差异�Q�包括访问性能上的差异�Q�，现在我们��来��d��的从语言、模型、性能�?br>应用�{�多个方面对虚��承和虚基�c�进行研�I��?br>    首先�q�是先给��l�承和虚基类的定义�?br>    虚��承：在��承定义中包含了virtual关键字的�l�承关系�Q?br>    虚基�c�：在虚�l�承体系中的通过virtual�l�承而来的基�c�，需要注意的是：
            struct CSubClass : public virtual CBase {}; 其中CBase�U�C��为CSubClass
            的虚基类�Q�而不是说CBase��是个虚基类�Q�因为CBase�q�可以不不是虚��承体�p?br>            中的基类�?br>    有了上面的定义后�Q�就可以开始虚�l�承和虚基类的本质研�I�了�Q�下面按照语法、语义�?br>模型、性能和应用五个方面进行全面的描述�?br>
    1. 语法
       语法有语�a�的本�w�的定义所军_��Q��M��上来说非常的��单，如下�Q?br>           struct CSubClass : public virtual CBaseClass {};
       其中可以采用public、protected、private三种不同的��承关键字�q�行修饰�Q�只�?br>       ��保包含virtual��可以了�Q�这样一来就形成了虚�l�承体系�Q�同时CBaseClass��成�?br>       了CSubClass的虚基类了�?br>       其实�q�没有那么的��单，如果出现虚��承体�pȝ��q�一步��承会出现什么样的状况呢�Q?br>       如下所�C�：
            /*
             * 带有数据成员的基�c?br>             */
            struct CBaseClass1
            {
                CBaseClass1( size_t i ) : m_val( i ) {}

                size_t m_val;
            };
            /*
             * 虚拟�l�承体系
             */
            struct CSubClassV1 : public virtual CBaseClass1
            {
                CSubClassV1( size_t i ) : CBaseClass1( i ) {}
            };
            struct CSubClassV2 : public virtual CBaseClass1
            {
                CSubClassV2( size_t i ) : CBaseClass1( i ) {}
            };
            struct CDiamondClass1 : public CSubClassV1, public CSubClassV2
            {
                CDiamondClass1( size_t i ) : CBaseClass1( i ), CSubClassV1( i ), CSubClassV2( i ) {}
            };
            struct CDiamondSubClass1 : public CDiamondClass1
            {
                CDiamondSubClass1( size_t i ) : CBaseClass1( i ), CDiamondClass1( i ) {}
            };
       注意上面代码中的CDiamondClass1和CDiamondSubClass1两个�cȝ��构造函数初始化�?br>       表中的内宏V��可以发现其中均包含了虚基类CBaseClass1的初始化工作�Q�如果没有这
       个初始化语句��׃��D��~�译旉��误，��Z��么会�q�样呢？一般情况下不是只要�?br>       CSubClassV1和CSubClassV2中包含初始化��可以了么？要解释该问题必须要明白虚
       �l�承的语义特征，所以参看下面语义部分的解释�?br>
    2. 语义
       从语义上来讲什么是虚��承和虚基�c�d��Q�上面仅仅是从如何在C++语言中书写合法的
       虚��承类定义而已。首先来了解一下virtual�q�个关键字在C++中的公共含义�Q�在C++
       语言中仅仅有两个地方可以使用virtual�q�个关键字，一个就是类成员虚函数和�q�里
       所讨论的虚�l�承。不要看�q�两�U�应用场合好像没什么关�p�，其实他们在背景语义上
       ��h��virtual�q�个词所代表的共同的含义�Q�所以才会在�q�两�U�场合��用相同的关键字�?br>       那么virtual�q�个词的含义是什么呢�Q?br>       virtual在《美国传�l�词典[双解]》中是这样定义的�Q?br>           adj.�Q��Ş容词�Q?br>           1. Existing or resulting in essence or effect though not in actual
              fact, form, or name:
              实质上的�Q�实际上的：虽然没有实际的事实、�Ş式或名义�Q�但在实际上或效
              果上存在或��生的�Q?br>           2. Existing in the mind, especially as a product of the imagination.
              Used in literary criticism of text.
              虚的�Q�内心的�Q�在头脑中存在的�Q�尤指意想的产物。用于文学批评中�?br>       我们采用�W�一个定义，也就是说被virtual所修饰的事物或现象在本质上是存在的�Q?br>       但是没有直观的�Ş式表玎ͼ�无法直接描述或定义，需要通过其他的间接方式或手段
       才能够体现出其实际上的效果�?br>       那么在C++中就是采用了�q�个词意�Q�不可以在语�a�模型中直接调用或体现的，但是��?br>       实是存在可以被间接的方式�q�行调用或体现的。比如：虚函数必��要通过一�U�间接的
       �q�行�Ӟ��而不是编译时�Q�机制才能够�Ȁ�z�（调用�Q�的函数�Q�而虚�l�承也是必须在运�?br>       时才能够�q�行定位讉K��的一�U�体制。存在，但间接。其中关键就在于存在、间接和�?br>       享这三种特征�?br>       对于虚函数而言�Q�这三个特征是很好理解的�Q�间接性表明了他必��d��q�行时根据实�?br>       的对象来完成函数��d��Q�共享性表象在基类会共享被子类重蝲后的虚函敎ͼ�其实指向
       相同的函数入口�?br>       对于虚��承而言�Q�这三个特征如何理解呢？存在卌��C��l�承体系和虚基类��实存在�Q?br>       间接性表明了在访问虚基类的成员时同样也必��通过某种间接机制来完成（下面模型
       中会讲到�Q�，�׃�n性表象在虚基�c�M��在虚�l�承体系中被�׃�n�Q�而不会出现多份拷贝�?br>       那现在可以解释语法小节中留下来的那个问题了，“��Z��么一旦出��C��虚基�c�，��必
       ��d��没有一个��承类中都必须包含虚基�cȝ��初始化语�?#8221;。由上面的分析可以知道，
       虚基�c�L��被共享的�Q�也��是在��承体�p�M��无论被��承多��次�Q�对象内存模型中均只�?br>       出现一个虚基类的子对象�Q�这和多�l�承是完全不同的�Q�，�q�样一来既然是�׃�n的那�?br>       每一个子�c�都不会独占�Q�但是总还是必��要有一个类来完成基�cȝ��初始化过�E�（因�ؓ
       所有的对象都必��被初始化，哪怕是默认的）�Q�同时还不能够重复进行初始化�Q�那�?br>       底谁应该负责完成初始化呢�Q�C++标准中（也是很自然的�Q�选择在每一�ơ��承子�c�M��
       都必��M��写初始化语句�Q�因为每一�ơ��承子�c�d��能都会用来定义对象）�Q�而在最下层
       �l�承子类中实际执行初始化�q�程。所以上面在每一个��承类中都要书写初始化语句�Q?br>       但是在创建对象时�Q�而仅仅会在创建对象用的类构造函��C��实际的执行初始化语句�Q?br>       其他的初始化语句都会被压制不调用�?br>
    3. 模型
       ��Z��实现上面所说的三种语义含义�Q�在考虑对象的实现模型（也就是内存模型）时就
       很自然了。在C++中对象实际上��是一个连�l�的地址�I�间的语义代表，我们来分析虚
       �l�承下的内存模型�?br>       3.1. 存在
           也就是说在对象内存中必须要包含虚基类的完整子对象�Q�以便能够完成通过地址
           完成对象的标识。那么至于虚基类的子对象会存攑֜�对象的那个位�|�（头、中间�?br>           ��N��Q�则由各个编译器选择�Q�没有差别。（在VC8中无��基类被声明在什么位�|�，
           虚基�cȝ��子对象都会被攄��在对象内存的��N��Q?br>       3.2. 间接
           间接性表明了在直接虚基承子类中一定包含了某种指针�Q�偏�U�L��表格�Q�来完成�?br>           �q�子�c�访问虚基类子对象（或成员）的间接手�D�（因�ؓ虚基�c�d��对象是共享的�Q?br>           没有��定关系�Q�，至于采用何种手段��q��译器选择。（在VC8中在子类中放�|�了
           一个虚基类指针vbc�Q�该指针指向虚函数表中的一个slot�Q�该slot中存攑ֈ�虚基
           �c�d��对象的偏�U�量的负��|��实际上就是个以补码表�C�的int�c�d��的��|��在计��虚
           基类子对象首地址�Ӟ��需要将该偏�U�量取绝对值相加，�q�个主要是�ؓ了和虚表
           中只能存放虚函数地址�q�一要求相区别，因�ؓ地址是原码表�C�的无符号int�c�d��
           的��|��
       3.3. �׃�n
           �׃�n表明了在对象的内存空间中仅仅能够包含一份虚基类的子对象�Q��ƈ且通过
           某种间接的机制来完成�׃�n的引用关�p�R��在介绍完整个内容后会附上测试代码，
           体现�q�些内容�?br>    4. 性能
       �׃��有了间接性和�׃�n性两个特征，所以决定了虚��承体�p�M��的对象在讉K��时必�?br>       会在旉��和空间上与一般情冉|��较大不同�?br>       4.1. 旉��
           在通过�l�承�c�d��象访问虚基类对象中的成员�Q�包括数据成员和函数成员�Q�时�Q�都
           必须通过某种间接引用来完成，�q�样会增加引用寻址旉��Q�就和虚函数一��P��Q?br>           其实��是调整this指针以指向虚基类对象�Q�只不过�q�个调整是运行时间接完成的�?br>           �Q�在VC8中通过打开汇编输出�Q�可以查�?.cod文�g中的内容�Q�在讉K��虚基�c�d��?br>           成员时会形成三条mov间接��d��语句�Q�而在讉K��一般��承类对象时仅仅只有一条mov
           帔R��直接��d��语句�Q?br>       4.2. �I�间
           �׃��׃�n所以不同在对象内存中保存多份虚基类子对象的拯��Q�这栯��之多�l�承
           节省�I�间�?br>    5. 应用
       谈了那么多语�a��Ҏ��和内容�Q�那么在什么情况下需要��用虚�l�承�Q�而一般应该如何��
       用呢�Q?br>       �q�个问题其实很难有答案，一般情况下如果你确性出现多�l�承没有必要�Q�必��要�׃�n
       基类子对象的时候可以考虑采用虚��承关�p�（C++标准ios体系��是�q�样的）。由于每
       一个��承类都必��d��含初始化语句而又仅仅只在最底层子类中调用，�q�样可能��׃��?br>       得某些上层子�c�d��到的虚基�c�d��对象的状态不是自己所期望的（因�ؓ自己的初始化�?br>       句被压制了）�Q�所以一般徏议不要在虚基�c�M��包含��M��数据成员�Q�不要有状态）�Q�只
       可以作�ؓ接口�c�L��提供�?br>
附录�Q�测试代�?br>#include
#include

/*
* 带有数据成员的基�c?br> */
struct CBaseClass1
{
    CBaseClass1( size_t i ) : m_val( i ) {}

    size_t m_val;
};
/*
* 虚拟�l�承体系
*/
struct CSubClassV1 : public virtual CBaseClass1
{
    CSubClassV1( size_t i ) : CBaseClass1( i ) {}
};

struct CSubClassV2 : public virtual CBaseClass1
{
    CSubClassV2( size_t i ) : CBaseClass1( i ) {}
};

struct CDiamondClass1 : public CSubClassV1, public CSubClassV2
{
    CDiamondClass1( size_t i ) : CBaseClass1( i ), CSubClassV1( i ), CSubClassV2( i ) {}
};

struct CDiamondSubClass1 : public CDiamondClass1
{
    CDiamondSubClass1( size_t i ) : CBaseClass1( i ), CDiamondClass1( i ) {}
};
/*
* 正常�l�承体系
*/
struct CSubClassN1 : public CBaseClass1
{
    CSubClassN1( size_t i ) : CBaseClass1( i ) {}
};
struct CSubClassN2 : public CBaseClass1
{
    CSubClassN2( size_t i ) : CBaseClass1( i ) {}
};
struct CMultiClass1 : public CSubClassN1, public CSubClassN2
{
    CMultiClass1( size_t i ) : CSubClassN1( i ), CSubClassN2( i ) {}
};
struct CMultiSubClass1 : public CMultiClass1
{
    CMultiSubClass1( size_t i ) : CMultiClass1( i ) {}
};
/*
* 不带有数据成员的接口基类
*/
struct CBaseClass2
{
    virtual void func() {};
    virtual ~CBaseClass2() {}
};
/*
* 虚拟�l�承体系
*/
// struct CBaseClassX { CBaseClassX() {i1 = i2 = 0xFFFFFFFF;} size_t i1, i2;};
struct CSubClassV3 : public virtual CBaseClass2
{
};
struct CSubClassV4 : public virtual CBaseClass2
{
};
struct CDiamondClass2 : public CSubClassV3, public CSubClassV4
{
};
struct CDiamondSubClass2 : public CDiamondClass2
{
};

/*
* 正常�l�承体系
*/
struct CSubClassN3 : public CBaseClass2
{
};
struct CSubClassN4 : public CBaseClass2
{
};
struct CMultiClass2 : public CSubClassN3, public CSubClassN4
{
};
struct CMultiSubClass2 : public CMultiClass2
{
};

/*
* 内存布局用类声明.
*/
struct CLayoutBase1
{
    CLayoutBase1() : m_val1( 0 ), m_val2( 1 ) {}

    size_t m_val1, m_val2;
};
struct CLayoutBase2
{
    CLayoutBase2() : m_val1( 3 ) {}

    size_t m_val1;
};
struct CLayoutSubClass1 : public virtual CBaseClass1, public CLayoutBase1, public CLayoutBase2
{
    CLayoutSubClass1() : CBaseClass1( 2 ) {}
};

#define MAX_TEST_COUNT 1000 * 1000 * 16
#define TIME_ELAPSE() ( std::clock() - start * 1.0 ) / CLOCKS_PER_SEC

int main( int argc, char *argv[] )
{
    /*
     * �c�M��p�M��的尺�?
     */
    std::cout << "================================ sizeof ================================" << std::endl;
    std::cout << "    ----------------------------------------------------------------" << std::endl;
    std::cout << "sizeof( CBaseClass1 )       = " << sizeof( CBaseClass1 ) << std::endl;
    std::cout << std::endl;
    std::cout << "sizeof( CSubClassV1 )       = " << sizeof( CSubClassV1 ) << std::endl;
    std::cout << "sizeof( CSubClassV2 )       = " << sizeof( CSubClassV2 ) << std::endl;
    std::cout << "sizeof( CDiamondClass1 )    = " << sizeof( CDiamondClass1 ) << std::endl;
    std::cout << "sizeof( CDiamondSubClass1 ) = " << sizeof( CDiamondSubClass1 ) << std::endl;
    std::cout << std::endl;
    std::cout << "sizeof( CSubClassN1 )       = " << sizeof( CSubClassN1 ) << std::endl;
    std::cout << "sizeof( CSubClassN2 )       = " << sizeof( CSubClassN2 ) << std::endl;
    std::cout << "sizeof( CMultiClass1 )      = " << sizeof( CMultiClass1 ) << std::endl;
    std::cout << "sizeof( CMultiSubClass1 )   = " << sizeof( CMultiSubClass1 ) << std::endl;

    std::cout << "    ----------------------------------------------------------------" << std::endl;
    std::cout << "sizeof( CBaseClass2 )       = " << sizeof( CBaseClass2 ) << std::endl;
    std::cout << std::endl;
    std::cout << "sizeof( CSubClassV3 )       = " << sizeof( CSubClassV3 ) << std::endl;
    std::cout << "sizeof( CSubClassV4 )       = " << sizeof( CSubClassV4 ) << std::endl;
    std::cout << "sizeof( CDiamondClass2 )    = " << sizeof( CDiamondClass2 ) << std::endl;
    std::cout << "sizeof( CDiamondSubClass2 ) = " << sizeof( CDiamondSubClass2 ) << std::endl;
    std::cout << std::endl;
    std::cout << "sizeof( CSubClassN3 )       = " << sizeof( CSubClassN3 ) << std::endl;
    std::cout << "sizeof( CSubClassN4 )       = " << sizeof( CSubClassN4 ) << std::endl;
    std::cout << "sizeof( CMultiClass2 )      = " << sizeof( CMultiClass2 ) << std::endl;
    std::cout << "sizeof( CMultiSubClass2 )   = " << sizeof( CMultiSubClass2 ) << std::endl;
    /*
     * 对象内存布局
     */
    std::cout << "================================ layout ================================" << std::endl;
    std::cout << "    --------------------------------MI------------------------------" << std::endl;
    CLayoutSubClass1 *lsc = new CLayoutSubClass1;
    std::cout << "sizeof( CLayoutSubClass1 )   = " << sizeof( CLayoutSubClass1 ) << std::endl;
    std::cout << "CLayoutBase1 offset of CLayoutSubClass1 is " << (char*)(CLayoutBase1 *)lsc - (char*)lsc << std::endl;
    std::cout << "CBaseClass1 offset of CLayoutSubClass1 is " << (char*)(CBaseClass1 *)lsc - (char*)lsc << std::endl;
    std::cout << "CLayoutBase2 offset of CLayoutSubClass1 is " << (char*)(CLayoutBase2 *)lsc - (char*)lsc << std::endl;

    int *ptr = (int*)lsc;
    std::cout << "vbc in CLayoutSubClass1 is " << *(int*)ptr[3] << std::endl;

    delete lsc;

    std::cout << "    --------------------------------SI------------------------------" << std::endl;
    CSubClassV1 *scv1 = new CSubClassV1( 1 );
    std::cout << "sizeof( CSubClassV1 )   = " << sizeof( CSubClassV1 ) << std::endl;
    std::cout << "CBaseClass1 offset of CSubClassV1 is " << (char*)(CBaseClass1 *)scv1 - (char*)scv1 << std::endl;

    ptr = (int*)scv1;
    std::cout << "vbc in CSubClassV1 is " << *(int*)ptr[0] << std::endl;

    delete scv1;

    /*
     * 性能��试
     */
    std::cout << "================================ Performance ================================" << std::endl;
    double times[4];
    size_t idx = 0;

    CSubClassV1 *ptr1 = new CDiamondClass1( 1 );
    std::clock_t start = std::clock();
    {
        for ( size_t i = 0; i < MAX_TEST_COUNT; ++i )
            ptr1->m_val = i;
    }
    times[idx++] = TIME_ELAPSE();
    delete static_cast( ptr1 );

    CSubClassN1 *ptr2 = new CMultiClass1( 0 );
    start = std::clock();
    {
        for ( size_t i = 0; i < MAX_TEST_COUNT; ++i )
            ptr2->m_val = i;
    }
    times[idx++] = TIME_ELAPSE();
    delete static_cast( ptr2 );

    std::cout << "CSubClassV1::ptr1->m_val " << times[0] << " s" << std::endl;
    std::cout << "CSubClassN1::ptr2->m_val " << times[1] << " s" << std::endl;

    return 0;
}

��试环境�Q?br>    软�g环境�Q�Visual Studio2005 Pro + SP1, boost1.34.0
    ��g环境�Q�PentiumD 3.0GHz, 4G RAM
��试数据�Q?br>================================ sizeof ================================
    ----------------------------------------------------------------
sizeof( CBaseClass1 )       = 4

sizeof( CSubClassV1 )       = 8
sizeof( CSubClassV2 )       = 8
sizeof( CDiamondClass1 )    = 12
sizeof( CDiamondSubClass1 ) = 12

sizeof( CSubClassN1 )       = 4
sizeof( CSubClassN2 )       = 4
sizeof( CMultiClass1 )      = 8
sizeof( CMultiSubClass1 )   = 8
    ----------------------------------------------------------------
sizeof( CBaseClass2 )       = 4

sizeof( CSubClassV3 )       = 8
sizeof( CSubClassV4 )       = 8
sizeof( CDiamondClass2 )    = 12
sizeof( CDiamondSubClass2 ) = 12

sizeof( CSubClassN3 )       = 4
sizeof( CSubClassN4 )       = 4
sizeof( CMultiClass2 )      = 8
sizeof( CMultiSubClass2 )   = 8
================================ layout ================================
    --------------------------------MI------------------------------
sizeof( CLayoutSubClass1 )   = 20
CLayoutBase1 offset of CLayoutSubClass1 is 0
CBaseClass1 offset of CLayoutSubClass1 is 16
CLayoutBase2 offset of CLayoutSubClass1 is 8
vbc in CLayoutSubClass1 is -12
    --------------------------------SI------------------------------
sizeof( CSubClassV1 )   = 8
CBaseClass1 offset of CSubClassV1 is 4
vbc in CSubClassV1 is 0
================================ Performance ================================
CSubClassV1::ptr1->m_val 0.062 s
CSubClassN1::ptr2->m_val 0.016 s

�l�果分析�Q?br>    1. �׃��虚��承引入的间接性指针所以导致了虚��承类的尺�怼�增加4个字节；
    2. 由Layout输出可以看出�Q�虚基类子对象被攑֜�了对象的��N��Q�偏�U�Mؓ16�Q�，�q�且vbc
       指针必须紧紧的接在虚基类子对象的前面�Q�所以vbc指针所指向的内容�ؓ“偏移 - 4”�Q?br>    3. �׃��VC8��偏�U�L��在了虚函数表中，所以�ؓ了区分函数地址和偏�U�，所以偏�U�L��用补
       码int表示的负��|��
    4. 间接性可以通过性能来看出，在虚�l�承体系同通过指针讉K��成员时的旉��一般是一�?br>       �c�访问情况下�?倍左叻I��W�合汇编语言输出文�g中的汇编语句的安排�?

Sandy 2008-10-16 22:19 发表评论

虚拟�l�承入门

Sandy — Thu, 16 Oct 2008 13:48:00 GMT
在园里�{�Q�看到好文章�Q�摘抄过来�?br>链接�Q?a href="http://www.shnenglu.com/franksunny/archive/2008/10/16/64168.html">
http://www.shnenglu.com/franksunny/archive/2008/10/16/64168.html

原文�Q?br>
��Z��么要引入虚拟�l�承�Q?/span>

虚拟�l�承在一般的应用中很��用刎ͼ�所以也往往被忽视，�q�也主要是因为在C++中，多重�l�承是不推荐的，也�ƈ不常用，而一旦离开了多重��承，虚拟�l�承��完全失��M��存在的必要（因�ؓ�q�样只会降低效率和占用更多的�I�间�Q�关于这一点，我自��p��没有太多深刻的理解，有兴��的可以看网�l�上白杨的作�?/span>�?/span>RTTI、虚函数和虚�?span>�cȝ��开销分析及��用指�?span>�?/span>�Q�说实话我目前还没看得很明白�Q�高人可以指点下我）�?/span>

以下面的一个例子�ؓ例：

#include

#include

class CA

{

    int k; //如果基类没有数据成员�Q�则在这里多重��承编译不会出��C��义�?/span>

public:

    void f() {cout << "CA::f" << endl;}

};

class CB : public CA

{

};

class CC : public CA

{

};

class CD : public CB, public CC

{

};

void main()

{

    CD d;

    d.f();

}

当编译上�q�C��码时�Q�我们会收到如下的错误提�C�：

error C2385: 'CD::f' is ambiguous

即编译器无法��定你在d.f()中要调用的函�?/span>f到底是哪一个。这里可能会让�h觉得有些奇怪，命名只定义了一�?/span>CA::f�Q�既然大安��z��?/span>CA�Q�那自然��是调用�?/span>CA::f�Q��ؓ什么还无法��定呢？

�q�是因�ؓ�~�译器在�q�行�~�译的时候，需要确定子�cȝ��函数定义�Q�如CA::f是确定的�Q�那么在�~�译CB�?/span>CC时还需要在�~�译器的语法树中生成CB::f�Q?/span>CC::f�{�标识，那么�Q�在�~�译CD的时候，�׃��CB�?/span>CC都有一个函�?/span>f�Q�此�Ӟ��~�译器将试图生成�q�两�?/span>CD::f标识�Q�显然这时就要报错了。（当我们不使用CD::f的时候，以上标识都不会生成，所以，如果��L��d.f()一句，�E�序��顺利通过�~�译�Q?/span>

要解册��个问题，有两个方法：

1、重载函�?/span>f()�Q�此时由于我们明��定义了CD::f�Q�编译器��查到CD::f()调用时就无需再像上面一样去逐��生成CD::f标识了；

此时CD的元素结构如下：

|CB(CA)|

|CC(CA)|

故此时的sizeof(CD) = 8;�Q?/span>CB�?/span>CC各有一个元�?/span>k�Q?/span>

2、��用虚拟��承：虚拟�l�承又称作共享��承，�q�种�׃�n其实也是�~�译期间实现的，当��用虚拟��承时�Q�上面的�E�序��变成下面的形式�Q?/span>

#include

#include

class CA

{

    int k;

public:

    void f() {cout << "CA::f" << endl;}

};

class CB : virtual public CA //也有一�U�写法是class CB : public virtual CA

{                       //实际上这两种�Ҏ��都可�?/span>

};

class CC : virtual public CA

{

};

class CD : public CB, public CC

{

};

void main()

{

    CD d;

    d.f();

}

此时�Q�当�~�译器确�?/span>d.f()调用的具体含义时�Q�将生成如下�?/span>CD�l�构�Q?/span>

|CB|

|CC|

|CA|

同时�Q�在CB�?/span>CC中都分别包含了一个指�?/span>CA的虚基类指针列表vbptr�Q?/span>virtual base table pointer�Q�，其中记录的是�?/span>CB�?/span>CC的元素到CA的元素之间的偏移量。此�Ӟ��不会生成各子�cȝ��函数f标识�Q�除非子�c�重载了该函敎ͼ�从而达�?#8220;�׃�n”的目的（�q�里的具体内存布局�Q�可以参看钻矛_��l�承内存布局�Q�在白杨的那��文章中也有�Q��?/span>

也正因此�Q�此时的sizeof(CD) = 12�Q�两�?/span>vbptr + sizoef(int)�Q?/span>;

另注�Q?/span>

如果CB�Q?/span>CC中各定义一�?/span>int型变量，�?/span>sizeof(CD)��变�?/span>20(两个vbptr + 3�?/span>sizoef(int)

如果CA中添加一�?/span>virtual void f1(){}�Q?/span>sizeof(CD) = 16�Q�两�?/span>vbptr + sizoef(int)+vptr�Q?/span>;

再添�?/span>virtual void f2(){}�Q?/span>sizeof(CD) = 16不变。原因如下所�C�：带有虚函数的�c�，其内存布局上包含一个指向虚函数列表的指针（vptr�Q�，�q�跟有几个虚函数无关�?/span>

以上内容涉及到类对象内存布局问题�Q�本��难以做过多展开�Q�先贴这么多�Q�本��文章只是考虑对于虚拟�l�承�q�行入门�Q�至于效率、应用等未作展开。本文在�|�上文章基础上修改了下而得此篇�Q�原文蝲�?/span>http://blog.csdn.net/billdavid/archive/2004/06/23/24317.aspx

另外关于虚��承和虚基�cȝ��讨论�Q�博客园有篇文章�?/span>虚��承与虚基�cȝ��本质》，�ȝ��得更��l�一炏V�?/span>

Sandy 2008-10-16 21:48 发表评论

亚洲精品中文字幕在线,国产精品国产三级国产aⅴ浪潮,在线观看一区二区精品视频

转：位运���符的一些简单应�?

�? C++ 虚函数表解析

�? C++ 对象的内存布局(�?

�? C++ 对象的内存布局(�?

�? c++ notes

�?使用__FILE__和__LINE__定位错误

�? fopen打开文�g方式

fopen打开文�g方式

C++�c�d��转换�W�的使用

转：使应用程序只能运行一个实�?

转：深入���出Win32多线�E�设计之MFC的多�U�程(作者：宋宝�?

深入���出Win32多线�E�设计之MFC的多�U�程(作者：宋宝�?

转：Windows多线�E�多��d��设计初步

转：一个跨�q�_���?C++ 内存泄漏������器

转：内存泄露�����?

转：������内存泄露的工具�Q�debugnew

虚��承与虚基�cȝ��本质

虚拟�l�承入门

转：位运��符的一些简单应�?

�?使用FILE和LINE定位错误

转：深入��出Win32多线�E�设计之MFC的多�U�程(作者：宋宝�?

深入��出Win32多线�E�设计之MFC的多�U�程(作者：宋宝�?

转：一个跨�q�_��?C++ 内存泄漏��器

转：内存泄露��?

转：��内存泄露的工具�Q�debugnew