C++博客-白纸人生-随笔分类-C++

网上看到的一个面试题：利用星号输出画一个任意大小的圆

思勤无邪 — Sat, 16 Oct 2010 15:41:00 GMT

1 /*利用星号输出画一个任意大小的圆*/
2 #include <math.h>
3 #include <stdio.h>
4
5 int max(int a, int b)
6 {
7     return a > b ? a : b;
8 }
9
10 void print_char(int x1, int x2)
11 {
12     int i;
13     // 计算这一行的宽度，终端最多显示80列
14     int n = max(x1, x2) + 1;
15     n = n > 80 ? 80 : n;
16     for (i = 0; i < n; i++)
17     {
18         if (i == x1 || i == x2)
19             printf("*");
20         else
21             printf(" ");
22     }
23     printf("\n");
24 }
25
26 void print_circle(int r)
27 {
28     int x1, x2, y;
29     int d = 2 * r;
30     int offset;
31     for(y = 0; y <= d; y++)
32     {
33         /*终端字符宽高比为2:1*/
34         offset = (int)(0.5 + sqrt((double)(r*r - (y-r)*(y-r)))*2.0);
35         x1 = d - offset;
36         x2 = d + offset;
37         print_char(x1, x2);
38     }
39 }
40
41 int main(int argn, char *argv[])
42 {
43     int r = 5;
44     if (argn > 1)
45         r = atoi(argv[1]);
46
47     print_circle(r);
48     return 0;
49 }
50

思勤无邪 2010-10-16 23:41 发表评论

聊聊封装、继承

思勤无邪 — Sat, 21 Jul 2007 08:18:00 GMT

在C++中封装的概念是把一个对象的外观接口同实际工作方式（实现）分离开来，但是C++的封装是不完全的，编译器必须知道一个对象的所有部分的声明，以便创建和管理它。我们可以想象一种只需声明一个对象的公共接口部分的编程语言，而将私有的实现部分隐藏起来。C + +在编译期间要尽可能多地做静态类型检查。这意味着尽早捕获错误，也意味着程序具有更高的效率。然而这对私有的实现部分来说带来两个影响：一是即使程序员不能轻易地访问实现部分，但他可以看到它；二是造成一些不必要的重复编译。

然而C++并没有将这个原则应用到二进制层次上，这是因为C++的类既是描述了一个接口同时也描述了实现的过程,示例如下：

class CMyString
{
private:
const int m_cch;
  char *m_psz;
public:
  CMyString(const char *psz);
  ~CMyString();
  int Length() const;
  int Index(const char *psz) const;
}

CMyStirng对外过多的暴露了内存布局实现的细节，这些信息过度的依赖于这些成员变量的大小和顺序，从而导致了客户过度依赖于可执行代码之间的二进制耦合关系，这样的接口不利于跨语言跨平台的软件开发和移植。

1.1.1 Handle-Body模式

解决这个问题的技术有一种叫句柄类（ handle classes）。有关实现的任何东西都消失了，只剩一个单一的指针“m_pThis”。该指针指向一个结构，该结构的定义与其所有的成员函数的定义都出现在实现文件中。这样，只要接口部分不改变，头文件就不需变动。而实现部分可以按需要任意更动，完成后只要对实现文件进行重新编译，然后再连接到项目中。

下面是这项技术的简单例子。头文件中只包含公共的接口和一个简单的没有完全指定的类指针。

class CMyStringHandle
{
private:
  class CMyString；
  CMyString *m_pThis;
public:
  CMyStringHandle (const char *psz);
  ~ CMyStringHandle ();
  int Length() const;
  int Index(const char *psz) const;
}；

CMyStringHandle:: CMyStringHandle(const char *psz)
:m_pThis(new CMyString(psz));
{
}

CMyStringHandle::~ CMyStringHandle()
{
   delete m_pThis;
}

int CMyStringHandle::Length()
{
  return m_pThis->Length();
}

int CMyStringHandle::Index(const char *psz)
{
return m_pThis->Index(psz);
}

这是所有客户程序员都能看到的。
class CMyString；

是一个没有完全指定的类型说明或类声明（一个类的定义包含类的主体）。它告诉编译器，CMyString是一个结构的名字，但没有提供有关该结构的任何东西。这对产生一个指向结构的指针来说已经足够了。但我们在提供一个结构的主体部分之前不能创建一个对象。在这种技术里，包含具体实现的结构主体被隐藏在实现文件中。

在设计模式中，这就叫做Handle-Body 模式，Handle-Body只含有一个实体指针，服务的数据成员永远被封闭在服务系统中。

Handle-Body的布局结构永远不会随着实现类数据成员的加入或者删除或者修改而导致Handle-Body的修改，即Handle-Body协议不依赖于C++实现类的任何细节。这就有效的对用户的编译器隐藏了这些细节，用户在使用对这项技术时候，Handle-Body 接口成了它唯一的入口。

然而Handle-Body模式也有自己的弱点：

1、接口类必须把每一个方法调用显示的传递给实现类，这在一个只有一个构造和一个析构的类来说显然不构成负担，但是如果一个庞大的类库，它有上百上千个方法时候，光是编写这些方法传递就有可能非常冗长，这也增加了出错的可能性。

2、对于关注于性能的应用每一个方法都得有两层的函数调用，嵌套的开销也不理想

3、由于句柄的存在，依然存在编译连接器兼容性问题。

1.1.2 抽象接口

使用了“接口与实现的分离”技术的 Handle-Body 解决了编译器/链接器的大部分问题，而C++面向对象编程中的抽象接口同样是运用了“接口与实现分离”的思想，而采用抽象接口对于解决这类问题是一个极其完美的解决方案。

1、抽象接口的语言描述：

class IMyString

{

virtual int Length() const = 0; //这表示是一个纯虚函数，具有纯虚函数的接口

virtual int Index(const char *psz) const = 0;

}；

2、抽象接口的内存结构：

抽象接口采用虚函数表来调用成员方法。

3、抽象接口的实现代码：

接口：

class IMyString

{

virtual int Length() const = 0; //这表示是一个纯虚函数，具有纯虚函数的接口

virtual int Index(const char *psz) const = 0;

}；

实现：

class CMyString：public IMyString

{

private:

const int m_cch;

char *m_psz;

public:

CMyString(const char *psz);

virtual ~CMyString();

int Length() const;

int Index(const char *psz) const;

}

从上面采用抽象接口的实例来看，抽象接口解决了Handle-Body所遗留下来的全部缺陷。

抽象接口的一个典型应用：

抽象工厂（AbstractFactroy）

1.2 多继承与菱形缺陷、this跳转等

多重继承是C++语言独有的继承方式，其它几乎所有语言都秉承了单一继承的思想。这是因为多重继承致命的缺陷导致的：

1.2.1 菱形缺陷

当继承基类时，在派生类中就获得了基类所有的数据成员副本。假如类B 从A1和A2两个类多重继承而来，这样B类就包含A1、A2类的数据成员副本。

考虑如果A1、A2都从某基类派生，该基类称为Base，现在继承关系将出现菱形继承关系。

我们C++语言来描述这种继承关系：

class Base{… … }；

class A1 :public Base {… … }；

class A2 :public Base {… … }；

class B :public A1,public A2 {… … }；

那么A1、A2都具有Base的副本。这样B就包含了Base的两个副本，副本发生了重叠，不但增加了存储空间，同时也引入了二义性。这就是菱形缺陷，菱形缺陷的两个缺陷：

1、子对象重叠

2、向上映射的二义性。

菱形缺陷的其中一种解决办法是使用虚拟继承。

在C++世界里最广泛的使用虚拟继承解决菱形缺陷的应用便是标准C++的输入/输出iostream；

1.2.2 多重接口与方法名冲突问题（Siamese twins）

对继承而来的虚函数改写很容易，但是如果是在改写一个“在两个基类都有相同原型”的虚函数情况就不那么容易了。

提出问题：

假设汽车最大速度的接口为ICar，潜艇最大速度的接口为 IBoat，有一个两栖类的交通工具它可以奔跑在马路上，也可以航行在大海中，那么它就同时拥有ICar、IBoat两种交通工具的最大速度特性，我们定义它的接口为ICarBoat；

class ICar

{

virtual int GetMaxSpeed（）= 0；

}；

class IBoat

{

virtual int GetMaxSpeed（）= 0；

}；

我们先对ICarBoat的接口做一个尝试：

class CCarBoat

{

virtual int GetMaxSpeed（）；//既完成ICar的GetMaxSpeed（）接口方法又 //完成IBoat的接口方法？显然不能够

};

解决问题：

显然上面这个尝试根本就无法成功，只用一个实现方法，怎么能够求出这个ICarBoat交通工具奔跑在马路上的最高时速，同时也能够求出航行在大海上的最大航行速度呢。

上面这一问题矛盾就在一一个方法，却需要两个答案。看来ICarBoat要返回两个答案就必须有两个方法了，我们假设一个方法是求在陆地上奔跑的速度，名称为GetCarMaxSpeed（）；另一个方法是求在大海上航行的最大速度，名称为GetBoatMaxSpeed（）；那这两个方法又怎么和GetMaxSpeed（）接口方法联系起来呢；

幸运的是，我们找到了解决办法，而且解决办法有很多种，下面介绍一下继承法。

class IXCar :public ICar

{

virtual int GetMaxSpeed（）

{

GetCarMaxSpeed();

}

virtual int GetCarMaxSpeed（） = 0;

}；

class IXBoat:public IBoat

{

virtual int GetMaxSpeed（）

{

GetBoatMaxSpeed();

}

virtual int GetBoatMaxSpeed（） = 0;

}；

classCCarBoat: public IXCar , public IXBoat

{

virtual int GetCarMaxSpeed（）

{

… …

}

virtual int GetBoatMaxSpeed（）

{

… …

}

};

1.2.3 this跳转

this跳转是指的“对象同一性”问题。

在单一继承的世界内，无论继承关系怎么复杂，针对于同一对象，无论它的子类或者父类的this指针永远相等。即如果 B从A继承，那么对于一个已经实例化B类的对象 bObject，永远有（B*）&bObject ==(A*)&bObject 成立。

但是在多继承的世界内，上面的等式就不能恒成立，对象的同一性受到了挑战。

特别的是，在多继承世界内如果菱形关系存在情况下，如果对于已经实例化B类的对象bObject; （Base*）（A1*）&bObject != （Base*）（A2*）&bObject 成立，当这种事情发生的时候我们就只能特殊处理了。这种情况在COM应用中处处都会发生。

1.3 C++多态的两种多态形式和区别

C++有两种多态多态形式：

1、编译时刻多态，编译时刻多态依靠函数重载或者模板实现

2、运行时刻多态。运行时刻多态依靠需函数虚接口实现

思勤无邪 2007-07-21 16:18 发表评论

C++的底层机制

思勤无邪 — Sun, 24 Jun 2007 12:43:00 GMT

　　c++为我们所提供的各种存取控制仅仅是在编译阶段给我们的限制，也就是说是编译器确保了你在完成任务之前的正确行为，如果你的行为不正确，那么你休想构造出任何可执行程序来。

　　但如果真正到了产生可执行代码阶段，无论是c，c++,还是pascal，大家都一样，你认为c和c++编译器产生的机器代码会有所不同吗，你认为c++产生的机器代码会有访问限制吗？那么你错了。什么const，private，统统没有(const变量或许会放入只读数据段)，它不会再给你任何的限制，你可以利用一切内存修改工具或者是自己写一个程序对某一进程空间的某一变量进行修改，不管它在你的印象中是 private，还是public，对于此时的你来说都一样，想怎样便怎样。

　　另外，你也不要为c++所提供的什么晚期捆绑等机制大呼神奇，它也仅仅是在所产生的代码中多加了几条而已，它远没有你想象的那么智能，所有的工作都是编译器帮你完成，真正到了执行的时候，计算机会完全按照编译器产生的代码一丝不苟的执行。

　　(以下的反汇编代码均来自visial c++ 7.0)

　　一.让我们从变量开始-----并非你想象的那么简单

　　变量是什么，变量就是一个在程序执行过程中可以改变的量。换一个角度，变量是一块内存区域的名字，它就代表这块内存区域，当我们对变量进行修改的时候，会引起内存区域中内容的改变。但是你若是学习过汇编或是计算机组成原理，那么你就会清楚对于一块内存区域来说，根本就不存在什么名字，它所仅有的标志就是他的地址，因此我们若想修改一块内存区域的内容，只有知道他的地址方能实现。看来所谓的变量一说只不过是编译器给我们进行的一种抽象，让我们不必去了解更多的细节，降低我们的思维跨度而已。例如下面这条语句：

　　int a=10;

　　按照我们的思维习惯来讲，就是“存在一个变量a，它的值是10”，一切都显得那么的自然。我们不必去在乎什么所谓的地址以及其他的一些细节。然而在这条语句的底层实现中，a已经不能算是一个变量了，它仅仅是一个标记，代表一个地址的标记：

　　mov dword ptr[a],0Ah;

　　怎么样，这条语句不像上面那条易于接受吧，因为它需要了解更多的细节，你几乎不能得到编译器的任何帮助，一切思维上的跨越必须由你自己完成。这条语句应该解释为“把10写入以a为地址的内存区域”。你说什么？a有些像指针？对，的确像，但还不是，只不过他们的过程似乎是类似的。这里所说的跨越实际上就是从一个现实问题到具体地址以及内存区域的跨越。

　　二.引用：你可以拥有引用，但编译器仅拥有指针(地址)

　　看过了第一条，你一定对编译器的工作有了一定的了解，实际上编译器就是程序员与底层之间的一个转换层，它把一个高级语言代码转换为低级语言代码，一个编译器完成的转换跨度越大，那么它也就会越复杂，因为程序员的工作都由他代为完成了。C++编译器必然比汇编编译器复杂就是这个道理。如果我问你引用和指针是一样的吗？你或许会说当然不一样了，指针容易产生不安全的因素，引用却不会，真的不会吗？我们来看下面这段代码：

　　int *e=new int(10);

　　int &f=*e;

　　delete e;

　　f=30;

　　你认为上面这段代码怎么样，我感觉就不很安全，它和指针有相同的隐患。因为它所引用的内存区域就不合法。

　　我个人认为，所谓的引用其实就是一种指针，只不过二者的接口并不相同，引用的接口有一定的限制。指针可以一对多，而引用却只能一对一，即&refer不能被改变，但却并不能说一对一就是安全的，只不过危险的系数降低罢了。引用比指针更容易控制。

　　Ok, 下面来说说指针，曾经有过汇编经验的人一定会说，恩，指针的某些地方有些像汇编，尤其是那个“*”，怎么就那么像汇编中的“[]”啊。的确，它也涵盖了一个寻址的过程。看来指针的确是个比较低级的东西。然而引用却并不那么直接，虽然程序员用起来方便安全了许多。但是你要清楚，只有你可以拥有引用，编译器可没有这个工具，计算机并不认识这个东西。因此，它的底层机制实际上是和指针一样的。不要相信只有一块内存拷贝，不要认为引用可以为你节省一个指针的空间，因为这一切不会发生，编译器还是会把引用解释为指针。不管你相不相信，请看下面这段代码：

　　int& b=a;

　　lea eax,[a];

　　mov dword ptr[b],eax;把a的地址赋给地址为b的一块内存

　　b=50;

　　mov eax,dword ptr[b];

　　mov dword ptr[eax],32h;

　　int *d=&a;

　　lea eax,[a];

　　mov dword ptr[d],eax

　　*d=60;

　　mov eax,dword ptr[d]

　　mov dword ptr[eax],3ch;

　　以上的代码均来自具体的编译器，怎么样，相信了吧，好，让我再来做一个或许不怎么恰当的比拟，你一定编过有关线性表和栈的程序吧，线性表是一个非常灵活的数据结构，在他上面有许多的操作，然而栈呢，它是一个限制性操作的线性表，它的底层操作实际上是由线性表操作实现的。就好比stack与vector的关系，因此指针和引用的关系就好比线性表和栈的关系，引用也就是受限的指针，它对外的接口和指针虽然并不一样，但底层是相同的。

　　下面再来看看引用的一个重要用途，作为函数的参数传递的时候是怎样的情形：

　　void swapr(int &a, int &b)；

　　void swapr(int* a, int *b)；

　　int a=10;

　　int b=20;

　　swapr(a, b);

　　lea eax,[a];

　　push eax; //把a的地址压入堆栈

　　lea ecx,[b];

　　push ecx;

　　call swapr;

　　swapr(&a, &b);

　　lea eax,[a];

　　push eax;

　　lea ecx,[b];

　　push ecx;

　　call swapr;

　　怎么样，用引用和指针传递参数无论是在效率上还是在空间上都是完全一样的，如果妄想不传入地址就修改实参的值，简直就是天方夜谭，这就说明引用的本质就是指针。毕竟它们的行为都太相似了，如果不是这样，你还有什么方法去实现引用吗？记住，引用只不过是编译器为你提供的一个有用且安全的工具，对于机器代码可无法表示它，它把指针一对多的缺点去除，禁止了你的不安全的操作。但回到问题的本源，他们没有任何区别。

思勤无邪 2007-06-24 20:43 发表评论

This case pointers cannot be used

思勤无邪 — Sat, 16 Jun 2007 12:45:00 GMT

References allow the use of expressions involving the usual arithmetic operators for large objects without excessive copying. Pointers cannot be used because it is not possible to redefine the meaning of an operator applied to a pointer.

思勤无邪 2007-06-16 20:45 发表评论

被误解的C++

思勤无邪 — Fri, 15 Jun 2007 12:41:00 GMT

    从CSDN上读到一篇文章，深有同感，原文如下：
    传统上认为，C++相对于目前一些新潮的语言，如Java、C#，优势在于程序的运行性能。这种观念并不完全。如果一个人深信这一点，那么说明他并没有充分了解和理解C++和那个某某语言。同时，持有这种观念的人，通常也是受到了某种误导（罪魁祸首当然就是那些财大气粗的公司）。对于这些公司而言，他们隐藏了C++同某某语言间的核心差别，而把现在多数程序员不太关心的差别，也就是性能，加以强化。因为随着cpu性能的快速提升，性能问题已不为人们所关心。这叫“李代桃僵”。很多涉世不深的程序员，也就相信了他们。于是，大公司们的阴谋也就得逞了。
    这个文章系列里，我将竭尽所能，利用一些现实的案例，来戳破这种谎言，还世道一个清白。但愿我的努力不会白费。

软件工程

    一般认为，使用Java或C#的开发成本比C++低。但是，如果你能够充分分析C++和这些语言的差别，会发现这句话的成立是有条件的。这个条件就是：软件规模和复杂度都比较小。如果不超过3万行有效代码（不包括生成器产生的代码），这句话基本上还能成立。否则，随着代码量和复杂度的增加，C++的优势将会越来越明显。
    造成这种差别的就是C++的软件工程性。在Java和C#大谈软件工程的时候，C++实际上已经悄悄地将软件工程性提升到一个前所未有的高度。这一点被多数人忽视，并且被大公司竭力掩盖。
    语言在软件工程上的好坏，依赖于语言的抽象能力。从面向过程到面向对象，语言的抽象能力有了一个质的飞跃。但在实践中，人们发现面向对象无法解决所有软件工程中的问题。于是，精英们逐步引入、并拓展泛型编程，解决更高层次的软件工程问题。（实际上，面向对象和泛型编程的起源都可以追溯到1967年，但由于泛型编程更抽象，所以应用远远落后于面向对象）。
    一个偶然的机会，我突发奇想，试图将货币强类型化，使得货币类型可以采用普通的算术表达式计算，而无需关心汇率换算的问题。具体的内容我已经写成文章，放在blog里：http://blog.csdn.net/longshanks/archive/2007/05/30/1631391.aspx。（CSDN的论坛似乎对大文章有些消化不良）。下面我只是简单地描述一下问题，重点还在探讨语言能力间的差异。
    当时我面临的问题是：假设有四种货币：RMB、USD、UKP、JPD。我希望能够这样计算他们：
RMB rmb_(1000);
USD usd_;
UKP ukp_;
JPD jpd_(2000);

usd_=rmb_;//赋值操作，隐含了汇率转换。usd_实际值应该是1000/7.68=130.21
rmb_=rmb_*2.5;//单价乘上数量。
ukp_=usd_*3.7;//单价乘上数量，赋值给英镑。隐含汇率转换。
double n=jpd_/(usd_-ukp_);//利用差价计算数量。三种货币参与，隐含汇率转换。
而传统上，我们通常用一个double或者currency类型表示所有货币。于是，当不同币种参与运算时，必须进行显式的汇率转换：
double rmb_(100), usd_(0), ukp_(0), jpn_(2000);

usd_=rmb_*usd_rmb_rate;
ukp_=(usd_*usd_ukp_rate)*3.7;
double n=jpd_/((usd_*usd_jpd_rate)-(ukp_*ukp_jpd_rate))
很显然，强类型化后，代码简洁的多。并且可以利用重载或特化，直接给出与货币相关的辅助信息，如货币符号等（这点我没有做，但加上也不复杂）。
在C++中，我利用模板、操作符重载，以及操作符函数模板等技术，很快开发出这个货币体系：
template
class Currency
{
public:
   Currency& operator=(count Currency& v) {
…
   }
public:
   double _val;
…
};
template
inline bool operator==(currency& c1, const currency& c2) {
…
}

template
inline currency& operator+=(currency& c1, const currency& c2) {
…
}
template
inline currency operator+(currency& c1, const currency& c2) {
…
}
…
总共不超过200行代码。（当然，一个工业强度的货币体系，需要更多的辅助类、函数等等。但基本上不会超过500行代码）。如果我需要一种货币，就先为其指定一个int类型的常量值，然后typedef一下即可：
const int CT_RMB=0;//也可以用enum
typedef CurrencyRMB;
const int CT_USD=1;
typedef CurrencyUSD;
const int CT_UKP=2;
typedef CurrencyUSD;
const int CT_JPD=3;
typedef CurrencyUSD;
…
每新增一种货币，只需定义一个值，然后typedef即可。而对于核心的Currency<>和操作符重载，无需做丁点改动。
之后，我试图将这个货币体系的代码移植到C#中去。根据试验的结果，我也写了一篇文章（也放在blog里：http://blog.csdn.net/longshanks/archive/2007/05/30/1631476.aspx）。我和一个同事（他是使用C#开发的，对其更熟悉），用了大半个上午，终于完成了这项工作。
令人丧气的事，上来就碰了个钉子：C#不支持=的重载。于是只能用asign<>()泛型函数代替。之后，由于C#的泛型不支持非类型泛型参数，即上面C++代码中的int CurrType模板参数的泛型对等物，以及C#不支持泛型操作符重载，整个货币系统从泛型编程模式退化成了面向对象模式。当然，在我们坚持不懈的努力下，最后终于实现了和C++中一样的代码效果（除了那个赋值操作）：
assign(rmb_, ukp_);
assign(usd_, rmb_*3.7);
…
我知道，有些人会说，既然OOP可以做到，何必用GP呢？GP太复杂了。这里，我已经为这些人准备了一组统计数据：在C#代码中，我实现了3个货币，结果定义了4个类（一个基类，三个货币类）；重载30个算术操作符（和C++一样，实现10个操作符，每个类都得把10个操作符重载一遍）；6个类型转换操作符（从两种货币类到第三货币类的转换操作符）。
这还不是最糟的。当我增加一个货币，货币数变成4个后，数据变成了：5个类；40个算术操作符重载；12个类型转换操作符重载。
当货币数增加到10个后：11个类；100个算术操作符重载；90个类型转换操作符重载。
反观C++的实现，3个货币时：1个类模板；1个赋值操作符重载模板；10个算术操作符重载模板；外加3个const int定义，3个typedef。
10个货币时：1个类模板；1个赋值操作符重载模板；10个算术操作符重载模板；const int定义和typedef分别增加到10个。
也就是说C++版本的代码随着货币的增加，仅线性增加。而且代码行增加的系数仅是2。请注意，是代码行！不是类、函数，也不是操作符的数量。而C#版本的代码量则会以几何级数增加。几何级数！！！
这些数字的含义，我就不用多说了吧。无论是代码的数量、可维护性、可扩展性C++都远远好于C#版本。更不用说可用性了（那个assign函数用起来有多难看）。
    我知道，有些人还会说：货币太特殊了，在实践中这种情况毕竟少见。没错，货币是比较特殊，但是并没有特殊到独此一家的程度。我曾经做了一个读取脚本中的图形信息，并绘图输出的简单案例，以展示OOP的一些基本概念，用于培训。但如果将其细化，可以开发出一个很不错的脚本绘图引擎。其中，我使用了组合递归、多态和动态链接，以及类工厂等技术。就是那个类工厂，由于我使用了模板，使得类工厂部分的代码减少了2/3，而且没有重复代码，更易维护。关于抽象类工厂的GP优化，Alexandrescu在其《Modren C++ design》中，有更多的案例。同样的技术，还可以推广到业务模型的类系统中，优化类工厂的代码。
如果还不满意，那么就去看看boost。boost的很多库实现了几乎不可想象的功能，比如lambda表达式、BGL的命名参数等等。它为我们很多优化软件代码新思路，很多技术和方法可以促进我们大幅优化代码，降低开发成本。
    最后，如果你认为C#的最大的优势在于.net平台，那我可以告诉你，这个世界上还有一种东西叫C++/CLI，完全可以满足.net的开发，而且更好，足以擦干净.net那肮脏的屁股。不过，这将会是另外一个故事了…

思勤无邪 2007-06-15 20:41 发表评论

一个简单的不依靠MFC的面向对象的Windows程序

思勤无邪 — Sat, 02 Jun 2007 04:36:00 GMT

摘要: 闲时顺手翻了翻《Windows Graphics Programming》，发现里面的示例代码很不错，对设计应用程序框架和理解现有的应用程序框架很有帮助（尤其是MFC）。先来看一个很简单的用面向对象的思想包装API函数的KWindow类。示例代码贴出来，申明一下，代码不是我写的，但有可能做一些改动，加了很多罗嗦的注释，只是想节约以后阅读的时间。 &n... 阅读全文

思勤无邪 2007-06-02 12:36 发表评论

什么是高级C++？

思勤无邪 — Sun, 22 Apr 2007 11:50:00 GMT

整理资料时，发现了《什么是高级C++》这个ppt。这是一个C++发展方向的介绍，个人觉得很不错，把内容贴了出来，同是也可以点击下载。

什么是高级C++？

——软件工业化时代的C++价值观
孟岩
《程序员》杂志社

开门见山

主要论点：
    1. C++本质上是一种重“创新”而轻“生产”的语言，到目前为止仍然是主流语言中最适合技术创新的一个；
    2. 1995年之前，整个软件产业处于“创新为王”的阶段，C++是最适合这个阶段的语言，这是C++红极一时的大背景和根本原因。
    3. 1995年发生了一系列影响深远的事件，软件产业整体上转向工业化，为了支持工业化，创新的重点由技术创新转向体系创新。然而C++没有能够迅速适应这一变化。
    4. 今天，C++应当准确定位，弥补不足，有针对性地发展，它将仍然是最重要的几种工业级语言之一。

从一本书说起
James Coplien，Advanced C++ Programming Styles and Idioms, Addison Wesley, 1991
—— 市面上唯一一本名副其实的“高级”C++书（Scott Meyers）
●面向对象特性的运用和把握
●面向对象的程序风格
●动态特征的运用和超越
●符号语言模拟
●设计模式

这本书代表了当时专家们对于“高级C++”的理解，换句话说代表了当时C++社群的一个审美价值取向。我们看到了什么？技术、技巧、风格、模式，但没有与工程相关的东西。更有意思的事情是，这本书的中文版12年后被剽窃出版，此时书中对于C++面向对象能力发挥到了我当时没有想到的程度。这说明即使在template被广泛应用之前，C++语言的技巧性就达到了如此的高度。然而耐人寻味的是，书中最高深的技巧从来就没有在C++实践中流行过。

另一本书...
Scott Meyers, Effective C++ ，1991年第1版，1998年第二版，2005年第三版。
●来自教学经验
●最初想开发一个代码扫描工具
●包含实际工程建议
●历史上最重要的C++著作之一

这本书出版的同时，还有一本在C++历史上影响更大的书问世——Scott Meyers的Effective C++。这本书并没有过多地探索语言技巧，而是探讨实践中应当遵循的规则，或者换句话说，探讨怎样在应用这种语言的同时保持软件的质量，提高开发效率。这本书的内容被整个C++社群熟知并吸收，至今仍在翻新，影响着更多的人。

还是在1991年...
●“按照1991年3月C++程序员增长的速度计算，到1996年5月，全世界每一个人都将成为C++程序员。此后我们将不得不教外星人学习C++。”
●问题：当时人们为什么如此疯狂地学习一种新语言？
答案很有趣：大部分人是盲从。但他们所追随的人并非等闲之辈，几乎所有在AT&T Bell Labs、Sun、Borland、IBM、Microsoft的C语言大师都转向C++（Brain Kernighan，Jon Bentley，Peter van der Linden）。而这些人转向C++，不是因为他们知道Effective C++，而是因为他们知道Advanced C++。什么意思呢？就是说人们转向C++，是因为C++充满了令人兴奋的新技巧和未知的创新空间。

1991年...
●5000行C代码可以写一个完整的应用程序，获得数万$的回报；
●一个TSR式的Help程序可以以shareware的方式通过磁盘发行，开发者银行户头里会收到大量汇款；
●John Carmark和Michael Abrash正在各自擅长的方向上不断创新。Doom发行后，id获得收入一度超过微软销售额。

C++历史选择中“创新”压倒“生产”
“相信程序员”；
Be an enable language;
Zero overhead；
STL投票的通过；
偏特化的引入
多继承
Generic/Generated/Meta
IOStream库的设计
Loki/Boost

counted_ptr被否决
可选GC方案被否决
加入类似delegate的对象方法指针提议未引起关注；
virtual关键字
exception机制
缺乏Thread, Network, Regex, DB...等标准库
没有ABI规范
孱弱的RTTI

并不是事后诸葛亮式的谴责，这就是C++的历史选择，无所谓对错。

C++重创新轻生产，重技巧轻规范，语言上的创新试验直到1996年ANSI C++标准草案落地才结束。直到2001年Modern C++ Design出版，人们还不断地发现新的语言运用技巧。我们每个人都经历过这个阶段，在实践中发现一个问题，想方设法用尽各种语言技巧来克服它，成则欣喜，败不气馁。我们都曾经相信，C++中一切问题都可以优雅地解决，只有想不到，没有做不到。问题是，从Advanced C++到Modern C++ Design，许许多多令人第一眼看上去无比惊喜的技术，最后在实践中被大范围推广运用的少之又少。C++大师们说这是教育问题，真的是这样吗？

C++社群的价值观
●用优雅的技巧解决复杂问题
●自己动手，丰衣足食
●决不让运行时效率蒙受半点损失
●妙者为王
“管理一群C++程序员就像放牧一群骄傲的猫。”——B. Moo
“C++程序员是高速公路上穿着短皮茄克，带着墨镜，抽着雪茄，挥舞着铁链的英勇无畏的摩托骑士。” ——VC产品经理

1995年：转折点
●Windows 95问世：GUI时代、保护模式操作系统时代、多线程时代的到来，是推动软硬件规模迅速膨胀；
●Netscape Navigator vs. Internet Explorer: Web的兴起将人类一下子拖入互联网时代, 个人与企业应用软件网络化；
●Java诞生：提供了网络时代、跨平台时代优于C++的企业应用软件开发语言；
●COM时代到来
●Delphi诞生：创新与工程原则平衡的典范；

1995年：C++全盛时代
●C++标准草案接近完成，语言基本稳定；
●C++工具大战结束：来自商业竞争的动力消失，MFC获胜；
●很多主流软件厂商转向C++，C++开始在大范围内被用于大规模软件开发；
●一切迹象表明，软件产业的重点将有创新转向生产。但是：C++社群在指导思想上并没有发生相应的变化。

我们的历史失误
●C++社群从来没有联合起来支持任何一个跨平台的二进制组件标准（如COM/SOM/CCM）和基础库（如Apache APR、ACE OS Wrapper）；
●C++社群从来没有联合起来支持任何一个跨平台的C++虚拟机、解释器、内存检测工具和错误录像工具，也从来没有促成过一个安全的库；
●Boost出现于1999-2000年，而在此之前的跨平台C++库都没有获得广泛的支持；
●钟情于用C++语法（无论多么复杂和稀奇古怪）完成所有的任务，却丢掉了老祖宗C语言的看家法宝——Little Language；
●对于风格争论不休，对于明显的技术进步拒不接受，对于很多后来被证明并不实用的技巧趋之若鹜。

没有跨平台的基础库，就没有跨平台的动态模块加载机制；
John Spencer夭折的书《The Art of C Programming》，GoF的Interpreter模式；Little Language实际上具有反映计算机本质的一些东西，现在却成了很少为C++程序员所采用和熟悉的工具。

2005年，C++的现实处境
●在系统编程领域仍然强势；
●套装软件主流开发语言之一；
●嵌入式开发领域进展较快；
●游戏引擎开发主力；
●科学计算方面略有一席之地
●遗留项目的维护；
●在企业应用开发领域快速收缩；
●Web开发中的影子语言；
●从高校主流教学中退潮；
●整体水平仍然不高，很多企业急于摆脱；
●最致命的：真正了解和熟练掌握C++的人太少；

案例：1. 国外一家公司花高薪聘人，要么能维护目前百万行规模的代码，要么把它转成Java；
2. IBM Workplace，项目一开始C++/Java并重，之后C++比重越来越小；
3. 微软与中国电信合作一个项目，客户端软件本来要用C++写，后来赶到产品化周期太长，改用C#，后发先至。

问题何在
●当前的软件产业发展的主要矛盾——各行各业对软件生产标准化、规模化、高质量要求与慢节奏、低效率、低质量的软件开发之间的矛盾。
●解决这个矛盾的关键：组件化体系，成熟的软件生产工具和环境，不断的创新精神。
●C++在外部环境已经发生根本变化的近十年时间里，没有抓住这个主要矛盾。

重新评估我们的C++价值取向
    重新评估“高级C++”的现实含义：
        - 简洁有效优于惊世骇俗；
        - 开放灵活优于保守固执；
        - 帮助他人优于凸现自己；
        - 领域创新优于卖弄技巧；

六个建议
●学会与现实和谐共处；
●尽快面向不同领域建立跨平台构件标准；
●支持各领域已经形成的基础库不断完善；
●支持相关工具厂商，迅速完善工具链；
●支持动态语言的发展；
●面向产业挑战创新发展；

与现实和谐共处
●承认C++只适合这个世界的一部分工作，快乐地与其他语言共同协作；
●告别妄自尊大和保守傲慢；
●尊重其他社群的专业能力和成绩；
●坦率承认C++在很多场合并非理想选择；
●在C++擅长的领域保持锐意。

跨平台构件标准
●C++迈向未来的关键技术步骤；
●尽可能支持现有的成熟方案；
●在不同尺度的平台上可能需要不同的标准；

支持成熟的基础库
●基本组件：STL和Boost（部分）
●网络和系统编程：ACE
●分布式计算：ICE
●GUI：Qt
●Windows：MFC/ATL/WTL
●科学计算：MTL

完善工具链
●C++用的GC；
●Code Review工具；
●内存错误排查工具；
●测试工具；
●MDA工具；
●文档工具；
●持续集成工具；
●运行录像工具。

支持动态语言
●动态语言是软件技术发展的一个重要方向，几年后会成为主流。
●目前几个流行动态语言天生与C/C++具有亲缘关系；
●加强对动态语言的友好性，是C++未来发展的一项重要任务；
●从这个角度来看待C++/CLI，我们应该持积极态度；
●Little Language问题；

迎接产业新挑战
●多核CPU带来根本性挑战，C++有责任挺身而出，为其他语言铺平前进道路；
●安全性问题，C/C++实际上是给整个产业拖了后腿，对此我们应当充分关注，积极改进；
●将STL思想精华发扬光大。

思勤无邪 2007-04-22 19:50 发表评论

Ruminations on C++ 中的代理类Demo

思勤无邪 — Thu, 29 Mar 2007 14:44:00 GMT

看Ruminations on C++ 的时候照着写的，简单的框架，留作备份吧。

// 代理类 Demo
// 将继承和容器共用，迫使我们要处理两个问题：
// 控制内存分配和把不同类型的对象放入同一个容器中。
// 代理类的每个对象都代表另一个对象，该对象可以是
// 位于一个完整继承层次中的任何类的对象。通过在容器中
// 用代理对象而不是对象本身来解决以上两个问题

#include <process.h>        // system()
#include <iostream>
using namespace std;

// 所有交通工具的基类
class Vehicle
{
public:
    virtual void start() = 0;
    // 动态复制
    virtual Vehicle* copy() const = 0;
    // 虚析构函数
    virtual ~Vehicle() {}
};

// 交通工具的代理类
class VehicleSurrogate
{
public:
    // 无参构造函数，用于创建数组
    VehicleSurrogate();
    // 用Vehicle 及其派生类构造
    VehicleSurrogate(const Vehicle&);
    ~VehicleSurrogate();
    // 拷贝及赋值
    VehicleSurrogate(const VehicleSurrogate&);
    VehicleSurrogate& operator=(const VehicleSurrogate&);

    // Vehicle 的方法
    void start();
private:
    Vehicle* p;
};

VehicleSurrogate::VehicleSurrogate() : p(0) {}

VehicleSurrogate::VehicleSurrogate(const Vehicle& v) : p(v.copy()) {}

VehicleSurrogate::VehicleSurrogate(const VehicleSurrogate& vs)
: p(vs.p ? vs.p->copy() : 0) {}

VehicleSurrogate & VehicleSurrogate::operator =(const VehicleSurrogate& vs)
{
    if (p != vs.p)
    {
        delete p;
        p = vs.p ? vs.p->copy() : 0;
    }
    return *this;
}

VehicleSurrogate::~VehicleSurrogate() { delete p; }

void VehicleSurrogate::start()
{
    if (p)
        p->start();
    else
        cout << "Error" << endl;
}

class RoadVehicle : public Vehicle
{
public :
    void start()
    {
        cout << "RoadVehicle start." << endl;
    }
    Vehicle* copy() const
    {
        return (Vehicle*) new RoadVehicle(*this);
    }
    ~RoadVehicle()
    {
    }
};

class AutoVehicle : public RoadVehicle
{
public :
    void start()
    {
        cout << "AutoVehicle start." << endl;
    }
    Vehicle* copy() const
    {
        return (Vehicle*) new AutoVehicle(*this);
    }
    ~AutoVehicle()
    {
    }
};

void main()
{
    VehicleSurrogate pa[3];
    RoadVehicle* prv = new RoadVehicle();
    pa[0] = *prv;
    delete prv;
    pa[1] = AutoVehicle();
    pa[2] = RoadVehicle();
    pa[0].start();
    pa[1].start();
    pa[2].start();
    system("pause");
}

思勤无邪 2007-03-29 22:44 发表评论

类厂和COM类的关系

思勤无邪 — Wed, 07 Mar 2007 02:24:00 GMT

读过《COM技术内幕》，理一下用类厂创建COM类的过程以及之间的关系。

类厂用来抽象组件的create过程，客户不需要知道组件的详细情况，也不需要知道类厂的详细情况，只要知道CoCreateInstance可以创建组件即可。而CoCreateInstance内部调用DllGetClassObject来生成该组件的类厂，由于类厂有组件的作者撰写，所以对组件类可谓知根知底，由类厂来生成组件完全行得通，这样客户和组件就进一步划分，客户只能查询该组件是否支持某接口，而对组件的其他情况一无所知，这样的划分可以使组件和客户间的耦合更小。
组件如果将某接口的全部方法都实现了，就称该组件支持某接口，com并没有规定组件和接口之间是虚函数继承的关系，只是在c++中以这种方法来实现最好而已。
IClassFactory说穿了就是专门构造组件的类，这样做是为了抽象，因为客户没有必要知道组件是什么，如果由客户直接构造组件，客户势必要知道组件的信息，com就失去了它的意义了，所以，规定了一个类厂（支持IClassFactory接口），每个组件的类厂都很清楚并且也只清楚该组件的信息，而客户只需要调用com库函数CoCreateInstance就可以了。
创建流程图：
CoCreateInstance -->> CoGetClassObject -->> DllGetClassObject -->> new ClassFactory -->>IClassFactory::CreateInstance() -->> new Component

思勤无邪 2007-03-07 10:24 发表评论

使用IDropTarget接口同时支持文本和文件拖放（转）

思勤无邪 — Mon, 05 Mar 2007 04:52:00 GMT

最近在写Shell Extension方面的东西，看到了这篇文章，抄在这里。
原文地址http://blog.csdn.net/vcbear/archive/2002/01/25/5990.aspx
同时也找到了一个与Drag and Drop有关的例子，地址：http://www.codeproject.com/useritems/NSExtDragDrop.asp

vcbear

关于

Windows 的外壳扩展编程，拖放是比较简单的一种，在网上可以找到不少介绍这个技巧的文章。大部分是介绍使用 MFC 的 COleDropTarget 实现的，我觉得一般使用 COleDropTarget 已经很好了，但是我习惯在一些程序模块中，完全的不使用 MFC, 比如纯 SDK 编程 , 还有用在 ATL 的时候 ,MFC 是相当累赘的。所以 COleDropTarget 在这个意义上讲不够完美。

参考了

MSDN 以及 www.CodeProject.com 的相关文章和代码（ by Thomas Blenkers ）之后，我发现拖放实际上主要使用了 IDropTarget 的接口方法，非常简单，不妨直接面对原始 IDropTarget 实现自己的拖放类。

作为学习笔记，就有了这么一篇文字,以抛砖引玉：

IDropTarget
是系统留给支持拖放的客户程序的一个纯虚接口，事先没有对接口的任何函数进行实现，而是让用户通过实现接口函数来接管拖放的结果。IDropTarget接口有以下成员函数：

基本

COM成员函数

QueryInterface

AddRef

Release

接管拖放事件的成员函数：

DragEnter

DragOver

DragLeave

Drop

也就是说，要在客户程序里实现以上

7个函数的实体。

系统在检测到拖放发生的时候，会在合适的时候依次调用客户程序里实现的

IDropTarget接口相应函数，检查用户在这些函数里返回的标志，决定鼠标外观表现和拖放结果。

　

实现
IDropTarget接口
为此建立一个基类为IDropTarget的类：
class CDropTargetEx : public IDropTarget

IDropTarget接口在OLEIDL.h里定义，为纯虚接口。

在CDropTargetEx里依次声明接口所包含的7个函数，原形为：

HRESULT STDMETHODCALLTYPE QueryInterface(REFIID iid, void ** ppvObject);

ULONG STDMETHODCALLTYPE AddRef(void);

ULONG STDMETHODCALLTYPE Release(void);

HRESULT STDMETHODCALLTYPE DragOver(DWORD grfKeyState,

POINTL pt,

DWORD *pdwEffect);

HRESULT STDMETHODCALLTYPE DragEnter(IDataObject * pDataObject,

DWORD grfKeyState, POINTL pt,

DWORD * pdwEffect);

HRESULT STDMETHODCALLTYPE DragLeave(void);

HRESULT STDMETHODCALLTYPE Drop(IDataObject *pDataObj,

DWORD grfKeyState,

POINTL pt,

DWORD __RPC_FAR *pdwEffect);

(为了实现Addref计数，还有一个ULONG tb_RefCount成员变量是必须的。QueryInterface，AddRef,Release这3个函数的实现是COM知识中最基本的，请参见附例)

在讲解

IDropTarget其他函数的具体实现之前，有必要介绍一下一个你可能永远不会直接调用但是确实存在的函数：DoDragDrop函数.此函数在某数据源的数据被拖动的时候就被调用，它负责

检测目标窗口是否支持拖放，发现目标窗口的

IDropTarget接口

随时跟踪鼠标和键盘的状态，根据状态决定调用其DrageEnter,DragMove,Drop或DragLeave接口

从这些接口获取客户程序的返回值，根据这些值和用户界面以及数据源进行交互。

可以说

DoDragDrop控制拖放的整个过程，我们要做的，只是将这个过程里发生的事件，接管下来并得到相应的信息，和DoDragDrop进行交互而已。了解了这一点有助于我们理解为什么通过区区一个接口4个函数就可以实现了拖放的效果，因为系统为我们已经做了很多。

另一个非常重要的

API是RegisterDragDrop，这个函数的原形是这样的：

WINOLEAPI RegisterDragDrop(

HWND hwnd,

IDropTarget * pDropTarget

);

不用被

WINOLEAPI吓到，这是一个宏:
#define STDAPI EXTERN_C HRESULT STDAPICALLTYPE

也就是表示一个标准的

WIN API函数，返回一个HRESULT的值。

函数

RegisterDragDrop的作用是告诉系统:某个窗口（hwnd参数指定）可以接受拖放，接管拖放的接口是pDropTarget。

记住在调用

RegisterDragDrop之前，一定要先调用OleInitialize初始化OLE环境。

在类

CDropTargetEx里设计了一个函数

BOOL CDropTargetEx::DragDropRegister(HWND hWnd,

DWORD AcceptKeyState=|MK_LBUTTON)

{

if(!IsWindow(hWnd))return false;

HRESULT s = ::RegisterDragDrop (hWnd,this);

if(SUCCEEDED(s))

{

m_hTargetWnd = hWnd;

m_AcceptKeyState = AcceptKeyState;

return true;

}

else { return false; }

}

在这个函数里调用

RegisterDragDrop,将this指针传入，表示本类实现了IDropTarget.，由本类接管拖放事件。另外顺便定义了一下拖放鼠标和键盘特性常数，对这个类来说，我希望默认的只接受鼠标左键的拖放，所以，默认的AcceptKeyState值是MK_LBUTTON。相关的键盘鼠标常数还有MK_SHIFT,MK_ALT,MK_RBOTTON,MK_MBUTTON,MK_BOTTON等几个，我想这个几个常数从字面上就可以理解它的意思了。这些常数可以用“位与”的操作组合。

以下具体讨论

IDropTarget的拖放相关接口函数（4个），这里的拖放对象以文本和文件为主。

DragEnter

当你用鼠标选中了某一个文件或一段文本，并且将鼠标移到某个可以接受拖放（已经调用过

RegisterDragDrop）的窗口里，DragEnter将第一时间被调用。再看一下其原形：
HRESULT DragEnter( IDataObject * pDataObject,

   DWORD grfKeyState,

    POINTL pt,

      DWORD * pdwEffect   )

pDataobject
是从拖放的原数据中传递过来的一个IDataObject接口实例，包含数据对象的一些相关方法，可以通过此接口获得数据。
grfKeyState
为DragEnter被调用时当前的键盘和鼠标的状态，包含上面介绍过的键盘鼠标状态常数。
pt
表示鼠标所在的点。是以整个屏幕为参考坐标的。
pdwEffect
是DoDragDrop提供的一个DWORD指针，客户程序通过这个指针给DoDragDrop返回特定的状态。有效的状态包括：

DROPEFFECT_NONE=0 表示此窗口不能接受拖放。

DROPEFFECT_MOVE=1 表示拖放的结果将使源对象被删除

DROPEFFECT_COPY=2 表示拖放将引起源对象的复制。

DROPEFFECT_LINK =4 表示拖放源对象创建了一个对自己的连接

DROPEFFECT_SCROLL=0x80000000表示拖放目标窗口正在或将要进行卷滚。此标志可以和其他几个合用

对于拖放对象来说，一般只要使用DROPEFFECT_NONE和DROPEFFECT_COPY即可。

在DragEnter里要做什么呢？主要是告知拖放已经进入窗口区域，并判断是否支持某具体类型的拖放。

首先,要判断键盘的状态。在调用DragDropRegister时我传入了一个AcceptKeyState并将其保存在m_AcceptKeyState成员变量里，现在可以拿它跟这里得到的grfKeyState比较：

if(grfKeyState!=m_AcceptKeyState )

{

*pdwEffect = DROPEFFECT_NONE;

return S_OK;

}

如果键盘和鼠标的状态和我期望的不一样，那么

pdwEffect里返回DROPEFFECT_NONE表示不接受拖放。

然后

,判断拖放过来的IDataObject对象里有没有我感兴趣的数据。

这里要介绍的是两个关键的结构体

FORMATETC和STDMEDIUM
FORMATETC
是OLE数据交换的一个关键结构，对某种设备，数据，和相关媒体做了格式上的描述。

其定义为

typedef struct tagFORMATETC

{

CLIPFORMAT cfFormat;

DVTARGETDEVICE *ptd;

DWORD dwAspect;

LONG lindex;

DWORD tymed;

}

FORMATETC, *LPFORMATETC;

在这里我们最感兴趣的是

cfFormat和tymed两个数据。cfFormat是标准的“粘帖板”数据类型比如CF_TEXT之类。tymed表示数据所依附的媒介，比如内存，磁盘文件，存储对象等等。其他的成员可以参见MSDN。

一个典型的

FORMATETC结构变量定义如下：
FORMATETC cFmt = {(CLIPFORMAT) CF_TEXT, NULL, DVASPECT_CONTENT, -1, TYMED_HGLOBAL};

IDataObject提供了一个GetData接口来获取其实例里包含的数据，比如：

STGMEDIUM stgMedium;

ret = pDataObject->GetData(&cFmt, &stgMedium);

GetData传入cFmt，以指出所感兴趣的数据，并将返回在stgMedium结构里。

STGMEDIUM
的定义如下1

typedef struct tagSTGMEDIUM

{

DWORD tymed;

[switch_type(DWORD), switch_is((DWORD) tymed)]

union {

[case(TYMED_GDI)] HBITMAP hBitmap;

[case(TYMED_MFPICT)] HMETAFILEPICT hMetaFilePict;

[case(TYMED_ENHMF)] HENHMETAFILE hEnhMetaFile;

[case(TYMED_HGLOBAL)] HGLOBAL hGlobal;

[case(TYMED_FILE)] LPWSTR lpszFileName;

[case(TYMED_ISTREAM)] IStream *pstm;

[case(TYMED_ISTORAGE)] IStorage *pstg;

[default] ;

};

[unique] IUnknown *pUnkForRelease;

}STGMEDIUM;

typedef STGMEDIUM *LPSTGMEDIUM;

看起来颇为复杂，其实主要是一系列句柄或数据对象接口的联合，根据数据具体的类型，使用其中之一即可。

tymed和FORMATETC里一样，指出数据的载体类型（遗憾的是它不能指出具体的标准类型比如CF_TEXT或者其他）。至于pUnkForRelease,是源数据指定的一个接口，用来传递给ReleaseStgMedium函数，如果它不为NULL，则ReleaseStgMedium函数使用这个接口释放数据。如果为NULL,则ReleaseStgMedium函数使用默认的IUnknown接口。对于常规的拖放来说，这个对象指针应该为NULL.

得到了句柄或数据对象接口，也相当于得到了拖放的数据。

定义一个特定的

FORMATETC结构实例传递给IDataObject的GetData，可以直接询问和获取某一种特定的数据。如果我们对我们想要的数据是非常确定的，这是比较有效率的方法。但是如果我们期望能够对拖放的对象进行自适应的话，我们可以采取枚举IDataObject里包含的所有数据类型的方案。这就要用到IEnumFORMATETC接口了。

IEnumFORMATETC接口从IDataObject接口里获取：

IEnumFormatETC *pEnumFmt = NULL;

ret = pDataObject->EnumFormatEtc (DATADIR_GET,&pEnumFmt);

如果获取成功，则可以通过

IEnumFORMATETC接口的Next方法，来枚举所有的数据格式：

pEnumFmt->Reset ();

HRESULT Ret=S_OK

while(Ret!=S_OK)

{

Ret

=pEnumFmt->Next(1,&cFmt,&Fetched);

if(SUCCEEDED(ret))

if( cFmt.cfFormat == CF_TEXT

||cFmt.cfFormat == CF_HDROP)

{

if(GetDragData(pDataObject,cFmt))

EnterResult = true;

}

第一个参数表示一次获取的

FORMATETC结构数据的数量，cFmt是一个FORMATETC指针，指向一个数据缓冲，用来返回FORMATETC数据。,Fetched是Next调用后得到的FORMATETC数据个数。一般一次获取一个，直到Next返回不为S_OK。

我们可以对每个得到

cFmt调用IDataObject->GetData方法，但是一般来说，一个数据对象包含的数据不止一种，而且一般有一些自定义的数据类型（关于自定义数据类型，参见：RegisterClipboardFormat，如果要自己实现Drag/Drop源数据，这个函数是有用的），对此我们不感兴趣，因为这里只要求处理文本和文件的拖动，为此，只处理cfFormat为CF_TEXT和CF_HROP的数据：
GetDragData
为CDropTargetEx类的一个成员函数：
///////////////////////////////////////////////////

//Get The DragData from IDataObject ,save in HANDEL

BOOL CDropTargetEx::GetDragData(IDataObject *pDataObject,FORMATETC cFmt)

{

HRESULT ret=S_OK;

STGMEDIUM stgMedium;

ret = pDataObject->GetData(&cFmt, &stgMedium);//GetData(CF_TEXT, &stgMedium);

if (FAILED(ret))

{

return FALSE;

}

if (stgMedium.pUnkForRelease != NULL)

{

return FALSE;

}

///////////////////////////////////////////

switch (stgMedium.tymed)

{

case TYMED_HGLOBAL:

{

LPDRAGDATA pData = new DRAGDATA;

pData->cfFormat = cFmt.cfFormat ;

memcpy(&pData->stgMedium,&stgMedium,sizeof(STGMEDIUM));

m_Array.push_back(pData);

return true;

break;

}

default:

// type not supported, so return error

{

::ReleaseStgMedium(&stgMedium);

}

break;

}

return false;

}

在这个成员函数里，根据

cFmt，调用IDataObject->GetData函数获得数据（对于CF_TEXT和CF_HROP来说，数据的媒介载体tymed都是HGLOBAL类型的）。

在具体实现的时候，我定义了一个结构：

typedef struct _DRAGDATA

{

int cfFormat;

STGMEDIUM stgMedium;

}DRAGDATA,*LPDRAGDATA;

将

STGMEDIUM和数据类型（比如CF_TEXT,记录在cfFormat）都记录在DRAGDATA里。并且使用了一个vector数组，将这个结构保存在数组里。对于不是我们想要的STGMEDIUM数据，我们马上调用ReleaseStgMedium函数进行释放，免得造成内存泄露。

这样，

DragEnter的工作就基本完成了，最后需要做的就是给DoDragDrop返回相应的状态：如果我们获得了想要的数据就给* pdwEffect赋值为DROPEFFECT_COPY，否则，就是DROPEFFECT_NONE；

如果支持拖放，鼠标形状将变成一个有接受意义的图标，否则，是一个拒绝意义的图标。

DragOver

鼠标拖动对象进入窗口之后，将会在窗口范围内移动，这时

DoDragDrop就会调用IDropTarget的DragOver接口。其原形为：

HRESULT DragOver(

DWORD grfKeyState

POINTL pt,

DWORD * pdwEffect

)

相对来说对于这个接口方法的实现可以简单的多：只要根据

grfKeyState判断键盘和鼠标的状态是否符合要求，根据pt传入的鼠标点判断该点是否支持拖放（比如将拖放区域限制在窗口的一部分的话），然后为*pdwEffect赋值为DROPEFFECT_COPY或DROPEFFECT_NONE.当然，还可以做一些你喜欢的事情，比如把鼠标坐标打印到屏幕上。不过为了性能和安全起见，建议不要做延时明显的操作。

DragLeave:

这个方法没有传入参数，相当简单。

当拖动的鼠标离开了窗口区域，这个方法将被调用，你可以在这里写一些清理内存的代码。在

CDropTargetEx类里，由于在DragEnter里new了一些数据结构，并加到一个指针数组里，所以我必须在这里对此数据进行清理，对此结构里的STDMEDIUM调用ReleaseStgMedium然后Delete该结构。

另外，如果需要的话，可以通知用户鼠标指针已经离开了拖放区域。

Drop

如果鼠标没有离开窗口，而是在窗口内释放按纽，那么拖放时间的“放”就在这时发生，

IDropTarget接口的Drop方法被调用。其原形为
HRESULT Drop(

IDataObject * pDataObject,

DWORD grfKeyState,
POINTL pt,

DWORD * pdwEffect

)

有些资料建议在这里才调用

pDataObject->GetData方法获取数据，在CDropTargetEx类里，数据实际上已经在DragEnter里获取了。这样做的理由是我希望一开始就获得数据，从它本身进行判断是否支持拖放,而不是在“放”的时候才判断是否合法数据。

既然数据已经获得，那么我就可以从保存数据的指针数组里提取出

STGMEDIUM数据来，并根据数据的具体格式进行处理（最后一定要记住对STGMEDIUM进行ReleaseStgMedium）

对于

CF_TEXT类型的数据，STGMEDIUM的成员hGlobal里包含的是一段全局内存数据。获取这些数据的方法是：

TCHAR *pBuff = NULL;

pBuff=(LPSTR)GlobalLock(hText);

GlobalUnlock(hText);

则得到一个指向内存数据的指针pBuff。在我这个例子里一般是一段

"\0"结尾的文本字符串。这样就实现了文本的拖放。

对于

CF_HDROP类型的数据，STGMEDIUM成员hGlobal是一个HDROP类型的句柄。通过这个句柄，可以获得拖放的文件列表。如：

BOOL CDropTargetEx::ProcessDrop(HDROP hDrop)

{

UINT iFiles,ich =0;

TCHAR Buffer[MAX_PATH]="";

memset(&iFiles,0xff,sizeof(iFiles));

int Count = ::DragQueryFile(hDrop,iFiles,Buffer,0); //Get the Drag _Files Number.

if(Count)

for (int i=0;i

{

if(::DragQueryFile(hDrop,i,Buffer,sizeof(Buffer)))

{

//Got the FileName in Buffer

}

::DragFinish(hDrop);

return true;

}

获得的

Buffer是就是拖放的文件名，如果拖放的是多个文件，在for循环里可以依次获取这些文件的文件名。这样就实现了文件的拖放。

CDropTargetEx
类使用非常简单:

在客户窗口的相关文件中，定义一个

CDropTargetEx实例：CDropTargetEx DropTarget;

在窗口创建之后，将窗口句柄进行拖放注册：

DropTarget.DragDropRegister(hWnd);

或者

DropTarget.DragDropRegister(hWnd，MK_CONTROL|MK_LBUTTON);

表示鼠标左键按下并且按住

Ctrl键的拖放有效;

对于获取拖放的结果，我使用的是回调函数方式：

回调原形

typedef VOID (_stdcall *DROPCALLBACK)(LPCSTR Buffer,int type);

在适当的地方（比如窗口的实现

CPP里）定义函数DropCallback：
void _stdcall DropCallBack(LPCSTR Buffer,int type)

并且将其地址赋于

DropTarget实例：
DropTarget.SetCallBack(DropCallBack);

这样，拖放文本到客户窗口，回调函数将被调用，参数

Buffer为拖放的文本，format为CF_TEXT。而拖放文件的时候，对每个被拖放的文件都调用一次回调函数，参数Buffer为文件全路径名，format为CF_HDROP。

示例的

DropCallBack代码为：

void _stdcall DropCallBack(LPCSTR Buffer,int format)

{

switch(format)

{

case CF_TEXT:

{

SetWindowText(hEdit,Buffer);

break;

}

case CF_HDROP:

{

TCHAR Buf[2048]="";

sprintf(Buf,"File : <%s> is Drag and Drop to this Windows ,Open it?",Buffer);

if(MessageBox(hMainWnd,Buf,"Question",MB_YESNO)==IDYES)

{

ShellExecute(0,"open",Buffer,"","",SW_SHOW);

}

default:

break;

}

总结
：使用IDropTarget实现通用的拖放，只要实现其7个接口，并且对得到的IDataObject用正确的格式（FORMATETC）调用正确的GetData获取数据，返回DROPEFFECT决定拖放的特征和结果，并处理拖放结果即可。

要注意的小问题是：

要调用OleInitialize而不是CoInitialize或CoInitializeEx对COM进行初始，否则RegisterDragDrop将不会成功，返回的错误是E_OUTOFMEMORY--内存不够，无法进行该操作。
调用ReleaseStgMedium释放STGMEDIUM里的数据，而不是直接对其hGlobal成员调用CloseHandle.
拖放操作关系到两个进程的数据交换，会将两个进程都堵塞，直到拖放完成为止，所以，在接管拖放的接口方法中，不要进行过于耗时的运算。

这个例子相当简单，还可以简化，比如取消

vector,将获得HGLOBAL句柄作为成员变量存储，或者将获取数据的操作全部放到Drop方法里。

对于拖放文件，还有一个更简单的方法：响应

WM_DROPFILES消息。步骤是：

对客户窗口调用

DropAccepFiles,使该窗口可以接受文件拖放。

响应WM_DROPFILES消息，其wParam就是HDROP句柄

对此句柄调用DropQueryFiles获取拖放文件列表并结束拖放，参见上面关于ProcessDrop的代码

对于拖放的全面阐述，请参见

MSDN->PlatformSDK Document->User Interface Services->Windows Shell里关于“Transferring Shell Objects with Drag-and-Drop and the Clipboard”一章。Windows Shell系统提供了很多接口，让用户利用和扩充这些接口，很方便的开发和使用丰富的shell服务，确实是一种很聪明的设计。

附
例子和代码

思勤无邪 2007-03-05 12:52 发表评论

从MFC与ATL的男女关系说起

思勤无邪 — Thu, 16 Nov 2006 01:15:00 GMT

如果从哲学的观点来看，这大概要说是一种辩证关系了!

首先谈谈男人。男人与男孩的区别在于责任，对于一个男人来说，他的肩膀永远有负担，他要解决生活中遇到的所有问题，可以为妻儿带来幸福生活，可以赡养父母，可以做一些成就来创一番事业。所以男人不要轻生，因为你垮下就意味着你的负担没有了支撑，也就是你不负责任。男人的这种责任体现了一种刚性，打不倒压不垮，坎坎坷坷一路走来即使没有扬名立万但是肩膀上的负担始终没有落下。铮铮铁骨、铁血男儿、阳刚之美都是对男人的赞美，一个家庭男人是顶梁柱，这就是责任。

再谈谈女人。女人与女孩的区别在于柔情，少了撒娇和任性，多了体贴和温柔。女人是生活的调剂品，少了她尽管可以填抱肚皮、补充营养但食之无味。女人天生就是善于交际的，这本身体现的就是一种柔性，就像太极一样，以柔克刚，借助刚性体现柔美。

用建筑来形容男女关系，男人就像钢筋水泥搭建起来的框架承受着外力，女人则是对框架填补装修使其美观，不同的男人有着不同的建筑风格，不同的女人可以使建筑呈现不同的美。成功的男人背后都有一个女人，钢筋水泥加上精心装饰让人体会到设计之美，至于谁重要次要，谁表谁里都不是关键，关键的是刚柔的结合。

MFC

MFC是一个男人，从Microsoft C/C++ version 7.0到Visual Stduio.net 2005一直承担着软件框架设计的角色，风风雨雨路不回头，屹立在软件设计大道，为开发者提供便利，著名的BCG库和XTREME库都是在MFC源码基础上的改进。它大而繁杂，曲折通幽，粗旷豪放。它必须承担责任，提供软件设计的一套解决方案，而且背负着历史包袱，所以难免带有一些成熟男人的深邃而不被人理解。如果你还一味的去批判它，那只能说你不懂男人的心，不理解一个男人难言之苦。 ATL

ATL是一个女人，小巧灵活讨人喜爱，它作为COM思想的实现而拿出来解决软件协作的问题。它可以不具体实现功能而只留出一些接口，接口两端相通并且随时拔插，多么完美一个女人!为一个C++对象配备一个ATL对象你可以想象有什么结果嘛?

软件设计中的MFC与ATL

以前我一直以为ATL就是做控件、构造插件接口体系的，而MFC就是用来做界面功能。它们属于不同体系，在功能级别上存在差异，所以只是在纵向上结合而没有尝试横向的结合。人类社会是自然的，软件社会也应该是自然的。自然代表一种随和，亲近，协调。

提到MFC，八九不离十就涉及到软件界面开发。目前来说软件复用需求越来越高，而软件功能的不确定因素越来越大，一个特定的界面行为可能不确定。MFC是一个男人，用它可以做任何想做的界面，这就是它的刚性。但是我们到底是要去做什么还是告诉别人我们可以做什么呢?如果我们一味的做，那我们充其量只是一个莽夫，是吕布有勇无谋。我告诉你我有一个MFC对象，还告诉你它可以做什么，这样不就够了。

MFC是男人天生缺乏沟通能力，所以无法告知外界它自身的行为，只有它自己知道。这时候就需要一个管子插到对象内部去了解它，而ATL刚好提供了一个接口，将其一段插入MFC对象内部而露出另一端以便告知外界MFC对象内部的行为。这样的界面是可解释的界面，它具有做事情的能力，但是它不去做，而成为可复用界面。

思勤无邪 2006-11-16 09:15 发表评论

sizeof终极无惑

思勤无邪 — Thu, 26 Oct 2006 03:59:00 GMT

1. 定义：
sizeof是C/C++中的一个操作符（operator），简单的说其作用就是返回一个对象或者类型所占的内存字节数。
MSDN上的解释为：
The sizeof keyword gives the amount of storage, in bytes, associated with a variable or a type (including aggregate types).
This keyword returns a value of type size_t.
其返回值类型为size_t，在头文件stddef.h中定义。这是一个依赖于编译系统的值，一般定义为
typedef unsigned int size_t;
世上编译器林林总总，但作为一个规范，它们都会保证char、signed char和unsigned char的sizeof值为1，毕竟char是我们编程能用的最小数据类型。

2. 语法：
sizeof有三种语法形式，如下：
1) sizeof( object ); // sizeof( 对象 );
2) sizeof( type_name ); // sizeof( 类型 );
3) sizeof object; // sizeof 对象;
所以，
int i;
sizeof( i ); // ok
sizeof i; // ok
sizeof( int ); // ok
sizeof int; // error
既然写法3可以用写法1代替，为求形式统一以及减少我们大脑的负担，第3种写法，忘掉它吧！
实际上，sizeof计算对象的大小也是转换成对对象类型的计算，也就是说，同种类型的不同对象其sizeof值都是一致的。这里，对象可以进一步延伸至表达式，即sizeof可以对一个表达式求值，编译器根据表达式的最终结果类型来确定大小，一般不会对表达式进行计算。如：
sizeof( 2 );// 2的类型为int，所以等价于 sizeof( int );
sizeof( 2 + 3.14 ); // 3.14的类型为double，2也会被提升成double类型，所以等价于 sizeof( double );
sizeof也可以对一个函数调用求值，其结果是函数返回类型的大小，函数并不会被调用，我们来看一个完整的例子：
char foo()
{
printf("foo() has been called.\n");
return 'a';
}
int main()
{
size_t sz = sizeof( foo() ); // foo() 的返回值类型为char，所以sz = sizeof( char )，foo()并不会被调用
printf("sizeof( foo() ) = %d\n", sz);
}
C99标准规定，函数、不能确定类型的表达式以及位域（bit-field）成员不能被计算sizeof值，即下面这些写法都是错误的：
sizeof( foo );// error

void foo2() { }
sizeof( foo2() );// error

struct S
{
unsigned int f1 : 1;
unsigned int f2 : 5;
unsigned int f3 : 12;
};
sizeof( S.f1 );// error

3. sizeof的常量性
sizeof的计算发生在编译时刻，所以它可以被当作常量表达式使用，如：
char ary[ sizeof( int ) * 10 ]; // ok
最新的C99标准规定sizeof也可以在运行时刻进行计算，如下面的程序在Dev-C++中可以正确执行：
int n;
n = 10; // n动态赋值
char ary[n]; // C99也支持数组的动态定义
printf("%d\n", sizeof(ary)); // ok. 输出10
但在没有完全实现C99标准的编译器中就行不通了，上面的代码在VC6中就通不过编译。所以我们最好还是认为sizeof是在编译期执行的，这样不会带来错误，让程序的可移植性强些。

4. 基本数据类型的sizeof
这里的基本数据类型指short、int、long、float、double这样的简单内置数据类型，由于它们都是和系统相关的，所以在不同的系统下取值可能不同，这务必引起我们的注意，尽量不要在这方面给自己程序的移植造成麻烦。
一般的，在32位编译环境中，sizeof(int)的取值为4。

5. 指针变量的sizeof
学过数据结构的你应该知道指针是一个很重要的概念，它记录了另一个对象的地址。既然是来存放地址的，那么它当然等于计算机内部地址总线的宽度。所以在32位计算机中，一个指针变量的返回值必定是4（注意结果是以字节为单位），可以预计，在将来的64位系统中指针变量的sizeof结果为8。
char* pc = "abc";
int* pi;
string* ps;
char** ppc = &pc;
void (*pf)();// 函数指针
sizeof( pc ); // 结果为4
sizeof( pi ); // 结果为4
sizeof( ps ); // 结果为4
sizeof( ppc ); // 结果为4
sizeof( pf );// 结果为4
指针变量的sizeof值与指针所指的对象没有任何关系，正是由于所有的指针变量所占内存大小相等，所以MFC消息处理函数使用两个参数WPARAM、LPARAM就能传递各种复杂的消息结构（使用指向结构体的指针）。

6. 数组的sizeof
数组的sizeof值等于数组所占用的内存字节数，如：
char a1[] = "abc";
int a2[3];
sizeof( a1 ); // 结果为4，字符串末尾还存在一个NULL终止符
sizeof( a2 ); // 结果为3*4=12（依赖于int）
一些朋友刚开始时把sizeof当作了求数组元素的个数，现在，你应该知道这是不对的，那么应该怎么求数组元素的个数呢？Easy，通常有下面两种写法：
int c1 = sizeof( a1 ) / sizeof( char ); // 总长度/单个元素的长度
int c2 = sizeof( a1 ) / sizeof( a1[0] ); // 总长度/第一个元素的长度
写到这里，提一问，下面的c3，c4值应该是多少呢？
void foo3(char a3[3])
{
int c3 = sizeof( a3 ); // c3 == ?
}
void foo4(char a4[])
{
int c4 = sizeof( a4 ); // c4 == ?
}也许当你试图回答c4的值时已经意识到c3答错了，是的，c3!=3。这里函数参数a3已不再是数组类型，而是蜕变成指针，相当于char* a3，为什么？仔细想想就不难明白，我们调用函数foo1时，程序会在栈上分配一个大小为3的数组吗？不会！数组是“传址”的，调用者只需将实参的地址传递过去，所以a3自然为指针类型（char*），c3的值也就为4。

7. 结构体的sizeof
这是初学者问得最多的一个问题，所以这里有必要多费点笔墨。让我们先看一个结构体：
struct S1
{
char c;
int i;
};
问sizeof(s1)等于多少？聪明的你开始思考了，char占1个字节，int占4个字节，那么加起来就应该是5。是这样吗？你在你机器上试过了吗？也许你是对的，但很可能你是错的！VC6中按默认设置得到的结果为8。
Why？为什么受伤的总是我？
请不要沮丧，我们来好好琢磨一下sizeof的定义——sizeof的结果等于对象或者类型所占的内存字节数，好吧，那就让我们来看看S1的内存分配情况：
S1 s1 = { 'a', 0xFFFFFFFF };
定义上面的变量后，加上断点，运行程序，观察s1所在的内存，你发现了什么？
以我的VC6.0为例，s1的地址为0x0012FF78，其数据内容如下：
0012FF78:? 61 CC CC CC FF FF FF FF
发现了什么？怎么中间夹杂了3个字节的CC？看看MSDN上的说明：
When applied to a structure type or variable, sizeof returns the actual size, which may include padding bytes inserted for alignment.
原来如此，这就是传说中的字节对齐啊！一个重要的话题出现了。
为什么需要字节对齐？计算机组成原理教导我们这样有助于加快计算机的取数速度，否则就得多花指令周期了。为此，编译器默认会对结构体进行处理（实际上其它地方的数据变量也是如此），让宽度为2的基本数据类型（short等）都位于能被2整除的地址上，让宽度为4的基本数据类型（int等）都位于能被4整除的地址上，以此类推。这样，两个数中间就可能需要加入填充字节，所以整个结构体的sizeof值就增长了。
让我们交换一下S1中char与int的位置：
struct S2
{
int i;
char c;
};
看看sizeof(S2)的结果为多少，怎么还是8？再看看内存，原来成员c后面仍然有3个填充字节，这又是为什么啊？别着急，下面总结规律。

字节对齐的细节和编译器实现相关，但一般而言，满足三个准则：
1) 结构体变量的首地址能够被其最宽基本类型成员的大小所整除；
2) 结构体每个成员相对于结构体首地址的偏移量（offset）都是成员大小的整数倍，如有需要编译器会在成员之间加上填充字节（internal adding）；
3) 结构体的总大小为结构体最宽基本类型成员大小的整数倍，如有需要编译器会在最末一个成员之后加上填充字节（trailing padding）。
对于上面的准则，有几点需要说明：
1) 前面不是说结构体成员的地址是其大小的整数倍，怎么又说到偏移量了呢？因为有了第1点存在，所以我们就可以只考虑成员的偏移量，这样思考起来简单。想想为什么。
结构体某个成员相对于结构体首地址的偏移量可以通过宏offsetof()来获得，这个宏也在stddef.h中定义，如下：
#define offsetof(s,m)?? (size_t)&(((s *)0)->m)
例如，想要获得S2中c的偏移量，方法为
size_t pos = offsetof(S2, c);// pos等于4
2) 基本类型是指前面提到的像char、short、int、float、double这样的内置数据类型，这里所说的“数据宽度”就是指其sizeof的大小。由于结构体的成员可以是复合类型，比如另外一个结构体，所以在寻找最宽基本类型成员时，应当包括复合类型成员的子成员，而不是把复合成员看成是一个整体。但在确定复合类型成员的偏移位置时则是将复合类型作为整体看待。
这里叙述起来有点拗口，思考起来也有点挠头，还是让我们看看例子吧（具体数值仍以VC6为例，以后不再说明）：
struct S3
{
char c1;
S1 s;
char c2
};
S1的最宽简单成员的类型为int，S3在考虑最宽简单类型成员时是将S1“打散”看的，所以S3的最宽简单类型为int，这样，通过S3定义的变量，其存储空间首地址需要被4整除，整个sizeof(S3)的值也应该被4整除。
c1的偏移量为0，s的偏移量呢？这时s是一个整体，它作为结构体变量也满足前面三个准则，所以其大小为8，偏移量为4，c1与s之间便需要3个填充字节，而c2与s之间就不需要了，所以c2的偏移量为12，算上c2的大小为13，13是不能被4整除的，这样末尾还得补上3个填充字节。最后得到sizeof(S3)的值为16。
通过上面的叙述，我们可以得到一个公式：
结构体的大小等于最后一个成员的偏移量加上其大小再加上末尾的填充字节数目，即：
sizeof( struct ) = offsetof( last item ) + sizeof( last item ) + sizeof( trailing padding )

到这里，朋友们应该对结构体的sizeof有了一个全新的认识，但不要高兴得太早，有一个影响sizeof的重要参量还未被提及，那便是编译器的pack指令。它是用来调整结构体对齐方式的，不同编译器名称和用法略有不同，VC6中通过#pragma pack实现，也可以直接修改/Zp编译开关。#pragma pack的基本用法为：#pragma pack( n )，n为字节对齐数，其取值为1、2、4、8、16，默认是8，如果这个值比结构体成员的sizeof值小，那么该成员的偏移量应该以此值为准，即是说，结构体成员的偏移量应该取二者的最小值，公式如下：
offsetof( item ) = min( n, sizeof( item ) )
再看示例：
#pragma pack(push) // 将当前pack设置压栈保存
#pragma pack(2)// 必须在结构体定义之前使用
struct S1
{
char c;
int i;
};
struct S3
{
char c1;
S1 s;
char c2
};
#pragma pack(pop) // 恢复先前的pack设置
计算sizeof(S1)时，min(2, sizeof(i))的值为2，所以i的偏移量为2，加上sizeof(i)等于6，能够被2整除，所以整个S1的大小为6。
同样，对于sizeof(S3)，s的偏移量为2，c2的偏移量为8，加上sizeof(c2)等于9，不能被2整除，添加一个填充字节，所以sizeof(S3)等于10。
现在，朋友们可以轻松的出一口气了，:)

还有一点要注意，“空结构体”（不含数据成员）的大小不为0，而是1。试想一个“不占空间”的变量如何被取地址、两个不同的“空结构体”变量又如何得以区分呢？于是，“空结构体”变量也得被存储，这样编译器也就只能为其分配一个字节的空间用于占位了。如下：
struct S5 { };
sizeof( S5 ); // 结果为1

8. 含位域结构体的sizeof
前面已经说过，位域成员不能单独被取sizeof值，我们这里要讨论的是含有位域的结构体的sizeof，只是考虑到其特殊性而将其专门列了出来。
C99规定int、unsigned int和bool可以作为位域类型，但编译器几乎都对此作了扩展，允许其它类型类型的存在。
使用位域的主要目的是压缩存储，其大致规则为：
1) 如果相邻位域字段的类型相同，且其位宽之和小于类型的sizeof大小，则后面的字段将紧邻前一个字段存储，直到不能容纳为止；
2) 如果相邻位域字段的类型相同，但其位宽之和大于类型的sizeof大小，则后面的字段将从新的存储单元开始，其偏移量为其类型大小的整数倍；
3) 如果相邻的位域字段的类型不同，则各编译器的具体实现有差异，VC6采取不压缩方式，Dev-C++采取压缩方式；
4) 如果位域字段之间穿插着非位域字段，则不进行压缩；
5) 整个结构体的总大小为最宽基本类型成员大小的整数倍。

还是让我们来看看例子。
示例1：
struct BF1
{
char f1 : 3;
char f2 : 4;
char f3 : 5;
};
其内存布局为：
|_f1__|__f2__|_|____f3___|____|
|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|

位域类型为char，第1个字节仅能容纳下f1和f2，所以f2被压缩到第1个字节中，而f3只能从下一个字节开始。因此sizeof(BF1)的结果为2。
示例2：
struct BF2
{
char f1 : 3;
short f2 : 4;
char f3 : 5;
};
由于相邻位域类型不同，在VC6中其sizeof为6，在Dev-C++中为2。
示例3：
struct BF3
{
char f1 : 3;
char f2;
char f3 : 5;
};
非位域字段穿插在其中，不会产生压缩，在VC6和Dev-C++中得到的大小均为3。

9. 联合体的sizeof
结构体在内存组织上是顺序式的，联合体则是重叠式，各成员共享一段内存，所以整个联合体的sizeof也就是每个成员sizeof的最大值。结构体的成员也可以是复合类型，这里，复合类型成员是被作为整体考虑的。
所以，下面例子中，U的sizeof值等于sizeof(s)。
union U
{
int i;
char c;
S1 s;
};

思勤无邪 2006-10-26 11:59 发表评论

重写atoi函数

思勤无邪 — Tue, 24 Oct 2006 08:36:00 GMT

int myatoi( char * s)
{
   int sign, n;
   while (isspace( * s))
            ++ s;
  sign = 1 ;
   switch ( * s) {
     case ' - ' : sign = - 1 ;
     case ' + ' : ++ s;
    }
  n = 0 ;
   while (isdigit( * s))
           n = 10 * n + ( * s ++ ) - ' 0 ' ;
   return (sign * n);
}

思勤无邪 2006-10-24 16:36 发表评论

不用友元，访问类的私有成员变量的方法

思勤无邪 — Tue, 24 Oct 2006 07:22:00 GMT

    虽然没有现实意义，但对理解C++的对象模型是很有帮助的。

    前几天，在论坛里看到一个帖子，内容是：
（原帖见：http://community.csdn.net/Expert/topic/5014/5014384.xml?temp=.3018152）
========================================
class a
{
private:
int k;
};
要求不用友元，不在这个类里添加任何代码，去访问成员变量k。
能做出的高手，请贴出完整源码，以便大家测试。
========================================

这道题目本身所要解决的问题并没有多少现实意义，但如果试着去解决它，以及比它更复杂的情况，我认为至少对理解C++的对象模型是很有帮助的。

开始讨论之前不得不说，这道题做为一个题目存在逻辑上的重大缺陷：“不给类增加一行代码”，我实在想不出如何在验正解题人所提供方案的正确性。只有一个private，难道用解题人所提供的读出方案来验证他自己所提供的写入方案？你用你的方法读出来，然后告诉我那就是你用你的方法写进去的值——那能让人信服吗？所以我决定还是把问题改一改，并稍微具体化如下：
class Test {
public:
int get_value() { return value; }
private:
int value;
};
要求不用友元，不在这个类里添加任何代码，把成员变量k的值改为100，结果自然是通过公共成员函数get_value来验证。

“不在类里添加任何代码”，除了
#define private public
我实在想不出其它的“偏门”方法了。那就想想不偏门的吧，论坛里好几位朋友提供了相当于如下代码的方法（为控制篇幅，本文中所有程序段都假设已包含了头文件并引入了std名字空间，必要时还有其它头文件）：
Test t;
*(int*)&t = 100;
cout << t.get_value() << endl;
这种方式利用对象内存布局的特点：整个类只有一个整型成员，没有继承或虚拟继承，也没有任何虚函数，那么这个对象的地址也就是它的第一个成员变量的地址，所以只需要把对象地址强转成整型，那么获得的就是那个成员变量的地址，然后对转换后的地址再解引用，修改即可，在VC2003中验证，结果是正确的。
但指针的强制转换总给人带来不爽，不大安全的感觉，上面那条最关键的语句相当于：
*reinterpret_cast(&t) = 100;
也就是说，它动用了C++语言中最“强”的指针转换方式（说它最强，是因为没有什么指针之间他不能转换的）。其实我们完全可以做得更“文明”一点，方法是再定义一个联合体，比如：
union TestInt {
Test t;
int i;
};
然后再：
TestInt ti;
ti.i = 100;
cout << ti.t.get_value() << endl;
同样达到了目的，但实质上依据的机理跟上面的指针转换是一致的。

这个方法没啥大问题，就是有局限性，只能用于修改类的第一个成员，如果在value之前再加一个成员，比如：
class Test {
public:
int get_value() { return value; }
private:
char ch;
int value;
};
这种方法就不灵了。
当然，你可以手工算，认为char占一个字节，于是会试图取对象地址再加1得到成员value的地址。但第一，这种方法无法不跨平台跨实现，char及int类型在不同的平台和编译器实现中的长度都可能是不一样的；第二，没有考虑字对齐问题，在内存中，value成员一般不会紧接着排布在ch之后，而是中间间开几个字节，最后将int类型对齐到另一个位置，比如4的倍数的地址上；而更糟糕的是，字对齐不仅跟平台相关，还跟预编译指令，甚至编译选项都会有关。所以，这种手工计算的方式还是放弃了吧。
有朋友提到了使用一种宏求出value成员相对于整个对象起始地址的偏移量，即定义一个宏：
#define OFFSET(TYPE,MEM) ((int)(char*)&(((TYPE*)0)->MEM))
这个宏通过把0地址转换为TYPE指针类型，然后从这个指针上“取”MEM成员，而MEM成员的地址转换后结果就是MEM成员相对于整个对象的偏移量（我们既然是从0地址开始算的，就不用再减去起始地址0）。
然后同，我们通过使用这个宏作用于原来的类和目标字段，即：
OFFSET(Test, value)
就可以获得value字段在Test类型对象中的偏移量，用对象的首地址加上这个偏移量，就可以得到value变量的地址，从而可以像上面一样解引用，修改。
这种方法不仅看起来难受，费解。事实上也根本行不通，因为这个宏所用到的技巧是从Test类型的指针上访问value成员——而valuee是private的！所以连编译都通不过。

论坛里有位朋友提出了另外一种方法可以巧妙地对付这个复杂一点的类，先做一个辅助类，它跟Test类很像，唯一的不同是它的成员都是public的：
class TestTwin {
public:
int get_value() { return value; }
public:
char ch;
int value;
};
于是，这个TestTwin类跟原来的Test类在内存布局上不会有什么不同，通过指针转换，很容易借助于它来修改Test类对象的value成员：
Test t;
TestTwin* p = reinterpret_cast(&t);
p->value = 100;
cout << t.get_value() << endl;
如果你不熟悉C++的显式指针转换方式：reinterpret_cast，在这里可以认为它相当于C风格的：
TestTwin* p = (TestTwin*)&t;
而前述的两条语句也可以合在一起，直接写成：
reinterpret_cast(&t)->value = 100;
还有，厌恶指针操作的朋友仍可采用前面介绍的联合体方法来运用这个模具类，只是这次定义的联合体是这样：
union TestTestTwin {
Test t;
TestTwin tw;
};
而程序是这样：
TestTestTwin ttw;
ttw.tw.value = 100;
cout << ttw.t.get_value() << endl;

问题都解决了吗？如果类更复杂一些，会不会还有局限性呢？我们再把类改一改：
class Test {
public:
int get_value() { return value; }
~Test() {}
private:
char ch;
int value;
public:
int a;
double b;
protected:
string e;
private:
short d;
};
这次不仅成员多了许多，有string类型的成员（须include ），还弄出个虚析构函数来（我们都知道拥有虚函数的类会导致其实例中多一个虚表指针）。但后面会看到，虚函数对我们讨论的问题影响不大，我们加上它只是想证明：只要方法足够好，不怕对象更复杂。
那上面的模具办法问题出在哪里呢？为什么不能同样再搞一个类，把那个value改为public的，然后用它来“套住”原来对象中value成员呢？
原因是C++语言只保证类中同一个access section（即从一个访问权限修饰符public/private/protected到另一个修饰符之间的部分）中定义的非静态成员变量会按照声明时的顺序分布的内存中，但并不保证跨越了不同access section的所有成员变量都在内存中按声明时的顺序存放，某种编译器完全有可能把所有的private块都合成一块，甚至整个给扔到所有protected成员的后边去（虽然VC并没这么做）。
换句话说：改掉了一个成员的访问权限，就可能改变了对象的内存布局。于是，改变了的模子也就不再能够套住相应位置上的成员。
但办法还是有，只需要将原来的改进一下：
在现有的C++对象模型中，为类增加一个非虚成员函数，不会改变对象的内存布局，我们可以利用这一点来写一个TestTwin：
class TestTwin {
public:
int get_value() { return value; }
void set_value(int v) { value = v; }
~TestTwin() {}
private:
char ch;
int value;
public:
int a;
double b;
protected:
float e;
private:
short d;
};
这个模具跟原来的Test类也是只有一点不同：增加了一个公共的，非虚的set_value方法，用来给私有成员value赋值。于是，程序可以这么写：
Test t;
reinterpret_cast(&t)->set_value(100);
cout << t.get_value() << endl;
验证通过。
增加的虚函数纯粹是个障眼物而已，它跟我们采用的方法几乎没有丝毫联系，所以也就丝毫不用担心虚函数对内存分布的影响会影响到这个方法的正确性。但被它一搞，那个使用联合体的方法这一次还真是不管用了，因为有了析构函数的类不能再放进联合体中了——否则当联合体实例的生命周期结束时，析构谁呢？

想了关天，能想到的只有这么多了。
最后，不行不承认，“增加一个非虚成员函数，不会改变对象的内存布局”这句话也无法从C++标准中得到直接支持，只是对于目前大多数编译器来说，这都是没问题的。因为这种“让类的每个实例拥有一份独立的成员变量，而类的所有实例共享一份成员函数”的C++对象模型是C++之父Bjarne Stroustrup先生本人所提出的，其时间、空间效率都很好地符合了C++语言的设计初衷，不仅现代C++编译器没有不这么做的，就连Java/C#编译器也都这么做。所以，也算是个“相对真理”了。

    原文地址：http://community.csdn.net/Expert/topic/5039/5039857.xml?temp=.728924

思勤无邪 2006-10-24 15:22 发表评论

Windows Socket API 使用小结

思勤无邪 — Wed, 11 Oct 2006 00:32:00 GMT

一、WSAStartup函数
   int WSAStartup(
     WORD wVersionRequested,
     LPWSADATA lpWSAData
   );
   使用Socket的程序在使用Socket之前必须调用WSAStartup函数。该函数的第一个参数指明程序请求使用的Socket版本，其中高位字节指明副版本、低位字节指明主版本；操作系统利用第二个参数返回请求的Socket的版本信息。当一个应用程序调用WSAStartup函数时，操作系统根据请求的Socket版本来搜索相应的Socket库，然后绑定找到的Socket库到该应用程序中。以后应用程序就可以调用所请求的Socket库中的其它Socket函数了。该函数执行成功后返回0。
例：假如一个程序要使用2.1版本的Socket,那么程序代码如下
           wVersionRequested = MAKEWORD( 2, 1 );
           err = WSAStartup( wVersionRequested, &wsaData );

二、WSACleanup函数
   int WSACleanup (void);
   应用程序在完成对请求的Socket库的使用后，要调用WSACleanup函数来解除与Socket库的绑定并且释放Socket库所占用的系统资源。

三、socket函数
  SOCKET socket(
     int af,
     int type,
     int protocol
   );
   应用程序调用socket函数来创建一个能够进行网络通信的套接字。第一个参数指定应用程序使用的通信协议的协议族，对于TCP/IP协议族，该参数置PF_INET;第二个参数指定要创建的套接字类型，流套接字类型为SOCK_STREAM、数据报套接字类型为SOCK_DGRAM；第三个参数指定应用程序所使用的通信协议。该函数如果调用成功就返回新创建的套接字的描述符，如果失败就返回INVALID_SOCKET。套接字描述符是一个整数类型的值。每个进程的进程空间里都有一个套接字描述符表，该表中存放着套接字描述符和套接字数据结构的对应关系。该表中有一个字段存放新创建的套接字的描述符，另一个字段存放套接字数据结构的地址，因此根据套接字描述符就可以找到其对应的套接字数据结构。每个进程在自己的进程空间里都有一个套接字描述符表但是套接字数据结构都是在操作系统的内核缓冲里。下面是一个创建流套接字的例子：
       struct protoent *ppe;
       ppe=getprotobyname("tcp");
       SOCKET ListenSocket=socket(PF_INET,SOCK_STREAM,ppe->p_proto);

四、closesocket函数
  int closesocket(
     SOCKET s
   );
   closesocket函数用来关闭一个描述符为s套接字。由于每个进程中都有一个套接字描述符表，表中的每个套接字描述符都对应了一个位于操作系统缓冲区中的套接字数据结构，因此有可能有几个套接字描述符指向同一个套接字数据结构。套接字数据结构中专门有一个字段存放该结构的被引用次数，即有多少个套接字描述符指向该结构。当调用closesocket函数时，操作系统先检查套接字数据结构中的该字段的值，如果为1，就表明只有一个套接字描述符指向它，因此操作系统就先把s在套接字描述符表中对应的那条表项清除，并且释放s对应的套接字数据结构；如果该字段大于1，那么操作系统仅仅清除s在套接字描述符表中的对应表项，并且把s对应的套接字数据结构的引用次数减1。
closesocket函数如果执行成功就返回0，否则返回SOCKET_ERROR。

五、send函数
  int send(
     SOCKET s,
     const char FAR *buf,
     int len,
     int flags
   );
   不论是客户还是服务器应用程序都用send函数来向TCP连接的另一端发送数据。客户程序一般用send函数向服务器发送请求，而服务器则通常用send函数来向客户程序发送应答。该函数的第一个参数指定发送端套接字描述符；第二个参数指明一个存放应用程序要发送数据的缓冲区；第三个参数指明实际要发送的数据的字节数；第四个参数一般置0。这里只描述同步Socket的send函数的执行流程。当调用该函数时，send先比较待发送数据的长度len和套接字s的发送缓冲区的长度，如果len大于s的发送缓冲区的长度，该函数返回SOCKET_ERROR；如果len小于或者等于s的发送缓冲区的长度，那么send先检查协议是否正在发送s的发送缓冲中的数据，如果是就等待协议把数据发送完，如果协议还没有开始发送s的发送缓冲中的数据或者s的发送缓冲中没有数据，那么send就比较s的发送缓冲区的剩余空间和len，如果len大于剩余空间大小send就一直等待协议把s的发送缓冲中的数据发送完，如果len小于剩余空间大小send就仅仅把buf中的数据copy到剩余空间里（注意并不是send把s的发送缓冲中的数据传到连接的另一端的，而是协议传的，send仅仅是把buf中的数据copy到s的发送缓冲区的剩余空间里）。如果send函数copy数据成功，就返回实际copy的字节数，如果send在copy数据时出现错误，那么send就返回SOCKET_ERROR；如果send在等待协议传送数据时网络断开的话，那么send函数也返回SOCKET_ERROR。要注意send函数把buf中的数据成功copy到s的发送缓冲的剩余空间里后它就返回了，但是此时这些数据并不一定马上被传到连接的另一端。如果协议在后续的传送过程中出现网络错误的话，那么下一个Socket函数就会返回SOCKET_ERROR。（每一个除send外的Socket函数在执行的最开始总要先等待套接字的发送缓冲中的数据被协议传送完毕才能继续，如果在等待时出现网络错误，那么该Socket函数就返回SOCKET_ERROR）
注意：在Unix系统下，如果send在等待协议传送数据时网络断开的话，调用send的进程会接收到一个SIGPIPE信号，进程对该信号的默认处理是进程终止。

六、recv函数
   int recv(
     SOCKET s,
     char FAR *buf,
     int len,
     int flags
   );
   不论是客户还是服务器应用程序都用recv函数从TCP连接的另一端接收数据。该函数的第一个参数指定接收端套接字描述符；第二个参数指明一个缓冲区，该缓冲区用来存放recv函数接收到的数据；第三个参数指明buf的长度；第四个参数一般置0。这里只描述同步Socket的recv函数的执行流程。当应用程序调用recv函数时，recv先等待s的发送缓冲中的数据被协议传送完毕，如果协议在传送s的发送缓冲中的数据时出现网络错误，那么recv函数返回SOCKET_ERROR，如果s的发送缓冲中没有数据或者数据被协议成功发送完毕后，recv先检查套接字s的接收缓冲区，如果s接收缓冲区中没有数据或者协议正在接收数据，那么recv就一直等待，只到协议把数据接收完毕。当协议把数据接收完毕，recv函数就把s的接收缓冲中的数据copy到buf中（注意协议接收到的数据可能大于buf的长度，所以在这种情况下要调用几次recv函数才能把s的接收缓冲中的数据copy完。recv函数仅仅是copy数据，真正的接收数据是协议来完成的），recv函数返回其实际copy的字节数。如果recv在copy时出错，那么它返回SOCKET_ERROR；如果recv函数在等待协议接收数据时网络中断了，那么它返回0。
注意：在Unix系统下，如果recv函数在等待协议接收数据时网络断开了，那么调用recv的进程会接收到一个SIGPIPE信号，进程对该信号的默认处理是进程终止。

七、bind函数
  int bind(
     SOCKET s,
     const struct sockaddr FAR *name,
     int namelen
   );
   当创建了一个Socket以后，套接字数据结构中有一个默认的IP地址和默认的端口号。一个服务程序必须调用bind函数来给其绑定一个IP地址和一个特定的端口号。客户程序一般不必调用bind函数来为其Socket绑定IP地址和断口号。该函数的第一个参数指定待绑定的Socket描述符；第二个参数指定一个sockaddr结构，该结构是这样定义的：
struct sockaddr {
           u_short sa_family;
           char sa_data[14];
       };
  sa_family指定地址族，对于TCP/IP协议族的套接字，给其置AF_INET。当对TCP/IP协议族的套接字进行绑定时，我们通常使用另一个地址结构：
       struct sockaddr_in {
           short   sin_family;
           u_short sin_port;
           struct  in_addr sin_addr;
           char    sin_zero[8];
       };
   其中sin_family置AF_INET；sin_port指明端口号；sin_addr结构体中只有一个唯一的字段s_addr，表示IP地址，该字段是一个整数，一般用函数inet_addr（）把字符串形式的IP地址转换成unsigned long型的整数值后再置给s_addr。有的服务器是多宿主机，至少有两个网卡，那么运行在这样的服务器上的服务程序在为其Socket绑定IP地址时可以把htonl(INADDR_ANY)置给s_addr，这样做的好处是不论哪个网段上的客户程序都能与该服务程序通信；如果只给运行在多宿主机上的服务程序的Socket绑定一个固定的IP地址，那么就只有与该IP地址处于同一个网段上的客户程序才能与该服务程序通信。我们用0来填充sin_zero数组，目的是让sockaddr_in结构的大小与sockaddr结构的大小一致。下面是一个bind函数调用的例子：
   struct sockaddr_in saddr；
   saddr.sin_family = AF_INET;
   saddr.sin_port = htons(8888);
   saddr.sin_addr.s_addr = htonl(INADDR_ANY);
   bind(ListenSocket,(struct sockaddr *)&saddr,sizeof(saddr))；

八、listen函数
   int listen( SOCKET s, int backlog );
   服务程序可以调用listen函数使其流套接字s处于监听状态。处于监听状态的流套接字s将维护一个客户连接请求队列，该队列最多容纳backlog个客户连接请求。假如该函数执行成功，则返回0；如果执行失败，则返回SOCKET_ERROR。

九、accept函数
   SOCKET accept(
     SOCKET s,
     struct sockaddr FAR *addr,
     int FAR *addrlen
   );
   服务程序调用accept函数从处于监听状态的流套接字s的客户连接请求队列中取出排在最前的一个客户请求，并且创建一个新的套接字来与客户套接字创建连接通道，如果连接成功，就返回新创建的套接字的描述符，以后与客户套接字交换数据的是新创建的套接字；如果失败就返回INVALID_SOCKET。该函数的第一个参数指定处于监听状态的流套接字；操作系统利用第二个参数来返回新创建的套接字的地址结构；操作系统利用第三个参数来返回新创建的套接字的地址结构的长度。下面是一个调用accept的例子：
       struct sockaddr_in ServerSocketAddr;
       int addrlen;
       addrlen=sizeof(ServerSocketAddr);
       ServerSocket=accept(ListenSocket,(struct sockaddr *)&ServerSocketAddr,&addrlen);

十、connect函数
   int connect(
     SOCKET s,
     const struct sockaddr FAR *name,
     int namelen
   );
   客户程序调用connect函数来使客户Socket s与监听于name所指定的计算机的特定端口上的服务Socket进行连接。如果连接成功，connect返回0；如果失败则返回SOCKET_ERROR。下面是一个例子：
       struct sockaddr_in daddr;
       memset((void *)&daddr,0,sizeof(daddr));
       daddr.sin_family=AF_INET;
       daddr.sin_port=htons(8888);
       daddr.sin_addr.s_addr=inet_addr("133.197.22.4");
       connect(ClientSocket,(struct sockaddr *)&daddr,sizeof(daddr));

思勤无邪 2006-10-11 08:32 发表评论

Visual C++线程同步技术

思勤无邪 — Tue, 10 Oct 2006 08:14:00 GMT

线程同步的方式有：
　　临界区
　　管理事件内核对象
　　信号量内核对象
　　互斥内核对象
分别介绍如下：

使线程同步

　　在程序中使用多线程时，一般很少有多个线程能在其生命期内进行完全独立的操作。更多的情况是一些线程进行某些处理操作，而其他的线程必须对其处理结果进行了解。正常情况下对这种处理结果的了解应当在其处理任务完成后进行。

　　如果不采取适当的措施，其他线程往往会在线程处理任务结束前就去访问处理结果，这就很有可能得到有关处理结果的错误了解。例如，多个线程同时访问同一个全局变量，如果都是读取操作，则不会出现问题。如果一个线程负责改变此变量的值，而其他线程负责同时读取变量内容，则不能保证读取到的数据是经过写线程修改后的。

　　为了确保读线程读取到的是经过修改的变量，就必须在向变量写入数据时禁止其他线程对其的任何访问，直至赋值过程结束后再解除对其他线程的访问限制。象这种保证线程能了解其他线程任务处理结束后的处理结果而采取的保护措施即为线程同步。

　　线程同步是一个非常大的话题，包括方方面面的内容。从大的方面讲，线程的同步可分用户模式的线程同步和内核对象的线程同步两大类。用户模式中线程的同步方法主要有原子访问和临界区等方法。其特点是同步速度特别快，适合于对线程运行速度有严格要求的场合。

　　内核对象的线程同步则主要由事件、等待定时器、信号量以及信号灯等内核对象构成。由于这种同步机制使用了内核对象，使用时必须将线程从用户模式切换到内核模式，而这种转换一般要耗费近千个CPU周期，因此同步速度较慢，但在适用性上却要远优于用户模式的线程同步方式。

临界区

　　临界区（Critical Section）是一段独占对某些共享资源访问的代码，在任意时刻只允许一个线程对共享资源进行访问。如果有多个线程试图同时访问临界区，那么在有一个线程进入后其他所有试图访问此临界区的线程将被挂起，并一直持续到进入临界区的线程离开。临界区在被释放后，其他线程可以继续抢占，并以此达到用原子方式操作共享资源的目的。

　　临界区在使用时以CRITICAL_SECTION结构对象保护共享资源，并分别用EnterCriticalSection（）和LeaveCriticalSection（）函数去标识和释放一个临界区。所用到的CRITICAL_SECTION结构对象必须经过InitializeCriticalSection（）的初始化后才能使用，而且必须确保所有线程中的任何试图访问此共享资源的代码都处在此临界区的保护之下。否则临界区将不会起到应有的作用，共享资源依然有被破坏的可能。

图1 使用临界区保持线程同步

　　下面通过一段代码展示了临界区在保护多线程访问的共享资源中的作用。通过两个线程来分别对全局变量g_cArray[10]进行写入操作，用临界区结构对象g_cs来保持线程的同步，并在开启线程前对其进行初始化。为了使实验效果更加明显，体现出临界区的作用，在线程函数对共享资源g_cArray[10]的写入时，以Sleep（）函数延迟1毫秒，使其他线程同其抢占CPU的可能性增大。如果不使用临界区对其进行保护，则共享资源数据将被破坏（参见图1（a）所示计算结果），而使用临界区对线程保持同步后则可以得到正确的结果（参见图1（b）所示计算结果）。代码实现清单附下：

// 临界区结构对象
CRITICAL_SECTION g_cs;
// 共享资源
char g_cArray[10];
UINT ThreadProc10(LPVOID pParam)
{
　// 进入临界区
　EnterCriticalSection(&g_cs);
　// 对共享资源进行写入操作
　for (int i = 0; i < 10; i++)
　{
　　g_cArray[i] = 'a';
　　Sleep(1);
　}
　// 离开临界区
　LeaveCriticalSection(&g_cs);
　return 0;
}
UINT ThreadProc11(LPVOID pParam)
{
　// 进入临界区
　EnterCriticalSection(&g_cs);
　// 对共享资源进行写入操作
　for (int i = 0; i < 10; i++)
　{
　　g_cArray[10 - i - 1] = 'b';
　　Sleep(1);
　}
　// 离开临界区
　LeaveCriticalSection(&g_cs);
　return 0;
}
……
void CSample08View::OnCriticalSection()
{
　// 初始化临界区
　InitializeCriticalSection(&g_cs);
　// 启动线程
　AfxBeginThread(ThreadProc10, NULL);
　AfxBeginThread(ThreadProc11, NULL);
　// 等待计算完毕
　Sleep(300);
　// 报告计算结果
　CString sResult = CString(g_cArray);
　AfxMessageBox(sResult);
}

　　在使用临界区时，一般不允许其运行时间过长，只要进入临界区的线程还没有离开，其他所有试图进入此临界区的线程都会被挂起而进入到等待状态，并会在一定程度上影响。程序的运行性能。尤其需要注意的是不要将等待用户输入或是其他一些外界干预的操作包含到临界区。如果进入了临界区却一直没有释放，同样也会引起其他线程的长时间等待。换句话说，在执行了EnterCriticalSection（）语句进入临界区后无论发生什么，必须确保与之匹配的LeaveCriticalSection（）都能够被执行到。可以通过添加结构化异常处理代码来确保LeaveCriticalSection（）语句的执行。虽然临界区同步速度很快，但却只能用来同步本进程内的线程，而不可用来同步多个进程中的线程。

　　MFC为临界区提供有一个CCriticalSection类，使用该类进行线程同步处理是非常简单的，只需在线程函数中用CCriticalSection类成员函数Lock（）和UnLock（）标定出被保护代码片段即可。对于上述代码，可通过CCriticalSection类将其改写如下：

// MFC临界区类对象
CCriticalSection g_clsCriticalSection;
// 共享资源
char g_cArray[10];
UINT ThreadProc20(LPVOID pParam)
{
　// 进入临界区
　g_clsCriticalSection.Lock();
　// 对共享资源进行写入操作
　for (int i = 0; i < 10; i++)
　{
　　g_cArray[i] = 'a';
　　Sleep(1);
　}
　// 离开临界区
　g_clsCriticalSection.Unlock();
　return 0;
}
UINT ThreadProc21(LPVOID pParam)
{
　// 进入临界区
　g_clsCriticalSection.Lock();
　// 对共享资源进行写入操作
　for (int i = 0; i < 10; i++)
　{
　　g_cArray[10 - i - 1] = 'b';
　　Sleep(1);
　}
　// 离开临界区
　g_clsCriticalSection.Unlock();
　return 0;
}
……
void CSample08View::OnCriticalSectionMfc()
{
　// 启动线程
　AfxBeginThread(ThreadProc20, NULL);
　AfxBeginThread(ThreadProc21, NULL);
　// 等待计算完毕
　Sleep(300);
　// 报告计算结果
　CString sResult = CString(g_cArray);
　AfxMessageBox(sResult);
}

管理事件内核对象

　　在前面讲述线程通信时曾使用过事件内核对象来进行线程间的通信，除此之外，事件内核对象也可以通过通知操作的方式来保持线程的同步。对于前面那段使用临界区保持线程同步的代码可用事件对象的线程同步方法改写如下：

// 事件句柄
HANDLE hEvent = NULL;
// 共享资源
char g_cArray[10];
……
UINT ThreadProc12(LPVOID pParam)
{
　// 等待事件置位
　WaitForSingleObject(hEvent, INFINITE);
　// 对共享资源进行写入操作
　for (int i = 0; i < 10; i++)
　{
　　g_cArray[i] = 'a';
　　Sleep(1);
　}
　// 处理完成后即将事件对象置位
　SetEvent(hEvent);
　return 0;
}
UINT ThreadProc13(LPVOID pParam)
{
　// 等待事件置位
　WaitForSingleObject(hEvent, INFINITE);
　// 对共享资源进行写入操作
　for (int i = 0; i < 10; i++)
　{
　　g_cArray[10 - i - 1] = 'b';
　　Sleep(1);
　}
　// 处理完成后即将事件对象置位
　SetEvent(hEvent);
　return 0;
}
……
void CSample08View::OnEvent()
{
　// 创建事件
　hEvent = CreateEvent(NULL, FALSE, FALSE, NULL);
　// 事件置位
　SetEvent(hEvent);
　// 启动线程
　AfxBeginThread(ThreadProc12, NULL);
　AfxBeginThread(ThreadProc13, NULL);
　// 等待计算完毕
　Sleep(300);
　// 报告计算结果
　CString sResult = CString(g_cArray);
　AfxMessageBox(sResult);
}

　　在创建线程前，首先创建一个可以自动复位的事件内核对象hEvent，而线程函数则通过WaitForSingleObject（）等待函数无限等待hEvent的置位，只有在事件置位时WaitForSingleObject（）才会返回，被保护的代码将得以执行。对于以自动复位方式创建的事件对象，在其置位后一被WaitForSingleObject（）等待到就会立即复位，也就是说在执行ThreadProc12（）中的受保护代码时，事件对象已经是复位状态的，这时即使有ThreadProc13（）对CPU的抢占，也会由于WaitForSingleObject（）没有hEvent的置位而不能继续执行，也就没有可能破坏受保护的共享资源。在ThreadProc12（）中的处理完成后可以通过SetEvent（）对hEvent的置位而允许ThreadProc13（）对共享资源g_cArray的处理。这里SetEvent（）所起的作用可以看作是对某项特定任务完成的通知。

　　使用临界区只能同步同一进程中的线程，而使用事件内核对象则可以对进程外的线程进行同步，其前提是得到对此事件对象的访问权。可以通过OpenEvent（）函数获取得到，其函数原型为：

HANDLE OpenEvent(
　DWORD dwDesiredAccess, // 访问标志
　BOOL bInheritHandle, // 继承标志
　LPCTSTR lpName // 指向事件对象名的指针
);

　　如果事件对象已创建（在创建事件时需要指定事件名），函数将返回指定事件的句柄。对于那些在创建事件时没有指定事件名的事件内核对象，可以通过使用内核对象的继承性或是调用DuplicateHandle（）函数来调用CreateEvent（）以获得对指定事件对象的访问权。在获取到访问权后所进行的同步操作与在同一个进程中所进行的线程同步操作是一样的。

　　如果需要在一个线程中等待多个事件，则用WaitForMultipleObjects（）来等待。WaitForMultipleObjects（）与WaitForSingleObject（）类似，同时监视位于句柄数组中的所有句柄。这些被监视对象的句柄享有平等的优先权，任何一个句柄都不可能比其他句柄具有更高的优先权。WaitForMultipleObjects（）的函数原型为：

DWORD WaitForMultipleObjects(
　DWORD nCount, // 等待句柄数
　CONST HANDLE *lpHandles, // 句柄数组首地址
　BOOL fWaitAll, // 等待标志
　DWORD dwMilliseconds // 等待时间间隔
);

　　参数nCount指定了要等待的内核对象的数目，存放这些内核对象的数组由lpHandles来指向。fWaitAll对指定的这nCount个内核对象的两种等待方式进行了指定，为TRUE时当所有对象都被通知时函数才会返回，为FALSE则只要其中任何一个得到通知就可以返回。dwMilliseconds在这里的作用与在WaitForSingleObject（）中的作用是完全一致的。如果等待超时，函数将返回WAIT_TIMEOUT。如果返回WAIT_OBJECT_0到WAIT_OBJECT_0+nCount-1中的某个值，则说明所有指定对象的状态均为已通知状态（当fWaitAll为TRUE时）或是用以减去WAIT_OBJECT_0而得到发生通知的对象的索引（当fWaitAll为FALSE时）。如果返回值在WAIT_ABANDONED_0与WAIT_ABANDONED_0+nCount-1之间，则表示所有指定对象的状态均为已通知，且其中至少有一个对象是被丢弃的互斥对象（当fWaitAll为TRUE时），或是用以减去WAIT_OBJECT_0表示一个等待正常结束的互斥对象的索引（当fWaitAll为FALSE时）。下面给出的代码主要展示了对WaitForMultipleObjects（）函数的使用。通过对两个事件内核对象的等待来控制线程任务的执行与中途退出：

// 存放事件句柄的数组
HANDLE hEvents[2];
UINT ThreadProc14(LPVOID pParam)
{
　// 等待开启事件
　DWORD dwRet1 = WaitForMultipleObjects(2, hEvents, FALSE, INFINITE);
　// 如果开启事件到达则线程开始执行任务
　if (dwRet1 == WAIT_OBJECT_0)
　{
　　AfxMessageBox("线程开始工作!");
　　while (true)
　　{
　　　for (int i = 0; i < 10000; i++);
　　　// 在任务处理过程中等待结束事件
　　　DWORD dwRet2 = WaitForMultipleObjects(2, hEvents, FALSE, 0);
　　　// 如果结束事件置位则立即终止任务的执行
　　　if (dwRet2 == WAIT_OBJECT_0 + 1)
　　　　break;
　　}
　}
　AfxMessageBox("线程退出!");
　return 0;
}
……
void CSample08View::OnStartEvent()
{
　// 创建线程
　for (int i = 0; i < 2; i++)
　　hEvents[i] = CreateEvent(NULL, FALSE, FALSE, NULL);
　　// 开启线程
　　AfxBeginThread(ThreadProc14, NULL);
　　// 设置事件0(开启事件)
　　SetEvent(hEvents[0]);
}
void CSample08View::OnEndevent()
{
　// 设置事件1(结束事件)
　SetEvent(hEvents[1]);
}

　　MFC为事件相关处理也提供了一个CEvent类，共包含有除构造函数外的4个成员函数PulseEvent（）、ResetEvent（）、SetEvent（）和UnLock（）。在功能上分别相当与Win32 API的PulseEvent（）、ResetEvent（）、SetEvent（）和CloseHandle（）等函数。而构造函数则履行了原CreateEvent（）函数创建事件对象的职责，其函数原型为：

CEvent(BOOL bInitiallyOwn = FALSE, BOOL bManualReset = FALSE, LPCTSTR lpszName = NULL, LPSECURITY_ATTRIBUTES lpsaAttribute = NULL );

　　按照此缺省设置将创建一个自动复位、初始状态为复位状态的没有名字的事件对象。封装后的CEvent类使用起来更加方便，图2即展示了CEvent类对A、B两线程的同步过程：

图2 CEvent类对线程的同步过程示意

　　B线程在执行到CEvent类成员函数Lock（）时将会发生阻塞，而A线程此时则可以在没有B线程干扰的情况下对共享资源进行处理，并在处理完成后通过成员函数SetEvent（）向B发出事件，使其被释放，得以对A先前已处理完毕的共享资源进行操作。可见，使用CEvent类对线程的同步方法与通过API函数进行线程同步的处理方法是基本一致的。前面的API处理代码可用CEvent类将其改写为：

// MFC事件类对象
CEvent g_clsEvent;
UINT ThreadProc22(LPVOID pParam)
{
　// 对共享资源进行写入操作
　for (int i = 0; i < 10; i++)
　{
　　g_cArray[i] = 'a';
　　Sleep(1);
　}
　// 事件置位
　g_clsEvent.SetEvent();
　return 0;
}
UINT ThreadProc23(LPVOID pParam)
{
　// 等待事件
　g_clsEvent.Lock();
　// 对共享资源进行写入操作
　for (int i = 0; i < 10; i++)
　{
　　g_cArray[10 - i - 1] = 'b';
　　Sleep(1);
　}
　return 0;
}
……
void CSample08View::OnEventMfc()
{
　// 启动线程
　AfxBeginThread(ThreadProc22, NULL);
　AfxBeginThread(ThreadProc23, NULL);
　// 等待计算完毕
　Sleep(300);
　// 报告计算结果
　CString sResult = CString(g_cArray);
　AfxMessageBox(sResult);
}

信号量内核对象

　　信号量（Semaphore）内核对象对线程的同步方式与前面几种方法不同，它允许多个线程在同一时刻访问同一资源，但是需要限制在同一时刻访问此资源的最大线程数目。在用CreateSemaphore（）创建信号量时即要同时指出允许的最大资源计数和当前可用资源计数。一般是将当前可用资源计数设置为最大资源计数，每增加一个线程对共享资源的访问，当前可用资源计数就会减1，只要当前可用资源计数是大于0的，就可以发出信号量信号。但是当前可用计数减小到0时则说明当前占用资源的线程数已经达到了所允许的最大数目，不能在允许其他线程的进入，此时的信号量信号将无法发出。线程在处理完共享资源后，应在离开的同时通过ReleaseSemaphore（）函数将当前可用资源计数加1。在任何时候当前可用资源计数决不可能大于最大资源计数。

图3 使用信号量对象控制资源

　　下面结合图例3来演示信号量对象对资源的控制。在图3中，以箭头和白色箭头表示共享资源所允许的最大资源计数和当前可用资源计数。初始如图（a）所示，最大资源计数和当前可用资源计数均为4，此后每增加一个对资源进行访问的线程（用黑色箭头表示）当前资源计数就会相应减1，图（b）即表示的在3个线程对共享资源进行访问时的状态。当进入线程数达到4个时，将如图（c）所示，此时已达到最大资源计数，而当前可用资源计数也已减到0，其他线程无法对共享资源进行访问。在当前占有资源的线程处理完毕而退出后，将会释放出空间，图（d）已有两个线程退出对资源的占有，当前可用计数为2，可以再允许2个线程进入到对资源的处理。可以看出，信号量是通过计数来对线程访问资源进行控制的，而实际上信号量确实也被称作Dijkstra计数器。

　　使用信号量内核对象进行线程同步主要会用到CreateSemaphore（）、OpenSemaphore（）、ReleaseSemaphore（）、WaitForSingleObject（）和WaitForMultipleObjects（）等函数。其中，CreateSemaphore（）用来创建一个信号量内核对象，其函数原型为：

HANDLE CreateSemaphore(
　LPSECURITY_ATTRIBUTES lpSemaphoreAttributes, // 安全属性指针
　LONG lInitialCount, // 初始计数
　LONG lMaximumCount, // 最大计数
　LPCTSTR lpName // 对象名指针
);

　　参数lMaximumCount是一个有符号32位值，定义了允许的最大资源计数，最大取值不能超过4294967295。lpName参数可以为创建的信号量定义一个名字，由于其创建的是一个内核对象，因此在其他进程中可以通过该名字而得到此信号量。OpenSemaphore（）函数即可用来根据信号量名打开在其他进程中创建的信号量，函数原型如下：

HANDLE OpenSemaphore(
　DWORD dwDesiredAccess, // 访问标志
　BOOL bInheritHandle, // 继承标志
　LPCTSTR lpName // 信号量名
);

　　在线程离开对共享资源的处理时，必须通过ReleaseSemaphore（）来增加当前可用资源计数。否则将会出现当前正在处理共享资源的实际线程数并没有达到要限制的数值，而其他线程却因为当前可用资源计数为0而仍无法进入的情况。ReleaseSemaphore（）的函数原型为：

BOOL ReleaseSemaphore(
　HANDLE hSemaphore, // 信号量句柄
　LONG lReleaseCount, // 计数递增数量
　LPLONG lpPreviousCount // 先前计数
);

　　该函数将lReleaseCount中的值添加给信号量的当前资源计数，一般将lReleaseCount设置为1，如果需要也可以设置其他的值。WaitForSingleObject（）和WaitForMultipleObjects（）主要用在试图进入共享资源的线程函数入口处，主要用来判断信号量的当前可用资源计数是否允许本线程的进入。只有在当前可用资源计数值大于0时，被监视的信号量内核对象才会得到通知。

　　信号量的使用特点使其更适用于对Socket（套接字）程序中线程的同步。例如，网络上的HTTP服务器要对同一时间内访问同一页面的用户数加以限制，这时可以为没一个用户对服务器的页面请求设置一个线程，而页面则是待保护的共享资源，通过使用信号量对线程的同步作用可以确保在任一时刻无论有多少用户对某一页面进行访问，只有不大于设定的最大用户数目的线程能够进行访问，而其他的访问企图则被挂起，只有在有用户退出对此页面的访问后才有可能进入。下面给出的示例代码即展示了类似的处理过程：

// 信号量对象句柄
HANDLE hSemaphore;
UINT ThreadProc15(LPVOID pParam)
{
　// 试图进入信号量关口
　WaitForSingleObject(hSemaphore, INFINITE);
　// 线程任务处理
　AfxMessageBox("线程一正在执行!");
　// 释放信号量计数
　ReleaseSemaphore(hSemaphore, 1, NULL);
　return 0;
}
UINT ThreadProc16(LPVOID pParam)
{
　// 试图进入信号量关口
　WaitForSingleObject(hSemaphore, INFINITE);
　// 线程任务处理
　AfxMessageBox("线程二正在执行!");
　// 释放信号量计数
　ReleaseSemaphore(hSemaphore, 1, NULL);
　return 0;
}
UINT ThreadProc17(LPVOID pParam)
{
　// 试图进入信号量关口
　WaitForSingleObject(hSemaphore, INFINITE);
　// 线程任务处理
　AfxMessageBox("线程三正在执行!");
　// 释放信号量计数
　ReleaseSemaphore(hSemaphore, 1, NULL);
　return 0;
}
……
void CSample08View::OnSemaphore()
{
　// 创建信号量对象
　hSemaphore = CreateSemaphore(NULL, 2, 2, NULL);
　// 开启线程
　AfxBeginThread(ThreadProc15, NULL);
　AfxBeginThread(ThreadProc16, NULL);
　AfxBeginThread(ThreadProc17, NULL);
}

图4 开始进入的两个线程

图5 线程二退出后线程三才得以进入

　　上述代码在开启线程前首先创建了一个初始计数和最大资源计数均为2的信号量对象hSemaphore。即在同一时刻只允许2个线程进入由hSemaphore保护的共享资源。随后开启的三个线程均试图访问此共享资源，在前两个线程试图访问共享资源时，由于hSemaphore的当前可用资源计数分别为2和1，此时的hSemaphore是可以得到通知的，也就是说位于线程入口处的WaitForSingleObject（）将立即返回，而在前两个线程进入到保护区域后，hSemaphore的当前资源计数减少到0，hSemaphore将不再得到通知，WaitForSingleObject（）将线程挂起。直到此前进入到保护区的线程退出后才能得以进入。图4和图5为上述代脉的运行结果。从实验结果可以看出，信号量始终保持了同一时刻不超过2个线程的进入。

　　在MFC中，通过CSemaphore类对信号量作了表述。该类只具有一个构造函数，可以构造一个信号量对象，并对初始资源计数、最大资源计数、对象名和安全属性等进行初始化，其原型如下：

CSemaphore( LONG lInitialCount = 1, LONG lMaxCount = 1, LPCTSTR pstrName = NULL, LPSECURITY_ATTRIBUTES lpsaAttributes = NULL );

　　在构造了CSemaphore类对象后，任何一个访问受保护共享资源的线程都必须通过CSemaphore从父类CSyncObject类继承得到的Lock（）和UnLock（）成员函数来访问或释放CSemaphore对象。与前面介绍的几种通过MFC类保持线程同步的方法类似，通过CSemaphore类也可以将前面的线程同步代码进行改写，这两种使用信号量的线程同步方法无论是在实现原理上还是从实现结果上都是完全一致的。下面给出经MFC改写后的信号量线程同步代码：

// MFC信号量类对象
CSemaphore g_clsSemaphore(2, 2);
UINT ThreadProc24(LPVOID pParam)
{
　// 试图进入信号量关口
　g_clsSemaphore.Lock();
　// 线程任务处理
　AfxMessageBox("线程一正在执行!");
　// 释放信号量计数
　g_clsSemaphore.Unlock();
　return 0;
}
UINT ThreadProc25(LPVOID pParam)
{
　// 试图进入信号量关口
　g_clsSemaphore.Lock();
　// 线程任务处理
　AfxMessageBox("线程二正在执行!");
　// 释放信号量计数
　g_clsSemaphore.Unlock();
　return 0;
}
UINT ThreadProc26(LPVOID pParam)
{
　// 试图进入信号量关口
　g_clsSemaphore.Lock();
　// 线程任务处理
　AfxMessageBox("线程三正在执行!");
　// 释放信号量计数
　g_clsSemaphore.Unlock();
　return 0;
}
……
void CSample08View::OnSemaphoreMfc()
{
　// 开启线程
　AfxBeginThread(ThreadProc24, NULL);
　AfxBeginThread(ThreadProc25, NULL);
　AfxBeginThread(ThreadProc26, NULL);
}

互斥内核对象

　　互斥（Mutex）是一种用途非常广泛的内核对象。能够保证多个线程对同一共享资源的互斥访问。同临界区有些类似，只有拥有互斥对象的线程才具有访问资源的权限，由于互斥对象只有一个，因此就决定了任何情况下此共享资源都不会同时被多个线程所访问。当前占据资源的线程在任务处理完后应将拥有的互斥对象交出，以便其他线程在获得后得以访问资源。与其他几种内核对象不同，互斥对象在操作系统中拥有特殊代码，并由操作系统来管理，操作系统甚至还允许其进行一些其他内核对象所不能进行的非常规操作。为便于理解，可参照图6给出的互斥内核对象的工作模型：

图6 使用互斥内核对象对共享资源的保护

　　图（a）中的箭头为要访问资源（矩形框）的线程，但只有第二个线程拥有互斥对象（黑点）并得以进入到共享资源，而其他线程则会被排斥在外（如图（b）所示）。当此线程处理完共享资源并准备离开此区域时将把其所拥有的互斥对象交出（如图（c）所示），其他任何一个试图访问此资源的线程都有机会得到此互斥对象。

　　以互斥内核对象来保持线程同步可能用到的函数主要有CreateMutex（）、OpenMutex（）、ReleaseMutex（）、WaitForSingleObject（）和WaitForMultipleObjects（）等。在使用互斥对象前，首先要通过CreateMutex（）或OpenMutex（）创建或打开一个互斥对象。CreateMutex（）函数原型为：

HANDLE CreateMutex(
　LPSECURITY_ATTRIBUTES lpMutexAttributes, // 安全属性指针
　BOOL bInitialOwner, // 初始拥有者
　LPCTSTR lpName // 互斥对象名
);

　　参数bInitialOwner主要用来控制互斥对象的初始状态。一般多将其设置为FALSE，以表明互斥对象在创建时并没有为任何线程所占有。如果在创建互斥对象时指定了对象名，那么可以在本进程其他地方或是在其他进程通过OpenMutex（）函数得到此互斥对象的句柄。OpenMutex（）函数原型为：

HANDLE OpenMutex(
　DWORD dwDesiredAccess, // 访问标志
　BOOL bInheritHandle, // 继承标志
　LPCTSTR lpName // 互斥对象名
);

　　当目前对资源具有访问权的线程不再需要访问此资源而要离开时，必须通过ReleaseMutex（）函数来释放其拥有的互斥对象，其函数原型为：

BOOL ReleaseMutex(HANDLE hMutex);

　　其唯一的参数hMutex为待释放的互斥对象句柄。至于WaitForSingleObject（）和WaitForMultipleObjects（）等待函数在互斥对象保持线程同步中所起的作用与在其他内核对象中的作用是基本一致的，也是等待互斥内核对象的通知。但是这里需要特别指出的是：在互斥对象通知引起调用等待函数返回时，等待函数的返回值不再是通常的WAIT_OBJECT_0（对于WaitForSingleObject（）函数）或是在WAIT_OBJECT_0到WAIT_OBJECT_0+nCount-1之间的一个值（对于WaitForMultipleObjects（）函数），而是将返回一个WAIT_ABANDONED_0（对于WaitForSingleObject（）函数）或是在WAIT_ABANDONED_0到WAIT_ABANDONED_0+nCount-1之间的一个值（对于WaitForMultipleObjects（）函数）。以此来表明线程正在等待的互斥对象由另外一个线程所拥有，而此线程却在使用完共享资源前就已经终止。除此之外，使用互斥对象的方法在等待线程的可调度性上同使用其他几种内核对象的方法也有所不同，其他内核对象在没有得到通知时，受调用等待函数的作用，线程将会挂起，同时失去可调度性，而使用互斥的方法却可以在等待的同时仍具有可调度性，这也正是互斥对象所能完成的非常规操作之一。

　　在编写程序时，互斥对象多用在对那些为多个线程所访问的内存块的保护上，可以确保任何线程在处理此内存块时都对其拥有可靠的独占访问权。下面给出的示例代码即通过互斥内核对象hMutex对共享内存快g_cArray[]进行线程的独占访问保护。下面给出实现代码清单：

// 互斥对象
HANDLE hMutex = NULL;
char g_cArray[10];
UINT ThreadProc18(LPVOID pParam)
{
　// 等待互斥对象通知
　WaitForSingleObject(hMutex, INFINITE);
　// 对共享资源进行写入操作
　for (int i = 0; i < 10; i++)
　{
　　g_cArray[i] = 'a';
　　Sleep(1);
　}
　// 释放互斥对象
　ReleaseMutex(hMutex);
　return 0;
}
UINT ThreadProc19(LPVOID pParam)
{
　// 等待互斥对象通知
　WaitForSingleObject(hMutex, INFINITE);
　// 对共享资源进行写入操作
　for (int i = 0; i < 10; i++)
　{
　　g_cArray[10 - i - 1] = 'b';
　　Sleep(1);
　}
　// 释放互斥对象
　ReleaseMutex(hMutex);
　return 0;
}
……
void CSample08View::OnMutex()
{
　// 创建互斥对象
　hMutex = CreateMutex(NULL, FALSE, NULL);
　// 启动线程
　AfxBeginThread(ThreadProc18, NULL);
　AfxBeginThread(ThreadProc19, NULL);
　// 等待计算完毕
　Sleep(300);
　// 报告计算结果
　CString sResult = CString(g_cArray);
　AfxMessageBox(sResult);
}

　　互斥对象在MFC中通过CMutex类进行表述。使用CMutex类的方法非常简单，在构造CMutex类对象的同时可以指明待查询的互斥对象的名字，在构造函数返回后即可访问此互斥变量。CMutex类也是只含有构造函数这唯一的成员函数，当完成对互斥对象保护资源的访问后，可通过调用从父类CSyncObject继承的UnLock（）函数完成对互斥对象的释放。CMutex类构造函数原型为：

CMutex( BOOL bInitiallyOwn = FALSE, LPCTSTR lpszName = NULL, LPSECURITY_ATTRIBUTES lpsaAttribute = NULL );

　　该类的适用范围和实现原理与API方式创建的互斥内核对象是完全类似的，但要简洁的多，下面给出就是对前面的示例代码经CMutex类改写后的程序实现清单：

// MFC互斥类对象
CMutex g_clsMutex(FALSE, NULL);
UINT ThreadProc27(LPVOID pParam)
{
　// 等待互斥对象通知
　g_clsMutex.Lock();
　// 对共享资源进行写入操作
　for (int i = 0; i < 10; i++)
　{
　　g_cArray[i] = 'a';
　　Sleep(1);
　}
　// 释放互斥对象
　g_clsMutex.Unlock();
　return 0;
}
UINT ThreadProc28(LPVOID pParam)
{
　// 等待互斥对象通知
　g_clsMutex.Lock();
　// 对共享资源进行写入操作
　for (int i = 0; i < 10; i++)
　{
　　g_cArray[10 - i - 1] = 'b';
　　Sleep(1);
　}
　// 释放互斥对象
　g_clsMutex.Unlock();
　return 0;
}
……
void CSample08View::OnMutexMfc()
{
　// 启动线程
　AfxBeginThread(ThreadProc27, NULL);
　AfxBeginThread(ThreadProc28, NULL);
　// 等待计算完毕
　Sleep(300);
　// 报告计算结果
　CString sResult = CString(g_cArray);
　AfxMessageBox(sResult);
}

　　小结

　　线程的使用使程序处理更够更加灵活，而这种灵活同样也会带来各种不确定性的可能。尤其是在多个线程对同一公共变量进行访问时。虽然未使用线程同步的程序代码在逻辑上或许没有什么问题，但为了确保程序的正确、可靠运行，必须在适当的场合采取线程同步措施。

思勤无邪 2006-10-10 16:14 发表评论

大、小写字母相互转换

思勤无邪 — Mon, 09 Oct 2006 05:31:00 GMT

其实主要是围绕着大、小写字母之间那个32的关系（小写字母减去32得到对应的大写字母，相反，大写字母加上32得到对应的小写字母）。

通常方法：

if(ch>='a'&&ch<='z')
ch=ch-32;
else if(ch>='A'&&ch<='Z')
ch=ch+32;

   上面的方法都有点罗嗦，采用异或运算：

   if(isalpha(ch))   //库函数isalpha用来测试参数是否为英文字母
      ch=ch^32;    //异或运算

思勤无邪 2006-10-09 13:31 发表评论

杨辉三角

思勤无邪 — Mon, 09 Oct 2006 03:06:00 GMT

杨辉三角具有以下形式，规律为除两侧的元素均为1以外，其余每个位置上数值都等于其左上角元素与右上角元素之和：

            1
          1   1
        1   2   1
      1   3   3   1
    1   4   6   4   1
1   5 10 10   5 1

上面的形式不适于用程序实现，往往都改写成下面的形式，规律为除两侧元素均为1以外，其余每个位置上的元素值为其正上方元素与左上角元素之和，用数组来描述则为a[i][j]=a[i-1][j]+a[i-1][j-1]：

1
1   1
1   2   1
1   3   3   1
1   4   6   4   1
1   5 10 10 5 1

// 杨辉三角的C++实现
// 未判断 int 溢出
// VS2005下编译通过
#include < iostream >
#include < iomanip >

using namespace std;

int prompt()
{
     int n;
    cout << " Input a positive number, " << endl
         << " nonpositive will quit! " << endl
         << " > " ;
    cin >> n;
     return n;
}

void main()
{
     int i, j, n;

     while ((n = prompt()) > 0 )
     {
         int ** a = new int * [n];

         for (i = 0 ; i < n; i ++ )
         {
            a[i] = new int [i + 1 ];
             // 两侧元素均为1
            a[i][i] = a[i][ 0 ] = 1 ;
             for (j = 1 ; j < i; j ++ )
             {
                a[i][j] = a[i - 1 ][j] + a[i - 1 ][j - 1 ];
            }
        }
         for (i = 0 ; i < n; i ++ )
         {
             for (j = 0 ; j <= i; j ++ )
                cout << setw( 80 / n) << a[i][j];
            cout << endl;
            delete[] a[i];
        }
        delete []a;
    }
}

思勤无邪 2006-10-09 11:06 发表评论

将动态二维数组的函数模板封成了类

思勤无邪 — Thu, 28 Sep 2006 07:44:00 GMT

将上一篇的动态数组的函数模板封成了类，但没有错误处理等。

#include < iostream >
#include < string >

using namespace std;

template < class T >
class TDArray
{
public :
    TDArray( int rows, int cols);
     ~ TDArray();
    template < class Tt > friend ostream & operator << ( ostream & output, const TDArray < Tt >& tdArray );
    T * operator []( int rows);

private :
     void Init();
    T ** p;
     int m_rows;
     int m_cols;
} ;

template < class T >
TDArray < T > ::TDArray( int rows, int cols)
{
    m_rows = rows;
    m_cols = cols;
     // 创建行指针
    p = new T * [rows];
     // 为每一行分配空间
     for ( int i = 0 ; i < rows; ++ i)
     {
        p[i] = new T[cols];
    }
     // 初始化
    Init();
}

template < class T >
TDArray < T > :: ~ TDArray()
{
     for ( int x = 0 ; x < m_rows; ++ x)
     {
        delete[] p[x];
    }
    delete[] p;
    p = 0 ;
}

template < class T >
inline void TDArray < T > ::Init()
{
     for ( int x = 0 ; x < m_rows; ++ x)
     {
         for ( int y = 0 ; y < m_cols; ++ y)
         {
            p[x][y] = T();
        }
    }
}

template < class T >
ostream & operator << ( ostream & output, const TDArray < T >& tdArray )
{
     for ( int x = 0 ; x < tdArray.m_rows; ++ x)
     {
         for ( int y = 0 ; y < tdArray.m_cols; ++ y)
         {
            output << " [ " << x << " ][ " << y << " ] " << tdArray.p[x][y] << " " ;
        }
        output << endl;
    }
     return output;
}

template < class T >
inline T * TDArray < T > :: operator []( int rows)
{
     return p[rows];
}
int main( void )
{
    TDArray < int > iArray = TDArray < int > ( 2 , 3 );
    iArray[ 1 ][ 0 ] = 100 ;
    cout << iArray;

    system( " pause " );
     return 0 ;
}

思勤无邪 2006-09-28 15:44 发表评论

写了一个二维动态数组的函数模板

思勤无邪 — Thu, 28 Sep 2006 01:58:00 GMT

写了一个二维动态数组的函数模板，可以将它封成类使用。

#include <iostream>
#include <string>

using namespace std;

// 初始化动态数组
template<class T>
void Init2DArray(T** &p, int rows, int cols)
{
    for (int x=0; x<rows; ++x)
    {
        for (int y=0; y<cols; ++y)
        {
            p[x][y] = T();
        }
    }
}

// 动态创建 2 维数组模板
template<class T>
void Create2DArray(T** &p, int rows, int cols)
{
    // 创建行指针
    p = new T* [rows];
    // 为每一行分配空间
    for (int i=0; i<rows; ++i)
    {
        p[i] = new T[cols];
    }
    // 初始化
    Init2DArray(p, rows, cols);
}

// 删除动态数组
template<class T>
void Delete2DArray(T** &p, int rows)
{
    // 释放每一行的空间
    for (int i=0; i<rows; ++i)
    {
        delete[] p[i];
    }
    // 删除指针
    delete[] p;
    p = 0;
}

// 显示动态数组
template<class T>
void Show2DArray(T** &p, int rows, int cols, string arrayName = "p")
{
    for (int x=0; x<rows; ++x)
    {
        for (int y=0; y<cols; ++y)
        {
            cout << arrayName << "[" << x << "][" << y << "] = " << p[x][y] << " ";
        }
        cout << endl;
    }
}

int main(void)
{
    // 测试模板函数
    int **pInt;
    char **pChar;
    float **pFloat;
    int rows = 10;
    int cols = 5;
    Create2DArray(pInt, rows, cols);
    pInt[2][3] = 6;
    pInt[8][4] = 32;
    Show2DArray(pInt, rows, cols, "pInt");
    Delete2DArray(pInt, rows);

    Create2DArray(pChar, rows, cols);
    Show2DArray(pChar, rows, cols, "pChar");
    Delete2DArray(pChar, rows);

    Create2DArray(pFloat, rows, cols);
    Show2DArray(pFloat, rows, cols, "pFloat");
    Delete2DArray(pFloat, rows);

    system("pause");
    return 0;
}

思勤无邪 2006-09-28 09:58 发表评论

Bjarne Stroustrup语录[C++经验]

思勤无邪 — Thu, 28 Sep 2006 00:23:00 GMT

摘录自Bjarne Stroustrup 的《The C++ Programming Language》(Special Edition)

一、致读者

1．  在编程序时，你是在为你针对某个问题的解决方案中的思想建立起一种具体表示。让程序的结构尽可能地直接反映这些思想：
   ★.如果你能把“它”看成一个独立的概念，就把它做成一个类。
   ★.如果你能把“它”看成一个独立的实体，就把它做成某个类的一个对象。
   ★.如果两个类有共同的Interface，将此Interface做成一个抽象类。
   ★.如果两个类的实现有某些显著的共同东西，将这些共性做成一个基类。
   ★.如果一个类是一种对象的容器，将它做成一个模板。
   ★.如果一个函数实现对某容器的一个算法，将它做成为对一族容器可用的模板函数。
   ★.如果一组类、模板等相互之间有逻辑联系，将它们放进一个名字空间里。

2．  在你定义一个并不是实现某个像矩阵或复数这样的数学对象的类时，或者定义一个低层的类型如链接表的时候：
   ★.不要使用全局数据（使用成员）。
   ★.不要使用全局函数。
   ★.不要使用公用数据成员。
   ★.不要使用友元，除非为了避免a或c。
   ★.不要在一个类里面放“类型域”（指那种为了说明一个类所存储数据的情况而放置的标志域）；采用虚函数。
   ★.不要使用在线函数(inline function)，除非作为效果显著的优化。

二、C++ 概览

1．  不用害怕，一切都会随着时间的推移而逐渐明朗起来。
2．  你并不需要在知道了C++的所有细节之后才能写出好的C++程序。
3．  请特别关注程序设计技术，而不是各种语言特征。

三、标准库概览

1．  不要像重新发明车轮那样企图做每件事；去使用库。
2．  不要相信奇迹；要理解你的库能做什么，它们如何做，它们做时需要多大的代价。
3．  当你遇到一个选择时，应该优先选择标准库而不是其他的库。
4．  不要认为标准库对于任何事情都是最理想的。
5．  切记#include 你所用到的功能的头文件。
6．  记住，标准库的功能定义在名字空间std之中。
7．  请用string，而不是char*。
8．  如果怀疑，就用一个检查区间范围的向量（例如Vec）。
9．  vector 、list和 map 都比T[] 好。
10．如果向一个容器中添加一个元素，用push_back() 或 back_inserter()。
11．采用对vector的push_back()，而不是对数组的realloc()。
12．在main()中捕捉公共的异常。

四、类型和声明

1．  保持较小的作用域。
2．  不要在一个作用域和它外围的作用域里采用同样的名字。
3．  在一个声明中只声明一个名字。
4．  让常用的和局部的名字比较短，让不常用的和全局的名字比较长。
5．  避免看起来类似的名字。
6．  维持某种统一的命名风格。
7．  仔细选择名字，反映其意义而不是反映实现方式。
8．  如果所用的内部类型表示某种可能变化的值，请用typedef 为它定义一个有意义的名字。
9．  用typedef为类型定义同义词，用枚举或类去定义新类型。
10．切记每个声明中都必须描述一个类型（没有“隐式的int”）。
11．避免有关字符数值的不必要假设。
12．避免有关整数大小的不必要假设。
13．避免有关浮点类型表示范围的不必要假设。
14．优先使用普通的int 而不是short int 或者long int。
15．优先使用double 而不是float 或者long double。
16．优先使用普通的 char 而不是 signed char或者 unsigned char。
17．避免做出有关对象大小的不必要假设。
18．避免无符号算术。
19．应该带着疑问去看待从signed 到unsigned ，或者从unsigned 到signed 的转换。
20．应该带着疑问去看待从浮点到整型的转换。
21．应该带着疑问去看待向较小类型的转换，如将int转换到char。

五、忠告

1．  避免非平凡的指针算术。
2．  当心，不要超出数组的界线去写。
3．  尽量使用0而不是NULL。
4．  尽量使用vector 和valarray ，而不是内部（C风格）的数组。
5．  尽量使用string而不是以0结尾的char 数组。
6．  尽量少用普通的引用参数。
7．  避免 void*，除了在某些低级代码里。
8．  避免在代码中使用非平凡的文字量（“神秘的数”）。相反，应该定义和使用各种符号常量。

思勤无邪 2006-09-28 08:23 发表评论

对指针的认识

思勤无邪 — Thu, 10 Aug 2006 01:56:00 GMT

对指针的认识：

每个指针都有一个相关的类型。不同数据类型的指针之间的区别不是在指针的表示上，也不在指针所持有的值（地址）上——对所有类型的指针这两方面都是相同的。不同之处在于指针所指的对象的类型上。指针的类型可以指示编译器怎样解释特定地址上内存的内容，以及该内存区域应该跨越多少内存单元。当指针持有0值时，表明它没有指向任何对象。

指针不能被初始化或赋值为其他类型对象的地址值。例如：不是说int类型的指针在物理上不能持有与double相关联内存的地址，它能够。但是不允许，因为虽然int型的指针和double型的指针能够持有同样的地址值，但对那块内存的存储布局和内容的解释却完全不同。

当然，如果我们要做的仅仅是持有地址值（可能是把一个地址同另一个地址作比较），那么指针的实际类型就不重要了。C++提供了一种特殊的指针类型来支持这种需求：空（void*）类型指针，它可以被任何数据指针类型的地址值赋值（函数指针不能赋值给它）。

void*表明相关的值是个地址，但该地址的对象类型不知道。我们不能够操作空类型指针所指向的对象，只能传送该地址值或将它与其他地址值作比较。

指针可以让它的地址值增加或减少一个整数值，例如：加法指针加2意味着给指针持有的地址值增加了该类型两个对象的长度。

思勤无邪 2006-08-10 09:56 发表评论

Unicode初探

思勤无邪 — Tue, 08 Aug 2006 04:10:00 GMT

Char数据型态

假定我们都非常熟悉在C程序中使用char数据型态来定义和储存字符跟字符串。但为了便于理解C如何处理宽字符，让我们先回顾一下可能在Win32程序中出现的标准字符定义。

下面的语句定义并初始化了一个只包含一个字符的变量：

char c = 'A' ;

变量c需要1个字节来保存，并将用十六进制数0x41初始化，这是字母A的ASCII代码。

您可以像这样定义一个指向字符串的指针：

char * p ;

因为Windows是一个32位操作系统，所以指针变量p需要用4个字节保存。您还可初始化一个指向字符串的指针：

char * p = "Hello!" ;

像前面一样，变量p也需要用4个字节保存。该字符串保存在静态内存中并占用7个字节－6个字节保存字符串，另1个字节保存终止符号0。

您还可以像这样定义字符数组：

char a[10] ;

在这种情况下，编译器为该数组保留了10个字节的储存空间。表达式sizeof（a）将返回10。如果数组是整体变量（即在所有函数外定义），您可使用像下面的语句来初始化一个字符数组：

char a[] = "Hello!" ;

如果您将该数组定义为一个函数的区域变量，则必须将它定义为一个static变量，如下：

static char a[] = "Hello!" ;

无论哪种情况，字符串都储存在静态程序内存中，并在末尾添加0，这样就需要7个字节的储存空间。

宽字符

Unicode或者宽字符都没有改变char数据型态在C中的含义。char继续表示1个字节的储存空间，sizeof （char）继续返回1。理论上，C中1个字节可比8位长，但对我们大多数人来说，1个字节（也就是1个char）是8位宽。

C中的宽字符基于wchar_t数据型态，它在几个表头文件包括WCHAR.H中都有定义，像这样：

typedef unsigned short wchar_t ;

因此，wchar_t数据型态与无符号短整数型态相同，都是16位宽。

要定义包含一个宽字符的变量，可使用下面的语句：

wchar_t c = 'A' ;

变量c是一个双字节值0x0041，是Unicode表示的字母A。（然而，因为Intel微处理器从最小的字节开始储存多字节数值，该字节实际上是以0x41、0x00的顺序保存在内存中。如果检查Unicode文字的计算机储存应注意这一点。）

您还可定义指向宽字符串的指针：

wchar_t * p = L"Hello!" ;

注意紧接在第一个引号前面的大写字母L（代表「long」）。这将告诉编译器该字符串按宽字符保存－即每个字符占用2个字节。通常，指针变量p要占用4个字节，而字符串变量需要14个字节－每个字符需要2个字节，末尾的0还需要2个字节。

同样，您还可以用下面的语句定义宽字符数组：

static wchar_t a[] = L"Hello!" ;

该字符串也需要14个字节的储存空间，sizeof (a) 将返回14。索引数组a可得到单独的字符。a[1] 的值是宽字符「e」，或者0x0065。

虽然看上去更像一个印刷符号，但第一个引号前面的L非常重要，并且在两个符号之间必须没有空格。只有带有L，编译器才知道您需要将字符串存为每个字符2字节。稍后，当我们看到使用宽字符串而不是变量定义时，您还会遇到第一个引号前面的L。幸运的是，如果忘记了包含L，C编译器通常会给提出警告或错误信息。

您还可在单个字符文字前面使用L前缀，来表示它们应解释为宽字符。如下所示：

wchar_t c = L'A' ;

但通常这是不必要的，C编译器会对该字符进行扩充，使它成为宽字符。

宽字符链接库函数

我们都知道如何获得字符串的长度。例如，如果我们已经像下面这样定义了一个字符串指针：

char * pc = "Hello!" ;

我们可以呼叫

iLength = strlen (pc) ;

这时变量iLength将等于6，也就是字符串中的字符数。

太好了！现在让我们试着定义一个指向宽字符的指针：

wchar_t * pw = L"Hello!" ;

再次呼叫strlen ：

iLength = strlen (pw) ;

现在麻烦来了。首先，C编译器会显示一条警告消息，可能是这样的内容：

'function' : incompatible types - from 'unsigned short *' to 'const char *'

这条消息的意思是：声明strlen函数时，该函数应接收char类型的指标，但它现在却接收了一个unsigned short类型的指标。您仍然可编译并执行该程序，但您会发现iLength等于1。为什么？

字符串「Hello!」中的6个字符占用16位：

0x0048 0x0065 0x006C 0x006C 0x006F 0x0021

Intel处理器在内存中将其存为：

48 00 65 00 6C 00 6C 00 6F 00 21 00

假定strlen函数正试图得到一个字符串的长度，并把第1个字节作为字符开始计数，但接着假定如果下一个字节是0，则表示字符串结束。

这个小练习清楚地说明了C语言本身和执行时期链接库函数之间的区别。编译器将字符串L"Hello!" 解释为一组16位短整数型态数据，并将其保存在wchar_t数组中。编译器还处理数组索引和sizeof操作符，因此这些都能正常工作，但在连结时才添加执行时期链接库函数，例如strlen。这些函数认为字符串由单字节字符组成。遇到宽字符串时，函数就不像我们所希望那样执行了。

您可能要说：「噢，太麻烦了！」现在每个C语言链接库函数都必须重写以接受宽字符。但事实上并不是每个C语言链接库函数都需要重写，只是那些有字符串参数的函数才需要重写，而且也不用由您来完成。它们已经重写完了。

strlen函数的宽字符版是wcslen（wide-character string length：宽字符串长度），并且在STRING.H（其中也说明了strlen）和WCHAR.H中均有说明。strlen函数说明如下：

size_t __cdecl strlen (const char *) ;

而wcslen函数则说明如下：

size_t __cdecl wcslen (const wchar_t *) ;

这时我们知道，要得到宽字符串的长度可以呼叫

iLength = wcslen (pw) ;

函数将返回字符串中的字符数6。请记住，改成宽字节后，字符串的字符长度不改变，只是位组长度改变了。

您熟悉的所有带有字符串参数的C执行时期链接库函数都有宽字符版。例如，wprintf是printf的宽字符版。这些函数在WCHAR.H和含有标准函数说明的表头文件中说明。

思勤无邪 2006-08-08 12:10 发表评论

匈牙利命名法规则

思勤无邪 — Tue, 08 Aug 2006 02:01:00 GMT

摘要: 　　一般情况下，变量的取名方式为： + + 。　　范围前缀_，类型前缀_，限定词。特殊的类型命名,前缀表示：　　类、接口前缀 ... 阅读全文

思勤无邪 2006-08-08 10:01 发表评论

MFC的类层次结构图

思勤无邪 — Wed, 12 Jul 2006 07:27:00 GMT

整理资料，看到几张MFC的类层次结构图。也来看看MFC的发展吧：

思勤无邪 2006-07-12 15:27 发表评论

MFC编程综述

思勤无邪 — Tue, 11 Jul 2006 01:54:00 GMT

摘一段以前的文章，原文作者：苟建兵清华大学热能系(北京，100084)。原文很长，这里只摘了一段。

采用MFC开发Windows程序之所以能够大幅度提高开发速度和效率主要是因为MFC在类
层次封装了大量Windows SDK函数和典型Windows应用的缺省处理，这样，用户只需
要较少的编程就可以实现自己的开发任务。如果在MFC基础上再配合Visual C++提供
的AppWizard、ClassWizard和AppStudio工具那么更可以大幅度加快开发进程。MFC
提供大量的基类供程序员使用，常见的如CWinApp类、CFrameWnd类、CMDIFrameWnd
类、CMDIChildWnd类、CView类、CDC类和CDocument类等等。通过从这些基类中派生
出用户自己的类，然后重载特殊的几个函数就可以生成一个独立的应用程序。可以
说，采用MFC编写Windows应用程序是非常方便的，虽然其学习过程并不简单，但是
其提供的灵活高效性足以使任何Windows程序开发人员为之付出努力。如果用户不曾
使用过MFC，那么用户可以通过附录中所列的参考书去学习MFC的强大功能。
采用MFC应用框架产生的应用程序使用了标准化的结构，因而使得采用MFC编写的程
序的在不同平台上的移植变得非常容易，事实上，MFC的16位和32位版本之间差别很
小。MFC提供的标准化结构是经过众多专家分析调研后总结编写出来的，一般情况下
可以满足绝大多数用户的要求，但有时用户也可以通过重载一些函数来修改其缺省
的风格从而实现自己特有的风格，如自定义应用图表和灰色背景等。在MFC提供的文
档视结构中，文档、视和资源之间的联系是通过定义文档模板来实现的，如：
m_pSimuTemplate = new CMultiDocTemplate(
IDR_SIMUTYPE,
RUNTIME_CLASS(CSimuDoc),
RUNTIME_CLASS(CMyChild), // Derived MDI child frame
RUNTIME_CLASS(CSimuView));
上中第一项IDR_SIMUTYPE就包括了视口的菜单，加速键和图表等资源，如果用户使
用AppWizard来产生的应用基本框架，那么其也同时产生了缺省的图标，如果用户不
满意缺省图标（实际上用户很少满足于缺省图标），只需要将缺省图标删除，然后
编辑或者直接引入一个新的图标，在存储这一图标时只需要使用与被删除图标同样
的ID即可实现替代。
熟悉Windows程序开发的人都知道，在Windows上通过使用灰色背景可以增强应用程
序的视觉效果，曾有人戏称，灰色是图形界面永恒的颜色。使用MFC产生的应用程序
的背景缺省为白色，如果用户希望改变成灰色或者其它颜色，那就需要使用单独处
理，解决的办法很多，如在每次视口的OnPaint()事件中采用灰色刷子人为填充背
景，但是这不是最好的办法。笔者发现最好的办法就是采用AfxRegisterWndClass()
函数注册一个使用灰色背景刷的新的窗口类，这需要重载PreCreateWindow()函数来
实现这一点，如下程序代码片段所示：
BOOL CSimuView::PreCreateWindow(CREATESTRUCT& cs)
{
HBRUSH hbkbrush=CreateSolidBrush(RGB(192,192,192));//创建灰色背景刷
LPCSTR lpMyOwnClass=AfxRegisterWndClass(CS_HREDRAW
|CS_VREDRAW|CS_OWNDC,0,hbkbrush);//注册新类
cs.lpszClass=lpMyOwnClass;//修改缺省的类风格
return TRUE;
}
采用这种方法速度最快，也最省力。同时，还可以在PreCreateWindow()函数定义所
希望的任何窗口风格，如窗口大小，光标式样等。

使用单文档-多视结构

如果用户使用过MFC进行编程，那么就会发现借助于AppWizard基于MFC无论编写SDI
(单文档界面)还是编写MDI(多文档界面)都是十分方便的。MDI应用程序目前使用越
来越普遍，人们熟悉的Microsoft公司的Office系列产品以及Visual系列产品都是典
型的多文档应用程序。这种多文档界面具有多窗口的特点，因而人们可以在一个程
序中使用多个子窗口来实现不同数据的浏览查看。如果用户要实现在MDI各个窗口之
间针对同一数据进行不同的可视化就是一件比较麻烦的事情。值得庆幸的是，MFC提
供的文档-视结构大大简化了这一工作。文档-视结构通过将数据从用户对数据的观
察中分离出来，从而方便实现多视，亦即多个视口针对同一数据，如果一个视口中
数据发生改变，那么其它相关视口中的内容也会随之发生改变以反映数据的变化。
SDI和MDI这两种Windows标准应用程序框架并不是总能满足用户的需要，就作者的工
作而言，就特别需要一种被称为单文档多视的应用程序，英文可以缩写为SDMV。通
过SDMV应用我们可以利用文档类来统一管理应用程序的所有数据，同时需要采用多
窗口以多种方式来可视化这些的数据，如棒图，趋势图和参数列表，从而方便用户
从不同角度来观察数据。MDI虽然具有多窗口的特点，但是其为多文档，即通常情况
下，一个视口对应一个文档，视口+文档便构成一个子窗口。在各个子窗口之间数据
相互独立，如果要保持数据同步更新就需要采用特殊的技术了，采用这种方式既费
时又费力。通过笔者的实践发现，利用MFC本身提供的多视概念通过适当改造MDI窗
口应用程序就可以实现上述SDMV结构。
所谓SDMV应用程序本质上仍然是一个MDI应用程序，只是在程序中我们人为控制使其
只能生成一个文档类，这个文档在第一个视口创建时创建，注意，这里并不需要限
制各个视口的创建先后顺序。此后与MDI窗口固有特性不同的是，所有新创建的子窗
口都不再创建独立文档，而是把该新视口直接连接到已有的文档对象上，这样就使
其成为单文档多视的结构，所有相关数据都存储在文档对象中，一旦文挡中数据发
生改变，通过UpdateAllViews()函数通知所有相关视口，各个视口就可以在
OnUpdate()中相应数据的变化。这种响应机制如下图所示:

图 1 文档-视结构数据更新机制
由于MDI本质上并不是为这种单文档多视机制服务的，因而在实际应用时需要解决一
些问题。
1、窗口标题问题
窗口标题本来不应该成为问题，缺省情况下MDI窗口通过在文档模板中提供的资源ID
所提供的对应字符串来确定窗口标题。但是对于SDMV应用，由于各个视口实质上是
对应于同一个文挡，因此每个视口都具有相同标题，只不过增加了一个数据用于指
示这是第几个视口。如果在各个视口中指明具体的窗口名字，那么由不同的视口启
动创建文档产生的窗口标题就不同，这个名字会影响到后继视口。为了作到不同类
型的视口如棒图视口和曲线视口具有不同的标题，这就需要一定的技术处理。根据
笔者的摸索发现可以采用如下步骤实现：
首先在从标准的MDI子窗口基类CMDIChildWnd派生一个自己的子窗口类，姑且命名为
CMyChild，然后在其成员变量中增加一个CString型变量用以存储当前窗口标题：
CString winTitle;
然后在不同的视口创建过程中通过获取父窗口指针按自己的意愿对上述变量进行赋
值，程序片段如下：
pChild=(CMyChild*)GetParent();
pChild->winTitle="棒图显示窗口";
最后在CMyChild派生类中重载CMDIChildWnd基类中的OnUpdateFrameTitle()函数来
强制实现窗口标题的个性化，这一函数在各种类库手册上和联机帮助中都没有，但
的确有这样一个具有保护属性的函数用来实现窗口标题的更新操作，这可以从MFC类
库的源代码中找到该函数的实现。重载后的源代码如下：
void CMyChild::OnUpdateFrameTitle(BOOL bAddToTitle)
{
// update our parent window first
GetMDIFrame()->OnUpdateFrameTitle(bAddToTitle);

if ((GetStyle() & FWS_ADDTOTITLE) == 0)
return; // leave child window alone!

CDocument* pDocument = GetActiveDocument();
if (bAddToTitle && pDocument != NULL)
{
char szOld[256];
GetWindowText(szOld, sizeof(szOld));
char szText[256];

lstrcpy(szText,winTitle); //Modified by author!
if (m_nWindow > 0)
wsprintf(szText + lstrlen(szText), ":%d", m_nWindow);

// set title if changed, but don't remove completely
if (lstrcmp(szText, szOld) != 0)
SetWindowText(szText);
}
}
2、如何创建SDMV应用
如何创建SDMV应用比较麻烦，下面通过举例来具体说明。该例子假设用户需要建棒
图类型和曲线形式的两种视口，假设用户已经利用CView基类派生并且实现了这两个
类，分别对应于CMyChart和CMyTraceView两个类。
1) 在应用类（从CWinApp派生出来的类）的头文件中加入下列变量和函数原型说
明：
CMultiDocTemplate* m_pMyTraceTemplate;
CMultiDocTemplate* m_pMyChartTemplate;
int ExitInstance();
2) 在应用类的InitInstance成员函数中删除对AddDocTemplate函数的调用和
OpenFileNew()语句，并且加入如下代码：
m_pMyTraceTemplate = new CMultiDocTemplate(
IDR_MYTRACEVIEW,
RUNTIME_CLASS(CSimuDoc),
RUNTIME_CLASS(CMyChild), // Derived MDI child frame
RUNTIME_CLASS(CMyTraceView));

m_pMyChartTemplate = new CMultiDocTemplate(
IDR_MYCHART,
RUNTIME_CLASS(CSimuDoc),
RUNTIME_CLASS(CMyChild), // Derived MDI child frame
RUNTIME_CLASS(CMyChart));
3) 实现ExitInstance()函数，在其中删除所用的两个辅助模板：
int CTestApp::ExitInstance()
{
if(m_pMyChartTemplate) delete m_pMyChartTemplate;
if(m_pMyTraceTemplate) delete m_pMyTraceTemplate;
return TRUE;
}
4) 在菜单资源中去掉File菜单中的New和Open项，加入New Chart View和New
Trace View两项，在对应的菜单命令中实现如下：
void CMainFrame::OnNewMychart()
{
// TODO: Add your command handler code here
OnNewView(((CSimuApp*)AfxGetApp())->m_pMyChartTemplate);
}
void CMainFrame::OnNewMyTrace()
{
// TODO: Add your command handler code here
OnNewView(((CSimuApp*)AfxGetApp())->m_pMyTraceTemplate);
}
上中OnNewView的实现如下：
BOOL CMainFrame::OnNewView(CMultiDocTemplate* pDocTemplate)
{
CMDIChildWnd* pActiveChild = MDIGetActive();
CDocument* pDocument;
if (pActiveChild == NULL ||
(pDocument = pActiveChild->GetActiveDocument()) == NULL)
{
TRACE0("Now New the specify view\n");
ASSERT(pDocTemplate != NULL);
ASSERT(pDocTemplate->IsKindOf(RUNTIME_CLASS(CDocTemplate)));
pDocTemplate->OpenDocumentFile(NULL);
return TRUE;
}

// otherwise we have a new frame to the same document!
CMultiDocTemplate* pTemplate = pDocTemplate;
ASSERT_VALID(pTemplate);
CFrameWnd* pFrame = pTemplate->CreateNewFrame(pDocument, pActiveChild);
if (pFrame == NULL)
{
TRACE0("Warning: failed to create new frame\n");
return FALSE; // command failed
}
pTemplate->InitialUpdateFrame(pFrame, pDocument);
return TRUE;
}
OnNewView是整个SDMV应用的核心组成，它的任务是创建一个新的指定类型的视口，
它首先判断是否有活动视口存在，文档是否已经创建，正常情况下活动视口存在则
表明文档存在，如果不存在则利用所指定的文档模板创建一个新的活动视口，否则
则只创建视口，同时将其连接到已存在的文档对象上。
通过以上步骤就可以实现SDMV应用，在其后的具体应用中利用文档对象的
UpdateAllViews()函数和视口的OnUpdate()函数就可以很好的工作了。

使用DDE服务

Windows 3.x是一个分时多任务操作环境，在此环境下，多个应用程序可以并发地执
行。为了在并发执行的多个任务之间共享数据和资源，Windows 提供了几种机制，
主要是通过剪贴板(Clipboard)和动态数据交换(Dynamic Data Exchange)。前者对
于用户需要直接参与的数据交换来说，是一个非常方便的工具，但是如果希望数据
交换自动进行时就必须依靠DDE技术了。编写DDE应用的技术也发展了好几代，从最
初的基于消息的DDE到基于DDEML(动态数据交换管理库)，再到现在流行的OLE技
术。DDE技术的发展使得程序开发人员编写DDE应用更为简洁。从发展趋势来看，基
于OLE的数据交换是最好的，它特别符合当今软件领域的客户-服务器机制
(Client-Server)。为适应多平台和Internet的需要，在OLE基础上微软又开发了
ActiveX技术。但是不容忽视的是，基于传统的DDE数据交换也自有它的应用空间，
使用仍然广泛。目前在Windows 3.x下，基于OLE的远程数据交换还很不成熟，但是
在WFW(Windows for Workgroup)下基于网络动态数据交换的技术却很成熟，目前也
应用非常普遍。关于DDE应用的开发和NetDDE的应用可以参看附录7。
1、回调函数的处理
由于DDEML机制需要使用回调函数，因此使用DDEML的关键是解决在MFC编程体系中回
调函数的使用。回调函数(Callback function)大量用于Windows的系统服务，通过
它，程序员可以安装设备驱动程序和消息过滤系统，以控制Windows的有效使用。
许多程序员都发现，利用MFC或者其它的C++应用编写回调函数是非常麻烦的，其根
本原因是回调函数是基于C编程的Windows SDK的技术，不是针对C++的，程序员可以
将一个C函数直接作为回调函数，但是如果试图直接使用C++的成员函数作为回调函
数将发生错误，甚至编译就不能通过。通过查询资料发现，其错误是普通的C++成员
函数都隐含了一个传递函数作为参数，亦即“this”指针，C++通过传递一个指向自
身的指针给其成员函数从而实现程序函数可以访问C++的数据成员。这也可以理解为
什么C++类的多个实例可以共享成员函数但是确有不同的数据成员。由于this指针的
作用，使得将一个CALLBACK型的成员函数作为回调函数安装时就会因为隐含的this
指针使得函数参数个数不匹配，从而导致回调函数安装失败。要解决这一问题的关
键就是不让this指针起作用，通过采用以下两种典型技术可以解决在C++中使用回调
函数所遇到的问题。这种方法具有通用性，适合于任何C++。
1. 不使用成员函数，直接使用普通C函数，为了实现在C函数中可以访问类的成员变
量，可以使用友元操作符(friend)，在C++中将该C函数说明为类的友元即可。这种
处理机制与普通的C编程中使用回调函数一样。
2. 使用静态成员函数，静态成员函数不使用this指针作为隐含参数，这样就可以作
为回调函数了。静态成员函数具有两大特点：其一，可以在没有类实例的情况下使
用；其二，只能访问静态成员变量和静态成员函数，不能访问非静态成员变量和非
静态成员函数。由于在C++中使用类成员函数作为回调函数的目的就是为了访问所有
的成员变量和成员函数，如果作不到这一点将不具有实际意义。解决的办法也很简
单，就是使用一个静态类指针作为类成员，通过在类创建时初始化该静态指针，如
pThis=this，然后在回调函数中通过该静态指针就可以访问所有成员变量和成员函
数了。这种处理办法适用于只有一个类实例的情况，因为多个类实例将共享静态类
成员和静态成员函数，这就导致静态指针指向最后创建的类实例。为了避免这种情
况，可以使用回调函数的一个参数来传递this指针，从而实现数据成员共享。这种
方法稍稍麻烦，这里就不再赘述。
2、在MFC中使用DDEML
对于典型的MFC应用程序，主框架窗口类(CMainFrame)只有一个实例，因此可以使用
静态成员函数作为回调函数，从而实现DDE机制。具体的代码片段如下：
(1) 在CMainFrame类中声明如下静态成员：
static CMainFrame* pThis;
static DWORD idInst;
static HDDEDATA CALLBACK EXPORT DdeCallback(UINT,UINT,HCONV,HSZ,HSZ, HDDEDATA,DWORD,DWORD);
(2) 在类的创建代码(OnCreate())中作如下说明：
pThis=this;
lpDdeCallback=MakeProcInstance((FARPROC)DdeCallback,hInstance);
if(DdeInitialize(&idInst,(PFNCALLBACK)lpDdeCallback,CBF_FAIL_EXECUTES
|CBF_SKIP_REGISTRATIONS|CBF_SKIP_UNREGISTRATIONS,0L))
{
AfxMessageBox("不能初始化DDE服务","错误");
DestroyWindow();
}
(3) 回调函数实现如下：
HDDEDATA FAR PASCAL _export CMainFrame::DdeCallback(UINT iType,UINT iFmt, HCONV hConv,HSZ hsz1,HSZ hsz2,HDDEDATA hData,DWORD dwData1,DWORD dwData2)
{
char szBuffer[16];
int i;

switch(iType)
{
case XTYP_CONNECT: //hsz1=topiv, hsz2=service
return (HDDEDATA)TRUE;//TRUE;
case XTYP_ADVSTART: //hsz1=topic, hsz2=item
case XTYP_REQUEST:
case XTYP_ADVREQ:
case XTYP_POKE: //hsz1=Topic, hsz2=item, hData=data
case XTYP_ADVSTOP:
return NULL;
}
}
3、避免变量类型冲突
如果在MFC应用直接使用DDEML服务，那么该MFC应用在编译时将会遇到变量类型HSZ
重复定义错误。经过追踪发现，错误在于在DDEML.H对HSZ作了如下定义：
DECLARE_HANDLE32(HSZ);
而在AFXEXT.H(通过stdafx.h引入)中对HSZ又作了如下说明：
typedef BPSTR FAR* HSZ; // Long handle to a string
两个定义一个为32位整数，一个为BASIC字符串指针，当然会发生编译器不能作变量
类型转换的错误。实际上，将HSZ声明为BASIC字符串指针主要用于在MFC应用中使用
VBX控制。要改正这一错误，就必须保证不要在同一个代码模块中使用DDEML和VBX支
持，通过将使用DDEML和VBX的代码分开，并在使用DDEML代码的模块中最开头定义如
下编译器宏就可以解决上述问题：
#define NO_VBX_SUPPORT

使用3D控制

毫无疑问，3D控制的使用可以显著提高Windows应用程序的界面友好性，目前，许多
流行的Windows应用程序都使用了3D控制，典型的如Microsoft公司的Office系列软
件，而且，在Windows 95和Windows NT 4.0中，3D控制更是作为操作系统的一部分
直接提供，这意味着在其上运行的软件不需要作任何特殊处理，就具有3D界面效
果，但是，很遗憾的是，在Windows 3.x中，除了命令按钮控制使用3D控制以外，其
余所有的控制，如编辑框，列表框，检查框等都只使用2D控制，要想使用3D控制，
程序设计人员就必须在自己的程序中作一定的修改，考虑到目前3D效果的流行，这
点努力是值得的。
为了支持3D效果，Microsoft公司提供了一个专门用于3D控制的动态连接库，即
CTL3D.DLL，但是在其Visual C++中却没有如何使用3D控制的讨论，并且，Visual
C++也不直接支持3D编码，因为它不包括使用3D控制所必须的头文件。但是，这并不
意味着在Visual C++中不能使用3D控制，只不过用户需要从其它地方获取技术支持
罢了。由于使用的是动态连接库机制，因此，任何其它语言提供的3D头文件和
CTL3D.DLL的输入库都是可用的。作者使用的就是Borland公司的Borland C++中提供
的CTL3D.H和CTL3D.LIB。在C/C++中使用3D控制的方法也有很多种，在这里，为节约
篇幅，只讨论与本文相关的主题，即使用MFC编程时如何使用3D控制。
在MFC的所有对话框中使用3D控制可以遵循如下步骤：
1. 在CWinApp::InitInstance函数中调用Ctl3dRegister和Ctl3dAutosubclass函
数：
Ctl3dRegister(AfxGetInstanceHandle());
Ctl3dAutoSubclass(AfxGetInstanceHandle());
值得一提的是，在AppWizard产生的应用框架的CWinApp::InitInstance中有一个函
数调用为SetDialogBkColor，此函数的作用是将所有对话框的背景颜色设置为灰
色，这个功能与3D界面实现相同的功能，可以移去此语句。
由于CTL3D在初始化时读入所有的系统颜色并自己维持，为了使应用程序能够正确反
映系统颜色的变化，MFC应用程序可以在WM_SYSCOLORCHANGE消息中调用
Ctl3dColorChange函数。
2. 在MFC应用程序的CWinApp类中的ExitInstance函数中调用Ctl3dUnregister函
数，以方便Windows对CTL3D库的正确管理。
3. 在MFC应用程序的项目文件中加入CTL3D.LIB（可以用IMPORT.EXE产生）。
使用上述CTL3D的自动子类化的机制可以大大简化使用3D控制，如果这不满足你的要
求，那么你就必须单独在需要使用3D控制的对话框的OnInitDialog()中自行子类化
相关的控制类了，典型的如下代码片断所示：
BOOL CMyDialog::OnInitDialog()
{
Ctl3dSubclassDlgEx(m_hWnd,CTL3D_ALL);
return TRUE;
}
上面讲了在对话框中使用3D效果的办法，如果用户想在非对话框中使用3D控制，典
型的在FormView导出类中使用，可以在导出类的OnInitialUpdate函数中进行适当修
改，修改的大小取决于你是否使用了3D控制的自动子类化机制。如果使用前面提到
的自动子类化方法，那么仅需要在相应的OnInitialUpdate函数中调用
Ctl3dSubclassDlg函数了，如下代码片断所示：
void CMyView::OnInitialUpdate()
{
Ctl3dSubclassDlg(m_hWnd,CTL3D_ALL);
}
否则，则需要修改如下：
void CMyView::OnInitialUpdate()
{
Ctl3dSubclassDlgEx(m_hWnd,CTL3D_ALL);
}

使用自定义消息

1、MFC的消息映射机制
Windows是一个典型的消息驱动的操作系统，程序的运行是靠对各种消息的响应来实
现的，这些消息的来源非常广泛，既包括Windows系统本身，如WM_CLOSE、
WM_PAINT、WM_CREATE和WM_TIMER等常用消息，又包括用户菜单选择、键盘加速
键以及工具条和对话框按钮等等，如果应用程序要与其它程序协同工作，那么消息的来
源还包括其它应用程序发送的消息，串行口和并行口等硬件发送的消息等等。总
之，Windows程序的开发是围绕着对众多消息的合理响应和实现来实现程序的各种功
能的。使用过C语言来开发Windows程序的人都知道，在Windows程序的窗口回调函数
中需要安排Switch语句来响应大量的消息，同时由于消息的间断性使得不同的消息
响应之间信息的传递是通过大量的全局变量或者静态数据来实现的。
人们常用的两种类库OWL和MFC都提供了消息映射机制用以加速开发速度，使用者只
需要按规定定义好对应消息的处理函数自身即可，至于实际调用由类库本身所提供
的机制进行，或采用虚函数，或采用消息映射宏。为了有效节约内存，MFC并不大量
采用虚函数机制，而是采用宏来将特定的消息映射到派生类中的响应成员函数。这
种机制不但适用于Windows自身的140条消息，而且适用于菜单命令消息和按钮控制
消息。MFC提供的消息映射机制是非常强大的，它允许在类的各个层次上对消息进行
控制，而不简单的局限于消息产生者本身。在应用程序接收到窗口命令时，MFC将按
如下次序寻找相应的消息控制函数：
SDI应用
MDI应用
视口
视口
文档
文档
SDI主框架
MDI子框架
应用
MDI主框架

应用
大多数应用对每一个命令通常都只有一个特定的命令控制函数，而这个命令控制函
数也只属于某一特定的类，但是如果在应用中对同一消息有多个命令控制函数，那
么只有优先级较高的命令控制函数才会被调用。为了简化对常用命令的处理，MFC在
基类中提供并实现了许多消息映射的入口，如打印命令，打印预览命令，退出命令
以及联机帮助命令等，这样在派生类中就继承了所有的基类中的消息映射函数，从
而可以大大简化编程。如果我们要在自己派生类中实现对消息的控制，那么必须在
派生类中加上相应的控制函数和映射入口。
2、使用自己的消息
在程序设计的更深层次，人们常常会发现只依赖于菜单和命令按钮产生的消息是不
够的，常常因为程序运行的逻辑结构和不同视口之间数据的同步而需要使用一些自
定义的消息，这样通过在相应层次上安排消息响应函数就可以实现自己的特殊需
要。比如如果我们要在特定的时间间隔内通知所有数据输出视口重新取得新数据，
要依靠菜单命令和按钮命令实现不够理想，比较理想的解决办法是采用定时器事件
进行特定的计算操作，操作完成后再采用SendMessage发送自己的特定消息，只有当
这一消息得到处理后才会返回主控程序进行下一时间计算。通过在文档层次上安排
对消息的响应取得最新计算数据，而后通过UpdateAllViews()成员函数来通知所有
相关视口更新数据的显示。视口通过重载OnUpdate()成员函数就可以实现特定数据
的更新显示。
如果用户能够熟练使用SendMessage()函数和PostMessage()函数，那么要发送自定
义消息并不难，通常有两种选择，其一是发送WM_COMMAND消息，通过消息的WORD
wParam参数传递用户的命令ID，举例如下：
SendMessage(WM_COMMAND,IDC_GETDATA,0); //MFC主框架发送
然后在文档层次上安排消息映射入口：
ON_COMMAND(IDC_GETDATA, OnGetData)
同时在文档类中实现OnGetData()函数：
void CSimuDoc::OnGetData()
{
TRACE("Now in SimuDoc,From OnGetData\n");
UpdateAllViews(NULL);
}
注意在上中的消息映射入口需要用户手工加入，Visual C++提供的ClassWizard并不
能替用户完成这一工作。上中例子没有使用PostMessage函数而使用SendMessage函
数的原因是利用了SendMessage函数的特点，即它只有发送消息得到适当处理后方才
返回，这样有助于程序控制。
另一种发送自定义消息的办法是直接发送命令ID，在控制层次上采用ON_MESSAGE来
实现消息映射入口，注意这时的命令控制函数的原型根据Windows本身消息处理的规
定必须如下：
afx_msg LONG OnCaculationOnce(WPARAM wParam,LPARAM lParam);
相对来讲，这种机制不如上述机制简单，也就不再赘述。

使用不带文挡-视结构的MFC应用

文档-视结构的功能是非常强大的，可以适合于大多数应用程序，但是有时我们只需
要非常简单的程序，为了减少最终可执行文件尺寸和提高运行速度，我们没有必要
使用文挡-视结构，典型的有简单SDI应用和基于对话框的应用。
1、简单SDI应用
此时只需要使用CWinApp和CFrameWnd两个类就完全可以了。由于CWinApp类封装了
WinMain函数和消息处理循环，因此任何使用MFC进行编程的程序都不能脱离开该
类。实际上使用CWinApp类非常简单，主要是派生一个用户自己的应用类，如
CMyApp，然后只需重载CWinApp类的InitInstance()函数：

BOOL CMyApp::InitInstance()
{
m_pMainWnd=new CMainFrame();
ASSERT(m_pMainWnd!=NULL); //error checking only
m_pMainWnd->ShowWindow(m_nCmdShow);
m_pMainWnd->UpdateWindow();
return TRUE;
}
至于所需要的主框架类，则可以直接使用ClassWizard实用程序生成，该类的头文件
与实现代码可以与CMyApp类的头文件和实现代码放在一起。注意，这里由一个技
巧，由于ClassWizard的使用需要有相应的CLW文件存在，而收工建代码时没有对应
的CLW文件，因此不能直接使用，解决办法是进入App Studio实用工具后使用
ClassWizard，此时系统会发觉不存在相应的CLW文件，系统将提示你重建CLW文件并
弹出相应对话框，这时候你不需要选择任何文件就直接选择OK按钮，这样系统将为
你产生一个空的CLW文件，这样就可以使用ClassWizard实用工具了。为了将CWinApp
和CFrameWnd的派生类有机地结合在一起，只需在CFrameWnd派生类的构造函数中进
行窗口创建即可。典型代码如下：
CMainFrame::CMainFrame()
{
Create(NULL,"DDE Client Application",WS_OVERLAPPEDWINDOW,rectDefault,
NULL,MAKEINTRESOURCE(IDR_MAINFRAME));
}
采用ClassWizard实用程序生成相关类代码后，所有的类的其它实现和维护就同普通
由AppWizard实用程序产生的代码一样了。
2、基于对话框的程序
有些主要用于数据的输入和输出等的应用在使用时没有必要改变窗口大小，典型的
如各种联机注册程序，这些使用对话框作为应用的主界面就足够了，而且开发此类
应用具有方便快捷的特点，代码也比较短小，如果直接采用各种控制类生成所需要
的控制就特别麻烦。在Visual C++ 4.x版本中使用AppWizard就可以直接生成基于对
话框的应用。在Visual 1.x中没有此功能，因此这类应用需要程序员自己实现。
实际上使用MFC实现基于对话框的应用非常简单，同样只使用两个MFC类作为基类，
这两个类为CWinApp类和CDialog类。所使用的对话框主界面同样可以先用App
Studio编辑对话框界面，再使用ClassWizard产生相应代码框架，然后修改CMyApp类
的声明，增加一个该对话框类的成员变量m_Mydlg，最后修改CMyApp类的
InitInstance()函数如下：
BOOL CMyApp::InitInstance()
{
m_Mydlg.DoModal();
return TRUE;
}

MFC应用的人工优化

使用C/C++编写Windows程序的优点就是灵活高效，运行速度快，Visual C++编译器
本身的优化工作相当出色，但这并不等于不需要进行适当的人工优化，为了提高程
序的运行速度，程序员可以从以下几方面努力：
1) 减少不必要的重复显示
相对来讲，Windows的GDI操作是比较慢的，因此在程序中我们应该尽可能地控制整
个视口的显示和更新，如果前后两此数据不发生变化，那么就不要重新进行视口的
GDI图形操作，尤其对于背景图显示时非万不得已时不要重绘，同时不要经常五必要
的刷新整个窗口。
2) 在视口极小化时不要进行更新屏幕操作
在窗口处于极小化时没有必要继续进行视口更新工作，这样可以显著提高速度。为
此需要在子窗口一级捕获上述信息（视口不能捕获该类信息），再在视口中进行相
应操作。如下代码片段所示：
首先在子窗口类中添加如下程序段：
void CMyChild::OnSysCommand(UINT nID,LPARAM lparam)
{
CMDIChildWnd::OnSysCommand(nID,lparam);
if(nID==SC_MINIMIZE){
RedrawFlag=0;
}
else
RedrawFlag=1;
}
再在视口更新时中修改如下：
void CMyChart::OnUpdate( CView* pSender, LPARAM lHint, CObject* pHint )
{
if(pChild->RedrawFlag)
{
InvalidateRect(&r,FALSE);
TRACE("Now In CMyChart::OnUpdate\n");
}
}
至于上中pChild指针可以在视口创建的例程中获取：
pChild=(CMyChild*)GetParent();
3) 使用永久性的资源
在频繁进行GDI输出的视口中，如在监控软件中常常使用的趋势图显示和棒图显示等
等，应该考虑在类层次上建立频繁使用的每种画笔和刷子，这可以避免频繁的在堆
中创建和删除GDI对象，从而提高速度。
4) 使用自有设备描述句柄
亦即在创建视口时通过指定WM_OWNDC风格来拥有自己的显示设备句柄，这虽然会多
消耗一些内存，一个DC大约占800字节的内存，但是这避免了每次进行GDI操作前创
建并合理初始化显示设备句柄这些重复操作。特别是要自定义坐标系统和使用特殊
字体的视口这一点尤其重要。在16M机器日益普遍的今天为了节约一点点内存而降低
速度的做法并不可取。
5) 优化编译时指定/G3选项和/FPix87选项
/G3选项将强迫编译器使用386处理器的处理代码，使用嵌入式协处理器指令对那些
频繁进行浮点运算的程序很有帮助。采用这两种编译开关虽然提高了对用户机型的
要求，但在386逐渐被淘汰，486市场大幅度萎缩，586市场日益普及的今天上述问题
已经不再成为问题了。

思勤无邪 2006-07-11 09:54 发表评论

STL 排序(Sort)

思勤无邪 — Fri, 30 Jun 2006 04:35:00 GMT

网上看到这篇文章，觉得写得比较易懂，修改了原文的一些错误后整理在这里。作者 Winter

详细解说 STL 排序(Sort)

一切复杂的排序操作，都可以通过STL方便实现 !

0 前言: STL，为什么你必须掌握

对于程序员来说，数据结构是必修的一门课。从查找到排序，从链表到二叉树，几乎所有的算法和原理都需要理解，理解不了也要死记硬背下来。幸运的是这些理论都已经比较成熟，算法也基本固定下来，不需要你再去花费心思去考虑其算法原理，也不用再去验证其准确性。不过，等你开始应用计算机语言来工作的时候，你会发现，面对不同的需求你需要一次又一次去用代码重复实现这些已经成熟的算法，而且会一次又一次陷入一些由于自己疏忽而产生的bug中。这时，你想找一种工具，已经帮你实现这些功能，你想怎么用就怎么用，同时不影响性能。你需要的就是STL, 标准模板库！

西方有句谚语：不要重复发明轮子！

STL几乎封装了所有的数据结构中的算法，从链表到队列，从向量到堆栈，从hash到二叉树，从搜索到排序，从增加到删除......可以说，如果你理解了STL，你会发现你已不用拘泥于算法本身，从而站在巨人的肩膀上去考虑更高级的应用。

排序是最广泛的算法之一，本文详细介绍了STL中不同排序算法的用法和区别。

1 STL提供的Sort 算法

C++之所以得到这么多人的喜欢，是因为它既具有面向对象的概念，又保持了C语言高效的特点。STL 排序算法同样需要保持高效。因此，对于不同的需求，STL提供了不同的函数。不同的函数，实现的算法又不尽相同。

1.1 所有sort算法介绍

所有的sort算法的参数都需要输入一个范围，[begin, end)。这里使用的迭代器(iterator)都需是随机迭代器(RadomAccessIterator), 也就是说可以随机访问的迭代器，如：it+n什么的。（partition 和stable_partition 除外）

如果你需要自己定义比较函数，你可以把你定义好的仿函数(functor)作为参数传入。每种算法都支持传入比较函数。以下是所有STL sort算法函数的名字列表:

函数名	功能描述
sort	对给定区间所有元素进行排序
stable_sort	对给定区间所有元素进行稳定排序
partial_sort	对给定区间所有元素部分排序
partial_sort_copy	对给定区间复制并排序
nth_element	找出给定区间的某个位置对应的元素
is_sorted	判断一个区间是否已经排好序
partition	使得符合某个条件的元素放在前面
stable_partition	相对稳定的使得符合某个条件的元素放在前面

其中nth_element 是最不易理解的，实际上，这个函数是用来找出第几个。例如：找出包含7个元素的数组中排在中间那个数的值，此时，我可能不关心前面，也不关心后面，我只关心排在第四位的元素值是多少。

1.2 sort 中的比较函数

当你需要按照某种特定方式进行排序时，你需要给sort指定比较函数，否则程序会自动提供给你一个比较函数。

vector < int > vect;
//...
sort(vect.begin(), vect.end());
//此时相当于调用
sort(vect.begin(), vect.end(), less<int>() );

上述例子中系统自己为sort提供了less仿函数。在STL中还提供了其他仿函数，以下是仿函数列表:

名称	功能描述
equal_to	相等
not_equal_to	不相等
less	小于
greater	大于
less_equal	小于等于
greater_equal	大于等于

需要注意的是，这些函数不是都能适用于你的sort算法，如何选择，决定于你的应用。另外，不能直接写入仿函数的名字，而是要写其重载的()函数：

less()
greater()

当你的容器中元素是一些标准类型（int float char)或者string时，你可以直接使用这些函数模板。但如果你是自己定义的类型或者你需要按照其他方式排序，你可以有两种方法来达到效果：一种是自己写比较函数。另一种是重载类型的'<'操作符。

#include 
#include 
#include 
#include 
usingnamespace std;

class myclass {
        public:
        myclass(int a, int b):first(a), second(b){}
        int first;
        int second;
        booloperator < (const myclass &m)const {
                return first < m.first;
        }
};

bool less_second(const myclass & m1, const myclass & m2) {
        return m1.second < m2.second;
}

int main() {
        
        vector< myclass > vect;
        for(int i = 0 ; i < 10 ; i ++){
                myclass my(10-i, i*3);
                vect.push_back(my);
        }
        for(int i = 0 ; i < vect.size(); i ++) 
        cout<<"("<,"<)\n";
        sort(vect.begin(), vect.end());
        cout<<"after sorted by first:"<for(int i = 0 ; i < vect.size(); i ++) 
        cout<<"("<,"<)\n";
        cout<<"after sorted by second:"<for(int i = 0 ; i < vect.size(); i ++) 
        cout<<"("<,"<)\n";
        
        return 0 ;
}

知道其输出结果是什么了吧：

(10,0)
(9,3)
(8,6)
(7,9)
(6,12)
(5,15)
(4,18)
(3,21)
(2,24)
(1,27)
after sorted by first:
(1,27)
(2,24)
(3,21)
(4,18)
(5,15)
(6,12)
(7,9)
(8,6)
(9,3)
(10,0)
after sorted by second:
(10,0)
(9,3)
(8,6)
(7,9)
(6,12)
(5,15)
(4,18)
(3,21)
(2,24)
(1,27)

1.3 sort 的稳定性

你发现有sort和stable_sort，还有 partition 和stable_partition，感到奇怪吧。其中的区别是，带有stable的函数可保证相等元素的原本相对次序在排序后保持不变。或许你会问，既然相等，你还管他相对位置呢，也分不清楚谁是谁了？这里需要弄清楚一个问题，这里的相等，是指你提供的函数表示两个元素相等，并不一定是一摸一样的元素。

例如，如果你写一个比较函数:

bool less_len(const string &str1, const string &str2)
{
        return str1.length() < str2.length();
}

此时，"apple" 和 "winter" 就是相等的，如果在"apple" 出现在"winter"前面，用带stable的函数排序后，他们的次序一定不变，如果你使用的是不带"stable"的函数排序，那么排序完后，"Winter"有可能在"apple"的前面。

1.4 全排序

全排序即把所给定范围所有的元素按照大小关系顺序排列。用于全排序的函数有

template <class RandomAccessIterator>
void sort(RandomAccessIterator first, RandomAccessIterator last);

template <class RandomAccessIterator, class StrictWeakOrdering>
void sort(RandomAccessIterator first, RandomAccessIterator last,
StrictWeakOrdering comp);

template <class RandomAccessIterator>
void stable_sort(RandomAccessIterator first, RandomAccessIterator last);

template <class RandomAccessIterator, class StrictWeakOrdering>
void stable_sort(RandomAccessIterator first, RandomAccessIterator last, 
StrictWeakOrdering comp);

在第1，3种形式中，sort 和 stable_sort都没有指定比较函数，系统会默认使用operator< 对区间[first,last)内的所有元素进行排序, 因此，如果你使用的类型已经重载了operator<函数，那么你可以省心了。第2, 4种形式，你可以随意指定比较函数，应用更为灵活一些。来看看实际应用：

班上有10个学生，我想知道他们的成绩排名。

#include 
#include 
#include 
#include 
#include 
usingnamespace std;

class student{
        public:
        student(const string &a, int b):name(a), score(b){}
        string name;
        int score;
        booloperator < (const student &m)const {
                return score< m.score;
        }
};

int main() {
        vector< student> vect;
        student st1("Tom", 74);
        vect.push_back(st1);
        st1.name="Jimy";
        st1.score=56;
        vect.push_back(st1);
        st1.name="Mary";
        st1.score=92;
        vect.push_back(st1);
        st1.name="Jessy";
        st1.score=85;
        vect.push_back(st1);
        st1.name="Jone";
        st1.score=56;
        vect.push_back(st1);
        st1.name="Bush";
        st1.score=52;
        vect.push_back(st1);
        st1.name="Winter";
        st1.score=77;
        vect.push_back(st1);
        st1.name="Andyer";
        st1.score=63;
        vect.push_back(st1);
        st1.name="Lily";
        st1.score=76;
        vect.push_back(st1);
        st1.name="Maryia";
        st1.score=89;
        vect.push_back(st1);
        cout<<"------before sort..."<for(int i = 0 ; i < vect.size(); i ++) cout<:\t"<());
        cout <<"-----after sort ...."<for(int i = 0 ; i < vect.size(); i ++) cout<:\t"<return 0 ;
}

其输出是：

------before sort...
Tom:    74
Jimy:   56
Mary:   92
Jessy:  85
Jone:   56
Bush:   52
Winter: 77
Andyer: 63
Lily:   76
Maryia: 89
-----after sort ....
Bush:   52
Jimy:   56
Jone:   56
Andyer: 63
Tom:    74
Lily:   76
Winter: 77
Jessy:  85
Maryia: 89
Mary:   92

sort采用的是成熟的"快速排序算法"(目前大部分STL版本已经不是采用简单的快速排序，而是结合内插排序算法)。可以保证很好的平均性能、复杂度为n*log(n)，由于单纯的快速排序在理论上有最差的情况，性能很低，其算法复杂度为n*n，但目前大部分的STL版本都已经在这方面做了优化，因此你可以放心使用。stable_sort采用的是"归并排序"，分派足够内存时，其算法复杂度为n*log(n), 否则其复杂度为n*log(n)*log(n)，其优点是会保持相等元素之间的相对位置在排序前后保持一致。

1.5 局部排序

局部排序其实是为了减少不必要的操作而提供的排序方式。其函数原型为：

template <class RandomAccessIterator>
void partial_sort(RandomAccessIterator first, 
RandomAccessIterator middle,
RandomAccessIterator last);

template <class RandomAccessIterator, class StrictWeakOrdering>
void partial_sort(RandomAccessIterator first,
RandomAccessIterator middle,
RandomAccessIterator last, 
StrictWeakOrdering comp);

template <class InputIterator, class RandomAccessIterator>
RandomAccessIterator partial_sort_copy(InputIterator first, InputIterator last,
RandomAccessIterator result_first,
RandomAccessIterator result_last);

template <class InputIterator, class RandomAccessIterator, 
class StrictWeakOrdering>
RandomAccessIterator partial_sort_copy(InputIterator first, InputIterator last,
RandomAccessIterator result_first,
RandomAccessIterator result_last, Compare comp);

理解了sort 和stable_sort后，再来理解partial_sort 就比较容易了。先看看其用途: 班上有10个学生，我想知道分数最低的5名是哪些人。如果没有partial_sort，你就需要用sort把所有人排好序，然后再取前5个。现在你只需要对分数最低5名排序，把上面的程序做如下修改：

stable_sort(vect.begin(), vect.end(),less());
替换为：
partial_sort(vect.begin(), vect.begin()+5, vect.end(),less());

输出结果为：

------before sort...
Tom:    74
Jimy:   56
Mary:   92
Jessy:  85
Jone:   56
Bush:   52
Winter: 77
Andyer: 63
Lily:   76
Maryia: 89
-----after sort ....
Bush:   52
Jimy:   56
Jone:   56
Andyer: 63
Tom:    74
Mary:   92
Jessy:  85
Winter: 77
Lily:   76
Maryia: 89

这样的好处知道了吗？当数据量小的时候可能看不出优势，如果是100万学生，我想找分数最少的5个人......

partial_sort采用的堆排序（heapsort），它在任何情况下的复杂度都是n*log(n). 如果你希望用partial_sort来实现全排序，你只要让middle=last就可以了。

partial_sort_copy其实是copy和partial_sort的组合。被排序(被复制)的数量是[first, last)和[result_first, result_last)中区间较小的那个。如果[result_first, result_last)区间大于[first, last)区间，那么partial_sort相当于copy和sort的组合。

1.6 nth_element 指定元素排序

nth_element一个容易看懂但解释比较麻烦的排序。用例子说会更方便：
班上有10个学生，我想知道分数排在倒数第4名的学生。
如果要满足上述需求，可以用sort排好序，然后取第4位（因为是由小到大排), 更聪明的朋友会用partial_sort, 只排前4位，然后得到第4位。其实这是你还是浪费，因为前两位你根本没有必要排序，此时，你就需要nth_element:

template <class RandomAccessIterator>
void nth_element(RandomAccessIterator first, RandomAccessIterator nth,
RandomAccessIterator last);

template <class RandomAccessIterator, class StrictWeakOrdering>
void nth_element(RandomAccessIterator first, RandomAccessIterator nth,
RandomAccessIterator last, StrictWeakOrdering comp);

对于上述实例需求，你只需要按下面要求修改1.4中的程序：

stable_sort(vect.begin(), vect.end(),less());
替换为：
nth_element(vect.begin(), vect.begin()+3, vect.end(),less());

运行结果为：

------before sort...
Tom:    74
Jimy:   56
Mary:   92
Jessy:  85
Jone:   56
Bush:   52
Winter: 77
Andyer: 63
Lily:   76
Maryia: 89
-----after sort ....
Jone:   56
Bush:   52
Jimy:   56
Andyer: 63
Jessy:  85
Mary:   92
Winter: 77
Tom:    74
Lily:   76
Maryia: 89

第四个是谁？Andyer，这个倒霉的家伙。为什么是begin()+3而不是+4? begin()是第一个，begin()+1是第二个，... begin()+3当然就是第四个了。

1.7 partition 和stable_partition

好像这两个函数并不是用来排序的，'分类'算法，会更加贴切一些。partition就是把一个区间中的元素按照某个条件分成两类。其函数原型为：

template <class ForwardIterator, class Predicate>
ForwardIterator partition(ForwardIterator first,
ForwardIterator last, Predicate pred)
template <class ForwardIterator, class Predicate>
ForwardIterator stable_partition(ForwardIterator first, ForwardIterator last, 
Predicate pred);

看看应用吧：班上10个学生，计算所有没有及格（低于60分）的学生。你只需要按照下面格式替换1.4中的程序：

stable_sort(vect.begin(), vect.end(),less());
替换为：
student exam("pass", 60);
stable_partition(vect.begin(), vect.end(), bind2nd(less(), exam));

其输出结果为：

------before sort...
Tom:    74
Jimy:   56
Mary:   92
Jessy:  85
Jone:   56
Bush:   52
Winter: 77
Andyer: 63
Lily:   76
Maryia: 89
-----after sort ....
Jimy:   56
Jone:   56
Bush:   52
Tom:    74
Mary:   92
Jessy:  85
Winter: 77
Andyer: 63
Lily:   76
Maryia: 89

看见了吗，Jimy，Jone, Bush(难怪说美国总统比较笨)都没有及格。而且使用的是stable_partition, 元素之间的相对次序是没有变.

2 Sort 和容器

STL中标准容器主要vector, list, deque, string, set, multiset, map, multimay，其中set, multiset, map, multimap都是以树结构的方式存储其元素. 因此在这些容器中，元素一直是有序的。

这些容器的迭代器类型并不是随机型迭代器，因此，上述的那些排序函数，对于这些容器是不可用的。上述sort函数对于下列容器是可用的：

vector
string
deque

如果你自己定义的容器也支持随机型迭代器，那么使用排序算法是没有任何问题的。

对于list容器，list自带一个sort成员函数list::sort(). 它和算法函数中的sort差不多，但是list::sort是基于指针的方式排序，也就是说，所有的数据移动和比较都是用指针的方式实现，因此排序后的迭代器一直保持有效（vector中sort后的迭代器会失效).

3 选择合适的排序函数

为什么要选择合适的排序函数？可能你并不关心效率(这里的效率指的是程序运行时间), 或者说你的数据量很小，因此你觉得随便用哪个函数都无关紧要。

其实不然，即使你不关心效率，如果你选择合适的排序函数，你会让你的代码更容易让人明白，你会让你的代码更有扩充性，逐渐养成一个良好的习惯，很重要吧。

如果你以前有用过C语言中的qsort, 想知道qsort和他们的比较，那我告诉你，qsort和sort是一样的，因为他们采用的都是快速排序。从效率上看，以下几种sort算法的是一个排序，效率由高到低（耗时由小变大）：

partion
stable_partition
nth_element
partial_sort
sort
stable_sort

Effective STL中对如何选择排序函数总结的很好：

若需对vector, string, deque, 或 array容器进行全排序，你可选择sort或stable_sort；
若只需对vector, string, deque, 或 array容器中取得top n的元素，部分排序partial_sort是首选.
若对于vector, string, deque, 或array容器，你需要找到第n个位置的元素或者你需要得到top n且不关系top n中的内部顺序，nth_element是最理想的；
若你需要从标准序列容器或者array中把满足某个条件或者不满足某个条件的元素分开，你最好使用partition或stable_partition；
若使用的list容器，你可以直接使用partition和stable_partition算法，你可以使用list::sort代替sort和stable_sort排序。若你需要得到partial_sort或nth_element的排序效果，你必须间接使用。正如上面介绍的有几种方式可以选择。

总之记住一句话： 如果你想节约时间，不要走弯路, 也不要走多余的路!

4 小结

讨论技术就像个无底洞，经常容易由一点可以引申另外无数个技术点。因此需要从全局的角度来观察问题，就像观察STL中的sort算法一样。其实在STL还有make_heap, sort_heap等排序算法。本文章没有提到。本文以实例的方式，解释了STL中排序算法的特性，并总结了在实际情况下应如何选择合适的算法。

思勤无邪 2006-06-30 12:35 发表评论

C++的iostream标准库介绍

思勤无邪 — Thu, 29 Jun 2006 00:21:00 GMT

C++的iostream标准库介绍

C++的iostream标准库介绍

0 为什么需要iostream

　　我们从一开始就一直在利用C++的输入输出在做着各种练习，输入输出是由iostream库提供的，所以讨论此标准库是有必要的，它与C语言的 stdio库不同，它从一开始就是用多重继承与虚拟继承实现的面向对象的层次结构，作为一个c++的标准库组件提供给程序员使用。

　　iostream为内置类型对象提供了输入输出支持，同时也支持文件的输入输出，类的设计者可以通过对iostream库的扩展，来支持自定义类型的输入输出操作。

　　为什么说要扩展才能提供支持呢？我们来一个示例。

#include  
#include  
usingnamespace std;     

class Test 
{ 
        public: 
        Test(int a=0,int b=0) 
        { 
                Test::a=a; 
                Test::b=b; 
        } 
        int a; 
        int b; 
}; 
int main() 
{ 
        Test t(100,50); 
        printf("%???",t);//不明确的输出格式 
        scanf("%???",t);//不明确的输入格式 
        cout<//同样不够明确 
        cin>>t;//同样不够明确 
        system("pause"); 
}

　　由于自定义类的特殊性，在上面的代码中，无论你使用c风格的输入输出，或者是c++的输入输出都不是不明确的一个表示，由于c语言没有运算符重载机制，导致stdio库的不可扩充性，让我们无法让printf()和scanf()支持对自定义类对象的扩充识别，而c++是可以通过运算符重载机制扩充 iostream库的，使系统能能够识别自定义类型，从而让输入输出明确的知道他们该干什么，格式是什么。

　　在上例中我们之所以用printf与cout进行对比目的是为了告诉大家，C与C++处理输入输出的根本不同，我们从c远的输入输出可以很明显看出是函数调用方式，而c++的则是对象模式，cout和cin是ostream类和istream类的对象。

1 iostream: istream 和 ostream

　　C++中的iostream库主要包含下图所示的几个头文件:

IOSstream 库
fstream	iomainip
ios	iosfwd
iostream	istream
ostream	sstream
streambuf	strstream

　　我们所熟悉的输入输出操作分别是由istream(输入流)和ostream(输出流)这两个类提供的，为了允许双向的输入／输出，由istream和ostream派生出了iostream类。

　　类的继承关系见下图：

iostream库定义了以下三个标准流对象：

cin，表示标准输入(standard input)的istream类对象。cin使我们可以从设备读入数据。
cout，表示标准输出(standard output)的ostream类对象。cout使我们可以向设备输出或者写数据。
cerr，表示标准错误(standard error)的osttream类对象。cerr是导出程序错误消息的地方，它只能允许向屏幕设备写数据。

　　输出主要由重载的左移操作符（<<）来完成，输入主要由重载的右移操作符(>>)完成:

>>a表示将数据放入a对象中。
<

　　这些标准的流对象都有默认的所对应的设备，见下表：

C++对象名	设备名称	C中标准设备名	默认含义
cin	键盘	stdin	标准输入
cout	显示器屏幕	stdout	标准输出
cerr	显示器屏幕	stderr	标准错误输出

　　上表中的意思表明cin对象的默认输入设备是键盘，cout对象的默认输出设备是显示器屏幕。

　　那么原理上Ｃ++有是如何利用cin／cout对象与左移和右移运算符重载来实现输入输出的呢？

　　下面我们以输出为例，说明其实现原理：

cout是ostream类的对象，因为它所指向的是标准设备（显示器屏幕），所以它在iostream头文件中作为全局对象进行定义。
ostream cout(stdout);//其默认指向的C中的标准设备名，作为其构造函数的参数使用。
在iostream.h头文件中，ostream类对应每个基本数据类型都有其友元函数对左移操作符进行了友元函数的重载。
- ostream& operator<<(ostream &temp,int source);
- ostream& operator<<(ostream &temp,char *ps);
- ... 等等

　　一句输出语句：cout<<"http://www.cppblog.com/andxie99";，事实上调用的就是ostream& operator<<(ostream &temp,char *ps);这个运算符重载函数，由于返回的是流对象的引用，引用可以作为左值使用，所以当程序中有类似cout<<"http://www.cppblog.com/andxie99"<<"白纸人生";这样的语句出现的时候，就能够构成连续输出。

　　由于iostream库不光支持对象的输入输出，同时也支持文件流的输入输出，所以在详细讲解左移与右移运算符重载之前，我们有必要先对文件的输入输出以及输入输出的控制符有所了解。

2 fstream: ifstream 和 ofstream

　　和文件有关系的输入输出类主要在fstream.h这个头文件中被定义，在这个头文件中主要被定义了三个类，由这三个类控制对文件的各种输入输出操作，他们分别是ifstream、ofstream、fstream，其中fstream类是由iostream类派生而来，他们之间的继承关系见下图所示。

由于文件设备并不像显示器屏幕与键盘那样是标准默认设备，所以它在fstream.h头文件中是没有像cout那样预先定义的全局对象，所以我们必须自己定义一个该类的对象，我们要以文件作为设备向文件输出信息(也就是向文件写数据)，那么就应该使用ofstream类。

　　ofstream类的默认构造函数原形为：

　　ofstream::ofstream(constchar *filename,int mode = ios::out,
                     int openprot = filebuf::openprot);

filename：　　要打开的文件名
mode：　　　　要打开文件的方式
prot：　　　　打开文件的属性

　　其中mode和openprot这两个参数的可选项表见下表：

mode属性表
ios::app	以追加的方式打开文件
ios::ate	文件打开后定位到文件尾，ios:app就包含有此属性
ios::binary	以二进制方式打开文件，缺省的方式是文本方式。两种方式的区别见前文
ios::in	文件以输入方式打开
ios::out	文件以输出方式打开
ios::trunc	如果文件存在，把文件长度设为0

　　可以用“或”把以上属性连接起来，如ios::out|ios::binary。

openprot属性表
属性	含义
0	普通文件，打开访问
1	只读文件
2	隐含文件
4	系统文件

　　可以用“或”或者“+”把以上属性连接起来，如3或1|2就是以只读和隐含属性打开文件。

实例代码如下：

#include  
usingnamespace std; 

int main()  
{ 
        ofstream myfile("c:\\1.txt",ios::out|ios::trunc,0); 
        myfile<<"白纸人生"<网址："<<"www.cppblog.com/andxie99"; 
        myfile.close() 
        system("pause"); 
}

　　文件使用完后可以使用close成员函数关闭文件。

　　ios::app为追加模式，在使用追加模式的时候同时进行文件状态的判断是一个比较好的习惯。

　　示例如下：

#include  
#include  
usingnamespace std; 
int main()  
{ 
        ofstream myfile("c:\\1.txt",ios::app,0); 
        if(!myfile)//或者写成myfile.fail() 
        { 
                cout<<"文件打开失败，目标文件状态可能为只读！"; 
                system("pause"); 
                exit(1); 
        } 
        myfile<<"白纸人生"<网址："<<"www.cppblog.com/andxie99"<

　　在定义ifstream和ofstream类对象的时候，我们也可以不指定文件。以后可以通过成员函数open()显式的把一个文件连接到一个类对象上。

　　例如：

#include  
#include  
usingnamespace std; 
int main()  
{ 
        ofstream myfile; 
        myfile.open("c:\\1.txt",ios::out|ios::app,0); 
        if(!myfile)//或者写成myfile.fail() 
        { 
                cout<<"文件创建失败,磁盘不可写或者文件为只读!"; 
                system("pause"); 
                exit(1); 
        } 
        myfile<<"白纸人生"<网址："<<"www.cppblog.com/andxie99"<

　　下面我们来看一下是如何利用ifstream类对象，将文件中的数据读取出来，然后再输出到标准设备中的例子。

　　代码如下：

#include  
#include  
#include  
usingnamespace std; 
int main()  
{ 
        ifstream myfile; 
        myfile.open("c:\\1.txt",ios::in,0); 
        if(!myfile) 
        { 
                cout<<"文件读错误"; 
                system("pause"); 
                exit(1); 
        } 
        char ch; 
        string content; 
        while(myfile.get(ch)) 
        { 
                content+=ch; 
                cout.put(ch);//cout<
        } 
        myfile.close(); 
        cout<pause"); 
}

　　上例中，我们利用成员函数get()，逐一的读取文件中的有效字符，再利用put()成员函数，将文件中的数据通过循环逐一输出到标准设备(屏幕)上， get()成员函数会在文件读到默尾的时候返回假值，所以我们可以利用它的这个特性作为while循环的终止条件，我们同时也在上例中引入了C++风格的字符串类型string，在循环读取的时候逐一保存到content中，要使用string类型，必须包含string.h的头文件。

我们在简单介绍过ofstream类和ifstream类后，我们再来看一下fstream类，fstream类是由iostream派生而来，fstream类对象可以同对文件进行读写操作。

　　示例代码如下：

#include  
#include  
usingnamespace std; 
int main()  
{ 
        fstream myfile; 
        myfile.open("c:\\1.txt",ios::out|ios::app,0); 
        if(!myfile) 
        { 
                cout<<"文件写错误,文件属性可能为只读!"<pause"); 
                exit(1); 
        } 
        myfile<<"白纸人生"<网址："<<"www.cppblog.com/andxie99"<c:\\1.txt",ios::in,0); 
        if(!myfile) 
        { 
                cout<<"文件读错误,文件可能丢失!"<pause"); 
                exit(1); 
        } 
        char ch; 
        while(myfile.get(ch)) 
        { 
                cout.put(ch); 
        } 
        myfile.close(); 
        system("pause"); 
}

　　由于fstream类可以对文件同时进行读写操作，所以对它的对象进行初始话的时候一定要显式的指定mode和openprot参数。

　　接下来我们来学习一下串流类的基础知识，什么叫串流类？

3 strstream: ostrstream 和 istrstream

　　简单的理解就是能够控制字符串类型对象进行输入输出的类，C++不光可以支持C++风格的字符串流控制，还可以支持C风格的字符串流控制。

　　我们先看看看C++是如何对C风格的字符串流进行控制的，C中的字符串其实也就是字符数组，字符数组内的数据在内存中的位置的排列是连续的，我们通常用 char str[size]或者char *str的方式声明创建C风格字符数组，为了能让字符数组作为设备并提供输入输出操作，C++引入了ostrstream、istrstream、 strstream这三个类，要使用他们创建对象就必须包含strstream.h头文件。

istrstream类用于执行C风格的串流的输入操作，也就是以字符串数组作为输入设备。
ostrstream类用于执行C风格的串流的输出操作，也就是一字符串数组作为输出设备。
strstream类同时可以支持C风格的串流的输入输出操作。

　　istrstream类是从istream（输入流类）和strstreambase（字符串流基类）派生而来，ostrstream是从 ostream（输出流类）和strstreambase（字符串流基类）派生而来，strstream则是从iostream(输入输出流类)和和 strstreambase（字符串流基类）派生而来。

　　他们的继承关系如下图所示:

　　串流同样不是标准设备，不会有预先定义好的全局对象，所以不能直接操作，需要通过构造函数创建对象。

类istrstream的构造函数原形如下：

　　istrstream::istrstream(constchar *str,int size);

　　参数1表示字符串数组,而参数2表示数组大小，当size为0时，表示istrstream类对象直接连接到由str所指向的内存空间并以\0结尾的字符串。

　　下面的示例代码就是利用istrstream类创建类对象，制定流输入设备为字符串数组，通过它向一个字符型对象输入数据。代码如下：

#include  
#include  
usingnamespace std; 
int main()  
{ 
        char *name = "www.cppblog.com/andxie99"; 
        int arraysize = strlen(name)+1; 
        istrstream is(name,arraysize); 
        char temp; 
        is>>temp; 
        cout<pause"); 
}

　　类ostrstream用于执行串流的输出，它的构造函数如下所示：

　　ostrstream::ostrstream(char *_Ptr,int streamsize,int Mode = ios::out);

　　第一个参数是字符数组，第二个是说明数组的大小，第三个参数是指打开方式。

　　我们来一个示例代码：

#include  
#include  
usingnamespace std; 
int main()  
{ 
        int arraysize=1; 
        char *pbuffer=newchar[arraysize]; 
        ostrstream ostr(pbuffer,arraysize,ios::out); 
        ostr<//使用ostrstream输出到流对象的时候,要用ends结束字符串 
        cout<delete[] pbuffer; 
        system("pause"); 
}

　　上面的代码中，我们创建一个c风格的串流输出对象ostr，我们将arraysize内的数据成功的以字符串的形式输出到了ostr对象所指向的pbuffer指针的堆空间中，pbuffer也正是我们要输出的字符串数组，在结尾要使用ends结束字符串，如果不这么做就有溢出的危险。

4 stringstream

对于stringstream了来说，不用我多说，大家也已经知道它是用于C++风格的字符串的输入输出的。　　stringstream的构造函数原形如下：

　　stringstream::stringstream(string str);

　　示例代码如下:

#include  
#include  
#include  
usingnamespace std; 

int main()  
{ 
        stringstream ostr("ccc"); 
        ostr.put('d'); 
        ostr.put('e'); 
        ostr<<"fg"; 
        string gstr = ostr.str(); 
        cout<char a; 
        ostr>>a; 
        cout<pause"); 
}

　　除此而外，stringstream类的对象我们还常用它进行string与各种内置类型数据之间的转换。示例代码如下：

#include  
#include  
#include  
usingnamespace std; 

int main()  
{ 
        stringstream sstr; 
        //--------int转string----------- int a=100; 
        string str; 
        sstr<>str; 
        cout<//--------string转char[]-------- 
        sstr.clear();//如果你想通过使用同一stringstream对象实现多种类型的转换，
                        //请注意在每一次转换之后都必须调用clear()成员函数。 
        string name = "colinguan"; 
        char cname[200]; 
        sstr<>cname; 
        cout<pause"); 
}

　　接下来我们来学习一下输入/输出的状态标志的相关知识.

5 io_state 输入/输出的状态标志

C++中负责的输入/输出的系统包括了关于每一个输入/输出操作的结果的记录信息。这些当前的状态信息被包含在io_state类型的对象中。io_state是一个枚举类型（就像open_mode一样），以下便是它包含的值。

goodbit 无错误
Eofbit 已到达文件尾
failbit 非致命的输入/输出错误，可挽回
badbit　致命的输入/输出错误,无法挽回

有两种方法可以获得输入/输出的状态信息。一种方法是通过调用rdstate()函数，它将返回当前状态的错误标记。例如，假如没有任何错误，则rdstate()会返回goodbit.下例示例，表示出了rdstate()的用法：

#include  
usingnamespace std; 

int main()  
{ 
        int a; 
        cin>>a; 
        cout<if(cin.rdstate() == ios::goodbit) 
        { 
                cout<<"输入数据的类型正确，无错误！"<if(cin.rdstate() == ios_base::failbit) 
        { 
                cout<<"输入数据类型错误，非致命错误，可清除输入缓冲区挽回！"<pause"); 
}

　　另一种方法则是使用下面任何一个函数来检测相应的输入/输出状态：

bool bad();
bool eof();
bool fail();
bool good();

　　下例示例，表示出了上面各成员函数的用法：

#include  
usingnamespace std; 

int main()  
{ 
        int a; 
        cin>>a; 
        cout<if(cin.good()) 
        { 
                cout<<"输入数据的类型正确，无错误！"<if(cin.fail()) 
        { 
                cout<<"输入数据类型错误，非致命错误，可清除输入缓冲区挽回！"<pause"); 
}

　　如果错误发生，那么流状态既被标记为错误，你必须清除这些错误状态，以使你的程序能正确适当地继续运行。要清除错误状态，需使用clear()函数。此函数带一个参数，它是你将要设为当前状态的标志值。，只要将ios::goodbit作为实参。

　　示例代码如下：

#include  
usingnamespace std; 

int main()  
{ 
        int a; 
        cin>>a; 
        cout<pause"); 
}

通常当我们发现输入有错又需要改正的时候，使用clear()更改标记为正确后，同时也需要使用get()成员函数清除输入缓冲区，以达到重复输入的目的。

　　示例代码如下：

#include  
usingnamespace std; 

int main()  
{ 
        int a; 
        while(1) 
        { 
                cin>>a; 
                if(!cin)//条件可改写为cin.fail() 
                { 
                        cout<<"输入有错!请重新输入"<else 
                { 
                        cout<break; 
                } 
        } 
        system("pause"); 
}

　　最后再给出一个对文件流错误标记处理的例子，巩固学习，代码如下：

#include  
#include  
usingnamespace std; 

int main()  
{ 
        ifstream myfile("c:\\1.txt",ios_base::in,0); 
        if(myfile.fail()) 
        { 
                cout<<"文件读取失败或指定文件不存在!"<else 
        { 
                char ch; 
                while(myfile.get(ch)) 
                { 
                        cout<if(myfile.eof()) 
                { 
                        cout<<"文件内容已经全部读完"<while(myfile.get(ch)) 
                { 
                        cout<pause"); 
}

思勤无邪 2006-06-29 08:21 发表评论

C++内存分配的五种方法的区别

思勤无邪 — Tue, 20 Jun 2006 04:33:00 GMT

　　在C++中，内存分成5个区，他们分别是堆、栈、自由存储区、全局/静态存储区和常量存储区。

　　栈，就是那些由编译器在需要的时候分配，在不需要的时候自动清楚的变量的存储区。里面的变量通常是局部变量、函数参数等。

　　堆，就是那些由new分配的内存块，他们的释放编译器不去管，由我们的应用程序去控制，一般一个new就要对应一个delete。如果程序员没有释放掉，那么在程序结束后，操作系统会自动回收。

　　自由存储区，就是那些由malloc等分配的内存块，他和堆是十分相似的，不过它是用free来结束自己的生命的。

　　全局/静态存储区，全局变量和静态变量被分配到同一块内存中，在以前的C语言中，全局变量又分为初始化的和未初始化的，在C++里面没有这个区分了，他们共同占用同一块内存区。

　　常量存储区，这是一块比较特殊的存储区，他们里面存放的是常量，不允许修改（当然，你要通过非正当手段也可以修改，而且方法很多，在《const的思考》一文中，我给出了6种方法）

　　明确区分堆与栈

　　在bbs上，堆与栈的区分问题，似乎是一个永恒的话题，由此可见，初学者对此往往是混淆不清的，所以我决定拿他第一个开刀。

　　首先，我们举一个例子：

void f() { int* p=new int[5]; }

　　这条短短的一句话就包含了堆与栈，看到new，我们首先就应该想到，我们分配了一块堆内存，那么指针p呢？他分配的是一块栈内存，所以这句话的意思就是：在栈内存中存放了一个指向一块堆内存的指针p。在程序会先确定在堆中分配内存的大小，然后调用operator new分配内存，然后返回这块内存的首地址，放入栈中，他在VC6下的汇编代码如下：

00401028 push 14h
0040102A call operator new (00401060)
0040102F add esp,4
00401032 mov dword ptr [ebp-8],eax
00401035 mov eax,dword ptr [ebp-8]
00401038 mov dword ptr [ebp-4],eax

　　这里，我们为了简单并没有释放内存，那么该怎么去释放呢？是delete p么？澳，错了，应该是delete []p，这是为了告诉编译器：我删除的是一个数组，VC6就会根据相应的Cookie信息去进行释放内存的工作。

　　好了，我们回到我们的主题：堆和栈究竟有什么区别？

　　主要的区别由以下几点：

　　1、管理方式不同；

　　2、空间大小不同；

　　3、能否产生碎片不同；

　　4、生长方向不同；

　　5、分配方式不同；

　　6、分配效率不同；

　　管理方式：对于栈来讲，是由编译器自动管理，无需我们手工控制；对于堆来说，释放工作由程序员控制，容易产生memory leak。

　　空间大小：一般来讲在32位系统下，堆内存可以达到4G的空间，从这个角度来看堆内存几乎是没有什么限制的。但是对于栈来讲，一般都是有一定的空间大小的，例如，在VC6下面，默认的栈空间大小是1M（好像是，记不清楚了）。当然，我们可以修改：

　　打开工程，依次操作菜单如下：Project->Setting->Link，在Category 中选中Output，然后在Reserve中设定堆栈的最大值和commit。

　　注意：reserve最小值为4Byte；commit是保留在虚拟内存的页文件里面，它设置的较大会使栈开辟较大的值，可能增加内存的开销和启动时间。

　　碎片问题：对于堆来讲，频繁的new/delete势必会造成内存空间的不连续，从而造成大量的碎片，使程序效率降低。对于栈来讲，则不会存在这个问题，因为栈是先进后出的队列，他们是如此的一一对应，以至于永远都不可能有一个内存块从栈中间弹出，在他弹出之前，在他上面的后进的栈内容已经被弹出，详细的可以参考数据结构，这里我们就不再一一讨论了。

　　生长方向：对于堆来讲，生长方向是向上的，也就是向着内存地址增加的方向；对于栈来讲，它的生长方向是向下的，是向着内存地址减小的方向增长。

　　分配方式：堆都是动态分配的，没有静态分配的堆。栈有2种分配方式：静态分配和动态分配。静态分配是编译器完成的，比如局部变量的分配。动态分配由alloca函数进行分配，但是栈的动态分配和堆是不同的，他的动态分配是由编译器进行释放，无需我们手工实现。

　　分配效率：栈是机器系统提供的数据结构，计算机会在底层对栈提供支持：分配专门的寄存器存放栈的地址，压栈出栈都有专门的指令执行，这就决定了栈的效率比较高。堆则是C/C++函数库提供的，它的机制是很复杂的，例如为了分配一块内存，库函数会按照一定的算法（具体的算法可以参考数据结构/操作系统）在堆内存中搜索可用的足够大小的空间，如果没有足够大小的空间（可能是由于内存碎片太多），就有可能调用系统功能去增加程序数据段的内存空间，这样就有机会分到足够大小的内存，然后进行返回。显然，堆的效率比栈要低得多。

　　从这里我们可以看到，堆和栈相比，由于大量new/delete的使用，容易造成大量的内存碎片；由于没有专门的系统支持，效率很低；由于可能引发用户态和核心态的切换，内存的申请，代价变得更加昂贵。所以栈在程序中是应用最广泛的，就算是函数的调用也利用栈去完成，函数调用过程中的参数，返回地址，EBP和局部变量都采用栈的方式存放。所以，我们推荐大家尽量用栈，而不是用堆。

　　虽然栈有如此众多的好处，但是由于和堆相比不是那么灵活，有时候分配大量的内存空间，还是用堆好一些。

　　无论是堆还是栈，都要防止越界现象的发生（除非你是故意使其越界），因为越界的结果要么是程序崩溃，要么是摧毁程序的堆、栈结构，产生以想不到的结果,就算是在你的程序运行过程中，没有发生上面的问题，你还是要小心，说不定什么时候就崩掉，那时候debug可是相当困难的：）

思勤无邪 2006-06-20 12:33 发表评论

static_cast<>揭密

思勤无邪 — Wed, 14 Jun 2006 06:54:00 GMT

作者：Sam NG

译者：小刀人

原文链接：What static_cast<> is actually doing

本文讨论static_cast<> 和 reinterpret_cast<>。

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

泛型（Generic Types）

        float f = 12.3;

        float* pf = &f;
      // static cast<>

        // 成功编译, n = 12

        int n = static_cast(f);

        // 错误,指向的类型是无关的（译注：即指针变量pf是float类型，现在要被转换为int类型）
        //int* pn = static_cast(pf);

        //成功编译

        void* pv = static_cast(pf);

        //成功编译, 但是 *pn2是无意义的内存（rubbish）

        int* pn2 = static_cast(pv);
// reinterpret_cast<>

        //错误,编译器知道你应该调用static_cast<>

        //int i = reinterpret_cast(f);

        //成功编译, 但是 *pn 实际上是无意义的内存,和 *pn2一样

        int* pi = reinterpret_cast(pf);

简而言之，static_cast<> 将尝试转换，举例来说，如float-到-integer，而reinterpret_cast<>简单改变编译器的意图重新考虑那个对象作为另一类型。

指针类型（Pointer Types）

指针转换有点复杂，我们将在本文的剩余部分使用下面的类：

class CBaseX

      {

      public:

      int x;

      CBaseX() { x = 10; }

      void foo() { printf("CBaseX::foo() x=%d\n", x); }

      };
      class CBaseY

        {

        public:

        int y;

        int* py;

        CBaseY() { y = 20; py = &y; }

        void bar() { printf("CBaseY::bar() y=%d, *py=%d\n", y, *py); 
        }

        };
class CDerived : public CBaseX, public CBaseY

        {

        public:

        int z;

        };

情况1：两个无关的类之间的转换

      // Convert between CBaseX* and CBaseY*

      // CBaseX* 和 CBaseY*之间的转换

      CBaseX* pX = new CBaseX();

      // Error, types pointed to are unrelated

      // 错误， 类型指向是无关的

      // CBaseY* pY1 = static_cast(pX);

      // Compile OK, but pY2 is not CBaseX

      // 成功编译, 但是 pY2 不是CBaseX

      CBaseY* pY2 = reinterpret_cast(pX);

      // System crash!!

      // 系统崩溃!!

      // pY2->bar();

正如我们在泛型例子中所认识到的，如果你尝试转换一个对象到另一个无关的类static_cast<>将失败，而reinterpret_cast<>就总是成功“欺骗”编译器：那个对象就是那个无关类。

情况2：转换到相关的类

      1. CDerived* pD = new CDerived();

      2. printf("CDerived* pD = %x\n", (int)pD);

      3. 

      4. // static_cast<> CDerived* -> CBaseY* -> CDerived*

      //成功编译，隐式static_cast<>转换

      5. CBaseY* pY1 = pD;

      6. printf("CBaseY* pY1 = %x\n", (int)pY1);

      // 成功编译, 现在 pD1 = pD

      7. CDerived* pD1 = static_cast(pY1);

      8. printf("CDerived* pD1 = %x\n", (int)pD1);

      9. 

      10. // reinterpret_cast

      // 成功编译, 但是 pY2 不是 CBaseY*

      11. CBaseY* pY2 = reinterpret_cast(pD);

      12. printf("CBaseY* pY2 = %x\n", (int)pY2);

      13. 

      14. // 无关的 static_cast<>

      15. CBaseY* pY3 = new CBaseY();

      16. printf("CBaseY* pY3 = %x\n", (int)pY3);

      // 成功编译,尽管 pY3 只是一个 "新 CBaseY()"

      17. CDerived* pD3 = static_cast(pY3);

      18. printf("CDerived* pD3 = %x\n", (int)pD3);

      ---------------------- 输出 ---------------------------

      CDerived* pD = 392fb8

      CBaseY* pY1 = 392fbc

      CDerived* pD1 = 392fb8

      CBaseY* pY2 = 392fb8

      CBaseY* pY3 = 390ff0

      CDerived* pD3 = 390fec

注意：在将CDerived*用隐式 static_cast<>转换到CBaseY*（第5行）时，结果是（指向）CDerived*（的指针向后）偏移了4（个字节）（译注：4为int类型在内存中所占字节数）。为了知道static_cast<> 实际如何，我们不得不要来看一下CDerived的内存布局。

CDerived的内存布局（Memory Layout）

如图所示，CDerived的内存布局包括两个对象，CBaseX 和 CBaseY，编译器也知道这一点。因此，当你将CDerived* 转换到 CBaseY*时，它给指针添加4个字节，同时当你将CBaseY*转换到CDerived*时，它给指针减去4。然而，甚至它即便不是一个CDerived你也可以这样做。
当然，这个问题只在如果你做了多继承时发生。在你将CDerived转换到 CBaseX时static_cast<> 和 reinterpret_cast<>是没有区别的。

情况3：void*之间的向前和向后转换

因为任何指针可以被转换到void*，而void*可以被向后转换到任何指针（对于static_cast<> 和 reinterpret_cast<>转换都可以这样做），如果没有小心处理的话错误可能发生。

    CDerived* pD = new CDerived();

        printf("CDerived* pD = %x\n", (int)pD);
    CBaseY* pY = pD; // 成功编译, pY = pD + 4

        printf("CBaseY* pY = %x\n", (int)pY);
      void* pV1 = pY; //成功编译, pV1 = pY

        printf("void* pV1 = %x\n", (int)pV1);
         // pD2 = pY, 但是我们预期 pD2 = pY - 4

        CDerived* pD2 = static_cast(pV1);

        printf("CDerived* pD2 = %x\n", (int)pD2);

        // 系统崩溃

        // pD2->bar();

        ---------------------- 输出 ---------------------------

        CDerived* pD = 392fb8

        CBaseY* pY = 392fbc

        void* pV1 = 392fbc

        CDerived* pD2 = 392fbc

一旦我们已经转换指针为void*，我们就不能轻易将其转换回原类。在上面的例子中，从一个void* 返回CDerived*的唯一方法是将其转换为CBaseY*然后再转换为CDerived*。
但是如果我们不能确定它是CBaseY* 还是 CDerived*，这时我们不得不用dynamic_cast<> 或typeid[2]。

注释：
1. dynamic_cast<>，从另一方面来说，可以防止一个泛型CBaseY* 被转换到CDerived*。
2. dynamic_cast<>需要类成为多态，即包括“虚”函数，并因此而不能成为void*。

思勤无邪 2006-06-14 14:54 发表评论