jianlinzhang

        最近一段时间安装了boost，但是由于以前无这方面的经验，导致了在安装完boost后，运用到vs2005或者vs2008时，visual assist 会不停的解析boost，导致我的虚拟内存会不断增加，最后死机或者vs崩溃，开始还以为自己在编译boost库时出现了问题，因此继续上网寻找关于这方面的问题，时至今日才发现网络也并非万能，或者可能我的问题大家都没遇到过，总之，该问题我一直没有解决，只好忍痛割爱，将va的设置中不添加boost一项。尽管关于boost的程序编译，运行都没有问题，但在缺少了va的强力支撑下，编写boost程序的相当的繁琐。。。
        今天，我终于发现了其中的缘由，原来是因为我的boost目录中包含的有中文字符串。。。哎，没想到啊。在重新设置了boost的目录后，一切就ok了。。。
        希望这对于有些同行来说有点用处。。。O(∩_∩)O哈哈~

1	堆和栈的区别 (转贴)
	堆和栈的区别 (转贴)  非本人作也!因非常经典,所以收归旗下,与众人阅之!原作者不祥! 堆和栈的区别 一、预备知识—程序的内存分配 一个由c/C++编译的程序占用的内存分为以下几个部分 1、栈区（stack）— 由编译器自动分配释放 ，存放函数的参数值，局部变量的值等。其操作方式类似于数据结构中的栈。 2、堆区（heap） — 一般由程序员分配释放， 若程序员不释放，程序结束时可能由OS回收 。注意它与数据结构中的堆是两回事，分配方式倒是类似于链表，呵呵。 3、全局区（静态区）（static）—，全局变量和静态变量的存储是放在一块的，初始化的全局变量和静态变量在一块区域， 未初始化的全局变量和未初始化的静态变量在相邻的另一块区域。 - 程序结束后有系统释放  4、文字常量区—常量字符串就是放在这里的。 程序结束后由系统释放 5、程序代码区—存放函数体的二进制代码。 二、例子程序  这是一个前辈写的，非常详细  //main.cpp  int a = 0; 全局初始化区  char *p1; 全局未初始化区  main()  {  int b; 栈  char s[] = "abc"; 栈  char *p2; 栈  char *p3 = "123456"; 123456\0在常量区，p3在栈上。  static int c =0； 全局（静态）初始化区  p1 = (char *)malloc(10);  p2 = (char *)malloc(20);  分配得来得10和20字节的区域就在堆区。  strcpy(p1, "123456"); 123456\0放在常量区，编译器可能会将它与p3所指向的"123456"优化成一个地方。  }    二、堆和栈的理论知识  2.1申请方式  stack:  由系统自动分配。 例如，声明在函数中一个局部变量 int b; 系统自动在栈中为b开辟空间  heap:  需要程序员自己申请，并指明大小，在c中malloc函数  如p1 = (char *)malloc(10);  在C++中用new运算符  如p2 = (char *)malloc(10);  但是注意p1、p2本身是在栈中的。  2.2  申请后系统的响应  栈：只要栈的剩余空间大于所申请空间，系统将为程序提供内存，否则将报异常提示栈溢出。  堆：首先应该知道操作系统有一个记录空闲内存地址的链表，当系统收到程序的申请时，  会遍历该链表，寻找第一个空间大于所申请空间的堆结点，然后将该结点从空闲结点链表中删除，并将该结点的空间分配给程序，另外，对于大多数系统，会在这块内存空间中的首地址处记录本次分配的大小，这样，代码中的delete语句才能正确的释放本内存空间。另外，由于找到的堆结点的大小不一定正好等于申请的大小，系统会自动的将多余的那部分重新放入空闲链表中。  2.3申请大小的限制  栈：在Windows下,栈是向低地址扩展的数据结构，是一块连续的内存的区域。这句话的意思是栈顶的地址和栈的最大容量是系统预先规定好的，在WINDOWS下，栈的大小是2M（也有的说是1M，总之是一个编译时就确定的常数），如果申请的空间超过栈的剩余空间时，将提示overflow。因此，能从栈获得的空间较小。  堆：堆是向高地址扩展的数据结构，是不连续的内存区域。这是由于系统是用链表来存储的空闲内存地址的，自然是不连续的，而链表的遍历方向是由低地址向高地址。堆的大小受限于计算机系统中有效的虚拟内存。由此可见，堆获得的空间比较灵活，也比较大。  2.4申请效率的比较：  栈由系统自动分配，速度较快。但程序员是无法控制的。  堆是由new分配的内存，一般速度比较慢，而且容易产生内存碎片,不过用起来最方便.  另外，在WINDOWS下，最好的方式是用VirtualAlloc分配内存，他不是在堆，也不是在栈是直接在进程的地址空间中保留一快内存，虽然用起来最不方便。但是速度快，也最灵活。  2.5堆和栈中的存储内容  栈： 在函数调用时，第一个进栈的是主函数中后的下一条指令（函数调用语句的下一条可执行语句）的地址，然后是函数的各个参数，在大多数的C编译器中，参数是由右往左入栈的，然后是函数中的局部变量。注意静态变量是不入栈的。
	作者：121.30.67.* 2006-11-26 23:15 回复此发言

2	堆和栈的区别 (转贴)
	当本次函数调用结束后，局部变量先出栈，然后是参数，最后栈顶指针指向最开始存的地址，也就是主函数中的下一条指令，程序由该点继续运行。  堆：一般是在堆的头部用一个字节存放堆的大小。堆中的具体内容有程序员安排。  2.6存取效率的比较  char s1[] = "aaaaaaaaaaaaaaa";  char *s2 = "bbbbbbbbbbbbbbbbb";  aaaaaaaaaaa是在运行时刻赋值的；  而bbbbbbbbbbb是在编译时就确定的；  但是，在以后的存取中，在栈上的数组比指针所指向的字符串(例如堆)快。  比如：  #include  void main()  {  char a = 1;  char c[] = "1234567890";  char *p ="1234567890";  a = c[1];  a = p[1];  return;  }  对应的汇编代码  10: a = c[1];  00401067 8A 4D F1 mov cl,byte ptr [ebp-0Fh]  0040106A 88 4D FC mov byte ptr [ebp-4],cl  11: a = p[1];  0040106D 8B 55 EC mov edx,dword ptr [ebp-14h]  00401070 8A 42 01 mov al,byte ptr [edx+1]  00401073 88 45 FC mov byte ptr [ebp-4],al  第一种在读取时直接就把字符串中的元素读到寄存器cl中，而第二种则要先把指针值读到edx中，在根据edx读取字符，显然慢了。  2.7小结：  堆和栈的区别可以用如下的比喻来看出：  使用栈就象我们去饭馆里吃饭，只管点菜（发出申请）、付钱、和吃（使用），吃饱了就走，不必理会切菜、洗菜等准备工作和洗碗、刷锅等扫尾工作，他的好处是快捷，但是自由度小。  使用堆就象是自己动手做喜欢吃的菜肴，比较麻烦，但是比较符合自己的口味，而且自由度大。  windows进程中的内存结构 在阅读本文之前，如果你连堆栈是什么多不知道的话，请先阅读文章后面的基础知识。  接触过编程的人都知道，高级语言都能通过变量名来访问内存中的数据。那么这些变量在内存中是如何存放的呢？程序又是如何使用这些变量的呢？下面就会对此进行深入的讨论。下文中的C语言代码如没有特别声明，默认都使用VC编译的release版。  首先，来了解一下 C 语言的变量是如何在内存分部的。C 语言有全局变量(Global)、本地变量(Local)，静态变量(Static)、寄存器变量(Regeister)。每种变量都有不同的分配方式。先来看下面这段代码：  #include <stdio.h>  int g1=0, g2=0, g3=0;  int main()  {  static int s1=0, s2=0, s3=0;  int v1=0, v2=0, v3=0;  //打印出各个变量的内存地址  printf("0x%08x\n",&v1); //打印各本地变量的内存地址  printf("0x%08x\n",&v2);  printf("0x%08x\n\n",&v3);  printf("0x%08x\n",&g1); //打印各全局变量的内存地址  printf("0x%08x\n",&g2);  printf("0x%08x\n\n",&g3);  printf("0x%08x\n",&s1); //打印各静态变量的内存地址  printf("0x%08x\n",&s2);  printf("0x%08x\n\n",&s3);  return 0;  }  编译后的执行结果是：  0x0012ff78  0x0012ff7c  0x0012ff80  0x004068d0  0x004068d4  0x004068d8  0x004068dc  0x004068e0  0x004068e4  输出的结果就是变量的内存地址。其中v1,v2,v3是本地变量，g1,g2,g3是全局变量，s1,s2,s3是静态变量。你可以看到这些变量在内存是连续分布的，但是本地变量和全局变量分配的内存地址差了十万八千里，而全局变量和静态变量分配的内存是连续的。这是因为本地变量和全局/静态变量是分配在不同类型的内存区域中的结果。对于一个进程的内存空间而言，可以在逻辑上分成3个部份：代码区，静态数据区和动态数据区。动态数据区一般就是“堆栈”。“栈(stack)”和“堆(heap)”是两种不同的动态数据区，栈是一种线性结构，堆是一种链式结构。进程的每个线程都有私有的“栈”，所以每个线程虽然代码一样，但本地变量的数据都是互不干扰。一个堆栈可以通过“基地址”和“栈顶”地址来描述。全局变量和静态变量分配在静态数据区，本地变量分配在动态数据区，即堆栈中。程序通过堆栈的基地址和偏移量来访问本地变量。
	作者：121.30.67.* 2006-11-26 23:15 回复此发言

3	堆和栈的区别 (转贴)
	├———————┤低端内存区域  │ …… │  ├———————┤  │ 动态数据区 │  ├———————┤  │ …… │  ├———————┤  │ 代码区 │  ├———————┤  │ 静态数据区 │  ├———————┤  │ …… │  ├———————┤高端内存区域  堆栈是一个先进后出的数据结构，栈顶地址总是小于等于栈的基地址。我们可以先了解一下函数调用的过程，以便对堆栈在程序中的作用有更深入的了解。不同的语言有不同的函数调用规定，这些因素有参数的压入规则和堆栈的平衡。windows API的调用规则和ANSI C的函数调用规则是不一样的，前者由被调函数调整堆栈，后者由调用者调整堆栈。两者通过“__stdcall”和“__cdecl”前缀区分。先看下面这段代码：  #include <stdio.h>  void __stdcall func(int param1,int param2,int param3)  {  int var1=param1;  int var2=param2;  int var3=param3;  printf("0x%08x\n",¶m1); //打印出各个变量的内存地址  printf("0x%08x\n",¶m2);  printf("0x%08x\n\n",¶m3);  printf("0x%08x\n",&var1);  printf("0x%08x\n",&var2);  printf("0x%08x\n\n",&var3);  return;  }  int main()  {  func(1,2,3);  return 0;  }  编译后的执行结果是：  0x0012ff78  0x0012ff7c  0x0012ff80  0x0012ff68  0x0012ff6c  0x0012ff70  ├———————┤<—函数执行时的栈顶（ESP）、低端内存区域  │ …… │  ├———————┤  │ var 1 │  ├———————┤  │ var 2 │  ├———————┤  │ var 3 │  ├———————┤  │ RET │  ├———————┤<—“__cdecl”函数返回后的栈顶（ESP）  │ parameter 1 │  ├———————┤  │ parameter 2 │  ├———————┤  │ parameter 3 │  ├———————┤<—“__stdcall”函数返回后的栈顶（ESP）  │ …… │  ├———————┤<—栈底（基地址 EBP）、高端内存区域  上图就是函数调用过程中堆栈的样子了。首先，三个参数以从又到左的次序压入堆栈，先压“param3”，再压“param2”，最后压入“param1”；然后压入函数的返回地址(RET)，接着跳转到函数地址接着执行（这里要补充一点，介绍UNIX下的缓冲溢出原理的文章中都提到在压入RET后，继续压入当前EBP，然后用当前ESP代替EBP。然而，有一篇介绍windows下函数调用的文章中说，在windows下的函数调用也有这一步骤，但根据我的实际调试，并未发现这一步，这还可以从param3和var1之间只有4字节的间隙这点看出来）；第三步，将栈顶(ESP)减去一个数，为本地变量分配内存空间，上例中是减去12字节(ESP=ESP-3*4，每个int变量占用4个字节)；接着就初始化本地变量的内存空间。由于“__stdcall”调用由被调函数调整堆栈，所以在函数返回前要恢复堆栈，先回收本地变量占用的内存(ESP=ESP+3*4)，然后取出返回地址，填入EIP寄存器，回收先前压入参数占用的内存(ESP=ESP+3*4)，继续执行调用者的代码。参见下列汇编代码：  ;--------------func 函数的汇编代码-------------------  :00401000 83EC0C sub esp, 0000000C //创建本地变量的内存空间  :00401003 8B442410 mov eax, dword ptr [esp+10]  :00401007 8B4C2414 mov ecx, dword ptr [esp+14]  :0040100B 8B542418 mov edx, dword ptr [esp+18]  :0040100F 89442400 mov dword ptr [esp], eax  :00401013 8D442410 lea eax, dword ptr [esp+10]  :00401017 894C2404 mov dword ptr [esp+04], ecx  ……………………（省略若干代码）  :00401075 83C43C add esp, 0000003C ;恢复堆栈，回收本地变量的内存空间  :00401078 C3 ret 000C ;函数返回，恢复参数占用的内存空间
	作者：121.30.67.* 2006-11-26 23:15 回复此发言

4	堆和栈的区别 (转贴)
	;如果是“__cdecl”的话，这里是“ret”，堆栈将由调用者恢复  ;-------------------函数结束-------------------------  ;--------------主程序调用func函数的代码--------------  :00401080 6A03 push 00000003 //压入参数param3  :00401082 6A02 push 00000002 //压入参数param2  :00401084 6A01 push 00000001 //压入参数param1  :00401086 E875FFFFFF call 00401000 //调用func函数  ;如果是“__cdecl”的话，将在这里恢复堆栈，“add esp, 0000000C”  聪明的读者看到这里，差不多就明白缓冲溢出的原理了。先来看下面的代码：  #include <stdio.h>  #include <string.h>  void __stdcall func()  {  char lpBuff[8]="\0";  strcat(lpBuff,"AAAAAAAAAAA");  return;  }  int main()  {  func();  return 0;  }  编译后执行一下回怎么样？哈，“"0x00414141"指令引用的"0x00000000"内存。该内存不能为"read"。”，“非法操作”喽！"41"就是"A"的16进制的ASCII码了，那明显就是strcat这句出的问题了。"lpBuff"的大小只有8字节，算进结尾的\0，那strcat最多只能写入7个"A"，但程序实际写入了11个"A"外加1个\0。再来看看上面那幅图，多出来的4个字节正好覆盖了RET的所在的内存空间，导致函数返回到一个错误的内存地址，执行了错误的指令。如果能精心构造这个字符串，使它分成三部分，前一部份仅仅是填充的无意义数据以达到溢出的目的，接着是一个覆盖RET的数据，紧接着是一段shellcode，那只要着个RET地址能指向这段shellcode的第一个指令，那函数返回时就能执行shellcode了。但是软件的不同版本和不同的运行环境都可能影响这段shellcode在内存中的位置，那么要构造这个RET是十分困难的。一般都在RET和shellcode之间填充大量的NOP指令，使得exploit有更强的通用性。  ├———————┤<—低端内存区域  │ …… │  ├———————┤<—由exploit填入数据的开始  │ │  │ buffer │<—填入无用的数据  │ │  ├———————┤  │ RET │<—指向shellcode，或NOP指令的范围  ├———————┤  │ NOP │  │ …… │<—填入的NOP指令，是RET可指向的范围  │ NOP │  ├———————┤  │ │  │ shellcode │  │ │  ├———————┤<—由exploit填入数据的结束  │ …… │  ├———————┤<—高端内存区域  windows下的动态数据除了可存放在栈中，还可以存放在堆中。了解C++的朋友都知道，C++可以使用new关键字来动态分配内存。来看下面的C++代码：  #include <stdio.h>  #include <iostream.h>  #include <windows.h>  void func()  {  char *buffer=new char[128];  char bufflocal[128];  static char buffstatic[128];  printf("0x%08x\n",buffer); //打印堆中变量的内存地址  printf("0x%08x\n",bufflocal); //打印本地变量的内存地址  printf("0x%08x\n",buffstatic); //打印静态变量的内存地址  }  void main()  {  func();  return;  }  程序执行结果为：  0x004107d0  0x0012ff04  0x004068c0  可以发现用new关键字分配的内存即不在栈中，也不在静态数据区。VC编译器是通过windows下的“堆(heap)”来实现new关键字的内存动态分配。在讲“堆”之前，先来了解一下和“堆”有关的几个API函数：  HeapAlloc 在堆中申请内存空间  HeapCreate 创建一个新的堆对象  HeapDestroy 销毁一个堆对象  HeapFree 释放申请的内存  HeapWalk 枚举堆对象的所有内存块  GetProcessHeap 取得进程的默认堆对象  GetProcessHeaps 取得进程所有的堆对象  LocalAlloc  GlobalAlloc  当进程初始化时，系统会自动为进程创建一个默认堆，这个堆默认所占内存的大小为1M。堆对象由系统进行管理，它在内存中以链式结构存在。通过下面的代码可以通过堆动态申请内存空间：
	作者：121.30.67.* 2006-11-26 23:15 回复此发言

5	堆和栈的区别 (转贴)
	HANDLE hHeap=GetProcessHeap();  char *buff=HeapAlloc(hHeap,0,8);  其中hHeap是堆对象的句柄，buff是指向申请的内存空间的地址。那这个hHeap究竟是什么呢？它的值有什么意义吗？看看下面这段代码吧：  #pragma comment(linker,"/entry:main") //定义程序的入口  #include <windows.h>  _CRTIMP int (__cdecl *printf)(const char *, ...); //定义STL函数printf  /*---------------------------------------------------------------------------  写到这里，我们顺便来复习一下前面所讲的知识：  (*注)printf函数是C语言的标准函数库中函数，VC的标准函数库由msvcrt.dll模块实现。  由函数定义可见，printf的参数个数是可变的，函数内部无法预先知道调用者压入的参数个数，函数只能通过分析第一个参数字符串的格式来获得压入参数的信息，由于这里参数的个数是动态的，所以必须由调用者来平衡堆栈，这里便使用了__cdecl调用规则。BTW，Windows系统的API函数基本上是__stdcall调用形式，只有一个API例外，那就是wsprintf，它使用__cdecl调用规则，同printf函数一样，这是由于它的参数个数是可变的缘故。  ---------------------------------------------------------------------------*/  void main()  {  HANDLE hHeap=GetProcessHeap();  char *buff=HeapAlloc(hHeap,0,0x10);  char *buff2=HeapAlloc(hHeap,0,0x10);  HMODULE hMsvcrt=LoadLibrary("msvcrt.dll");  printf=(void *)GetProcAddress(hMsvcrt,"printf");  printf("0x%08x\n",hHeap);  printf("0x%08x\n",buff);  printf("0x%08x\n\n",buff2);  }  执行结果为：  0x00130000  0x00133100  0x00133118  hHeap的值怎么和那个buff的值那么接近呢？其实hHeap这个句柄就是指向HEAP首部的地址。在进程的用户区存着一个叫PEB(进程环境块)的结构，这个结构中存放着一些有关进程的重要信息，其中在PEB首地址偏移0x18处存放的ProcessHeap就是进程默认堆的地址，而偏移0x90处存放了指向进程所有堆的地址列表的指针。windows有很多API都使用进程的默认堆来存放动态数据，如windows 2000下的所有ANSI版本的函数都是在默认堆中申请内存来转换ANSI字符串到Unicode字符串的。对一个堆的访问是顺序进行的，同一时刻只能有一个线程访问堆中的数据，当多个线程同时有访问要求时，只能排队等待，这样便造成程序执行效率下降。  最后来说说内存中的数据对齐。所位数据对齐，是指数据所在的内存地址必须是该数据长度的整数倍，DWORD数据的内存起始地址能被4除尽，WORD数据的内存起始地址能被2除尽，x86 CPU能直接访问对齐的数据，当他试图访问一个未对齐的数据时，会在内部进行一系列的调整，这些调整对于程序来说是透明的，但是会降低运行速度，所以编译器在编译程序时会尽量保证数据对齐。同样一段代码，我们来看看用VC、Dev-C++和lcc三个不同编译器编译出来的程序的执行结果：  #include <stdio.h>  int main()  {  int a;  char b;  int c;  printf("0x%08x\n",&a);  printf("0x%08x\n",&b);  printf("0x%08x\n",&c);  return 0;  }  这是用VC编译后的执行结果：  0x0012ff7c  0x0012ff7b  0x0012ff80  变量在内存中的顺序：b(1字节)-a(4字节)-c(4字节)。  这是用Dev-C++编译后的执行结果：  0x0022ff7c  0x0022ff7b  0x0022ff74  变量在内存中的顺序：c(4字节)-中间相隔3字节-b(占1字节)-a(4字节)。  这是用lcc编译后的执行结果：  0x0012ff6c  0x0012ff6b  0x0012ff64  变量在内存中的顺序：同上。  三个编译器都做到了数据对齐，但是后两个编译器显然没VC“聪明”，让一个char占了4字节，浪费内存哦。  基础知识：  堆栈是一种简单的数据结构，是一种只允许在其一端进行插入或删除的线性表。允许插入或删除操作的一端称为栈顶，另一端称为栈底，对堆栈的插入和删除操作被称为入栈和出栈。有一组CPU指令可以实现对进程的内存实现堆栈访问。其中，POP指令实现出栈操作，PUSH指令实现入栈操作。CPU的ESP寄存器存放当前线程的栈顶指针，EBP寄存器中保存当前线程的栈底指针。CPU的EIP寄存器存放下一个CPU指令存放的内存地址，当CPU执行完当前的指令后，从EIP寄存器中读取下一条指令的内存地址，然后继续执行。
	作者：121.30.67.* 2006-11-26 23:15 回复此发言

6	堆和栈的区别 (转贴)
	参考：《Windows下的HEAP溢出及其利用》by: isno  《windows核心编程》by: Jeffrey Richter  摘要： 讨论常见的堆性能问题以及如何防范它们。（共 9 页） 前言 您是否是动态分配的 C/C++ 对象忠实且幸运的用户？您是否在模块间的往返通信中频繁地使用了“自动化”？您的程序是否因堆分配而运行起来很慢？不仅仅您遇到这样的问题。几乎所有项目迟早都会遇到堆问题。大家都想说，“我的代码真正好，只是堆太慢”。那只是部分正确。更深入理解堆及其用法、以及会发生什么问题，是很有用的。 什么是堆？ （如果您已经知道什么是堆，可以跳到“什么是常见的堆性能问题？”部分） 在程序中，使用堆来动态分配和释放对象。在下列情况下，调用堆操作：  事先不知道程序所需对象的数量和大小。 对象太大而不适合堆栈分配程序。 堆使用了在运行时分配给代码和堆栈的内存之外的部分内存。下图给出了堆分配程序的不同层。 GlobalAlloc/GlobalFree：Microsoft Win32 堆调用，这些调用直接与每个进程的默认堆进行对话。 LocalAlloc/LocalFree：Win32 堆调用（为了与 Microsoft Windows NT 兼容），这些调用直接与每个进程的默认堆进行对话。 COM 的 IMalloc 分配程序（或 CoTaskMemAlloc / CoTaskMemFree）：函数使用每个进程的默认堆。自动化程序使用“组件对象模型 (COM)”的分配程序，而申请的程序使用每个进程堆。 C/C++ 运行时 (CRT) 分配程序：提供了 malloc() 和 free() 以及 new 和 delete 操作符。如 Microsoft Visual Basic 和 Java 等语言也提供了新的操作符并使用垃圾收集来代替堆。CRT 创建自己的私有堆，驻留在 Win32 堆的顶部。 Windows NT 中，Win32 堆是 Windows NT 运行时分配程序周围的薄层。所有 API 转发它们的请求给 NTDLL。 Windows NT 运行时分配程序提供 Windows NT 内的核心堆分配程序。它由具有 128 个大小从 8 到 1,024 字节的空闲列表的前端分配程序组成。后端分配程序使用虚拟内存来保留和提交页。 在图表的底部是“虚拟内存分配程序”，操作系统使用它来保留和提交页。所有分配程序使用虚拟内存进行数据的存取。 分配和释放块不就那么简单吗？为何花费这么长时间？ 堆实现的注意事项 传统上，操作系统和运行时库是与堆的实现共存的。在一个进程的开始，操作系统创建一个默认堆，叫做“进程堆”。如果没有其他堆可使用，则块的分配使用“进程堆”。语言运行时也能在进程内创建单独的堆。（例如，C 运行时创建它自己的堆。）除这些专用的堆外，应用程序或许多已载入的动态链接库 (DLL) 之一可以创建和使用单独的堆。Win32 提供一整套 API 来创建和使用私有堆。有关堆函数（英文）的详尽指导，请参见 MSDN。 当应用程序或 DLL 创建私有堆时，这些堆存在于进程空间，并且在进程内是可访问的。从给定堆分配的数据将在同一个堆上释放。（不能从一个堆分配而在另一个堆释放。） 在所有虚拟内存系统中，堆驻留在操作系统的“虚拟内存管理器”的顶部。语言运行时堆也驻留在虚拟内存顶部。某些情况下，这些堆是操作系统堆中的层，而语言运行时堆则通过大块的分配来执行自己的内存管理。不使用操作系统堆，而使用虚拟内存函数更利于堆的分配和块的使用。 典型的堆实现由前、后端分配程序组成。前端分配程序维持固定大小块的空闲列表。对于一次分配调用，堆尝试从前端列表找到一个自由块。如果失败，堆被迫从后端（保留和提交虚拟内存）分配一个大块来满足请求。通用的实现有每块分配的开销，这将耗费执行周期，也减少了可使用的存储空间。 Knowledge Base 文章 Q10758，“用 calloc() 和 malloc() 管理内存” （搜索文章编号）, 包含了有关这些主题的更多背景知识。另外，有关堆实现和设计的详细讨论也可在下列著作中找到：“Dynamic Storage Allocation: A Survey and Critical Review”，作者 Paul R. Wilson、Mark S. Johnstone、Michael Neely 和 David Boles；“International Workshop on Memory Management”, 作者 Kinross, Scotland, UK, 1995 年 9 月(http://www.cs.utexas.edu/users/oops/papers.html)（英文）。
	作者：121.30.67.* 2006-11-26 23:15 回复此发言

7	堆和栈的区别 (转贴)
	Windows NT 的实现（Windows NT 版本 4.0 和更新版本） 使用了 127 个大小从 8 到 1,024 字节的 8 字节对齐块空闲列表和一个“大块”列表。“大块”列表（空闲列表[0]） 保存大于 1,024 字节的块。空闲列表容纳了用双向链表链接在一起的对象。默认情况下，“进程堆”执行收集操作。（收集是将相邻空闲块合并成一个大块的操作。）收集耗费了额外的周期，但减少了堆块的内部碎片。 单一全局锁保护堆，防止多线程式的使用。（请参见“Server Performance and Scalability Killers”中的第一个注意事项, George Reilly 所著，在 “MSDN Online Web Workshop”上（站点：http://msdn.microsoft.com/workshop/server/iis/tencom.asp（英文）。）单一全局锁本质上是用来保护堆数据结构，防止跨多线程的随机存取。若堆操作太频繁，单一全局锁会对性能有不利的影响。 什么是常见的堆性能问题？ 以下是您使用堆时会遇到的最常见问题：  分配操作造成的速度减慢。光分配就耗费很长时间。最可能导致运行速度减慢原因是空闲列表没有块，所以运行时分配程序代码会耗费周期寻找较大的空闲块，或从后端分配程序分配新块。 释放操作造成的速度减慢。释放操作耗费较多周期，主要是启用了收集操作。收集期间，每个释放操作“查找”它的相邻块，取出它们并构造成较大块，然后再把此较大块插入空闲列表。在查找期间，内存可能会随机碰到，从而导致高速缓存不能命中，性能降低。 堆竞争造成的速度减慢。当两个或多个线程同时访问数据，而且一个线程继续进行之前必须等待另一个线程完成时就发生竞争。竞争总是导致麻烦；这也是目前多处理器系统遇到的最大问题。当大量使用内存块的应用程序或 DLL 以多线程方式运行（或运行于多处理器系统上）时将导致速度减慢。单一锁定的使用—常用的解决方案—意味着使用堆的所有操作是序列化的。当等待锁定时序列化会引起线程切换上下文。可以想象交叉路口闪烁的红灯处走走停停导致的速度减慢。  竞争通常会导致线程和进程的上下文切换。上下文切换的开销是很大的，但开销更大的是数据从处理器高速缓存中丢失，以及后来线程复活时的数据重建。 堆破坏造成的速度减慢。造成堆破坏的原因是应用程序对堆块的不正确使用。通常情形包括释放已释放的堆块或使用已释放的堆块，以及块的越界重写等明显问题。（破坏不在本文讨论范围之内。有关内存重写和泄漏等其他细节，请参见 Microsoft Visual C++(R) 调试文档 。） 频繁的分配和重分配造成的速度减慢。这是使用脚本语言时非常普遍的现象。如字符串被反复分配，随重分配增长和释放。不要这样做，如果可能，尽量分配大字符串和使用缓冲区。另一种方法就是尽量少用连接操作。 竞争是在分配和释放操作中导致速度减慢的问题。理想情况下，希望使用没有竞争和快速分配/释放的堆。可惜，现在还没有这样的通用堆，也许将来会有。 在所有的服务器系统中（如 IIS、MSProxy、DatabaseStacks、网络服务器、 Exchange 和其他）, 堆锁定实在是个大瓶颈。处理器数越多，竞争就越会恶化。 尽量减少堆的使用 现在您明白使用堆时存在的问题了，难道您不想拥有能解决这些问题的超级魔棒吗？我可希望有。但没有魔法能使堆运行加快—因此不要期望在产品出货之前的最后一星期能够大为改观。如果提前规划堆策略，情况将会大大好转。调整使用堆的方法，减少对堆的操作是提高性能的良方。 如何减少使用堆操作？通过利用数据结构内的位置可减少堆操作的次数。请考虑下列实例： struct ObjectA {    // objectA 的数据  } struct ObjectB {    // objectB 的数据  } // 同时使用 objectA 和 objectB // // 使用指针  // struct ObjectB {    struct ObjectA * pObjA;    // objectB 的数据  } // // 使用嵌入
	作者：121.30.67.* 2006-11-26 23:15 回复此发言

8	堆和栈的区别 (转贴)
	// struct ObjectB {    struct ObjectA pObjA;    // objectB 的数据  } // // 集合 – 在另一对象内使用 objectA 和 objectB // struct ObjectX {    struct ObjectA  objA;    struct ObjectB  objB; } 避免使用指针关联两个数据结构。如果使用指针关联两个数据结构，前面实例中的对象 A 和 B 将被分别分配和释放。这会增加额外开销—我们要避免这种做法。 把带指针的子对象嵌入父对象。当对象中有指针时，则意味着对象中有动态元素（百分之八十）和没有引用的新位置。嵌入增加了位置从而减少了进一步分配/释放的需求。这将提高应用程序的性能。 合并小对象形成大对象（聚合）。聚合减少分配和释放的块的数量。如果有几个开发者，各自开发设计的不同部分，则最终会有许多小对象需要合并。集成的挑战就是要找到正确的聚合边界。 内联缓冲区能够满足百分之八十的需要（aka 80-20 规则）。个别情况下，需要内存缓冲区来保存字符串/二进制数据，但事先不知道总字节数。估计并内联一个大小能满足百分之八十需要的缓冲区。对剩余的百分之二十，可以分配一个新的缓冲区和指向这个缓冲区的指针。这样，就减少分配和释放调用并增加数据的位置空间，从根本上提高代码的性能。 在块中分配对象（块化）。块化是以组的方式一次分配多个对象的方法。如果对列表的项连续跟踪，例如对一个 {名称，值} 对的列表，有两种选择：选择一是为每一个“名称-值”对分配一个节点；选择二是分配一个能容纳（如五个）“名称-值”对的结构。例如，一般情况下，如果存储四对，就可减少节点的数量，如果需要额外的空间数量，则使用附加的链表指针。  块化是友好的处理器高速缓存，特别是对于 L1-高速缓存，因为它提供了增加的位置 —不用说对于块分配，很多数据块会在同一个虚拟页中。 正确使用 _amblksiz。C 运行时 (CRT) 有它的自定义前端分配程序，该分配程序从后端（Win32 堆）分配大小为 _amblksiz 的块。将 _amblksiz 设置为较高的值能潜在地减少对后端的调用次数。这只对广泛使用 CRT 的程序适用。 使用上述技术将获得的好处会因对象类型、大小及工作量而有所不同。但总能在性能和可升缩性方面有所收获。另一方面，代码会有点特殊，但如果经过深思熟虑，代码还是很容易管理的。 其他提高性能的技术 下面是一些提高速度的技术：  使用 Windows NT5 堆  由于几个同事的努力和辛勤工作，1998 年初 Microsoft Windows(R) 2000 中有了几个重大改进： 改进了堆代码内的锁定。堆代码对每堆一个锁。全局锁保护堆数据结构，防止多线程式的使用。但不幸的是，在高通信量的情况下，堆仍受困于全局锁，导致高竞争和低性能。Windows 2000 中，锁内代码的临界区将竞争的可能性减到最小,从而提高了可伸缩性。 使用 “Lookaside”列表。堆数据结构对块的所有空闲项使用了大小在 8 到 1,024 字节（以 8-字节递增）的快速高速缓存。快速高速缓存最初保护在全局锁内。现在，使用 lookaside 列表来访问这些快速高速缓存空闲列表。这些列表不要求锁定，而是使用 64 位的互锁操作，因此提高了性能。 内部数据结构算法也得到改进。 这些改进避免了对分配高速缓存的需求，但不排除其他的优化。使用 Windows NT5 堆评估您的代码；它对小于 1,024 字节 (1 KB) 的块（来自前端分配程序的块）是最佳的。GlobalAlloc() 和 LocalAlloc() 建立在同一堆上，是存取每个进程堆的通用机制。如果希望获得高的局部性能，则使用 Heap(R) API 来存取每个进程堆，或为分配操作创建自己的堆。如果需要对大块操作，也可以直接使用 VirtualAlloc() / VirtualFree() 操作。 上述改进已在 Windows 2000 beta 2 和 Windows NT 4.0 SP4 中使用。改进后，堆锁的竞争率显著降低。这使所有 Win32 堆的直接用户受益。CRT 堆建立于 Win32 堆的顶部，但它使用自己的小块堆，因而不能从 Windows NT 改进中受益。（Visual C++ 版本 6.0 也有改进的堆分配程序。）
	作者：121.30.67.* 2006-11-26 23:15 回复此发言

9

堆和栈的区别 (转贴)

使用分配高速缓存  分配高速缓存允许高速缓存分配的块，以便将来重用。这能够减少对进程堆（或全局堆）的分配/释放调用的次数，也允许最大限度的重用曾经分配的块。另外，分配高速缓存允许收集统计信息,以便较好地理解对象在较高层次上的使用。 典型地，自定义堆分配程序在进程堆的顶部实现。自定义堆分配程序与系统堆的行为很相似。主要的差别是它在进程堆的顶部为分配的对象提供高速缓存。高速缓存设计成一套固定大小（如 32 字节、64 字节、128 字节等）。这一个很好的策略，但这种自定义堆分配程序丢失与分配和释放的对象相关的“语义信息”。  与自定义堆分配程序相反，“分配高速缓存”作为每类分配高速缓存来实现。除能够提供自定义堆分配程序的所有好处之外，它们还能够保留大量语义信息。每个分配高速缓存处理程序与一个目标二进制对象关联。它能够使用一套参数进行初始化，这些参数表示并发级别、对象大小和保持在空闲列表中的元素的数量等。分配高速缓存处理程序对象维持自己的私有空闲实体池（不超过指定的阀值）并使用私有保护锁。合在一起，分配高速缓存和私有锁减少了与主系统堆的通信量，因而提供了增加的并发、最大限度的重用和较高的可伸缩性。 需要使用清理程序来定期检查所有分配高速缓存处理程序的活动情况并回收未用的资源。如果发现没有活动，将释放分配对象的池，从而提高性能。 可以审核每个分配/释放活动。第一级信息包括对象、分配和释放调用的总数。通过查看它们的统计信息可以得出各个对象之间的语义关系。利用以上介绍的许多技术之一，这种关系可以用来减少内存分配。 分配高速缓存也起到了调试助手的作用，帮助您跟踪没有完全清除的对象数量。通过查看动态堆栈返回踪迹和除没有清除的对象之外的签名，甚至能够找到确切的失败的调用者。 MP 堆  MP 堆是对多处理器友好的分布式分配的程序包，在 Win32 SDK（Windows NT 4.0 和更新版本）中可以得到。最初由 JVert 实现，此处堆抽象建立在 Win32 堆程序包的顶部。MP 堆创建多个 Win32 堆，并试图将分配调用分布到不同堆，以减少在所有单一锁上的竞争。 本程序包是好的步骤 —一种改进的 MP-友好的自定义堆分配程序。但是，它不提供语义信息和缺乏统计功能。通常将 MP 堆作为 SDK 库来使用。如果使用这个 SDK 创建可重用组件，您将大大受益。但是，如果在每个 DLL 中建立这个 SDK 库，将增加工作设置。 重新思考算法和数据结构  要在多处理器机器上伸缩，则算法、实现、数据结构和硬件必须动态伸缩。请看最经常分配和释放的数据结构。试问，“我能用不同的数据结构完成此工作吗？”例如，如果在应用程序初始化时加载了只读项的列表，这个列表不必是线性链接的列表。如果是动态分配的数组就非常好。动态分配的数组将减少内存中的堆块和碎片，从而增强性能。 减少需要的小对象的数量减少堆分配程序的负载。例如，我们在服务器的关键处理路径上使用五个不同的对象，每个对象单独分配和释放。一起高速缓存这些对象，把堆调用从五个减少到一个，显著减少了堆的负载，特别当每秒钟处理 1,000 个以上的请求时。 如果大量使用“Automation”结构，请考虑从主线代码中删除“Automation BSTR”，或至少避免重复的 BSTR 操作。（BSTR 连接导致过多的重分配和分配/释放操作。） 摘要 对所有平台往往都存在堆实现，因此有巨大的开销。每个单独代码都有特定的要求，但设计能采用本文讨论的基本理论来减少堆之间的相互作用。  评价您的代码中堆的使用。 改进您的代码，以使用较少的堆调用：分析关键路径和固定数据结构。 在实现自定义的包装程序之前使用量化堆调用成本的方法。 如果对性能不满意，请要求 OS 组改进堆。更多这类请求意味着对改进堆的更多关注。 要求 C 运行时组针对 OS 所提供的堆制作小巧的分配包装程序。随着 OS 堆的改进，C 运行时堆调用的成本将减小。 操作系统（Windows NT 家族）正在不断改进堆。请随时关注和利用这些改进。 Murali Krishnan 是 Internet Information Server (IIS) 组的首席软件设计工程师。从 1.0 版本开始他就设计 IIS，并成功发行了 1.0 版本到 4.0 版本。Murali 组织并领导 IIS 性能组三年 (1995-1998), 从一开始就影响 IIS 性能。他拥有威斯康星州 Madison 大学的 M.S.和印度 Anna 大学的 B.S.。工作之外，他喜欢阅读、打排球和家庭烹饪。

原帖来自于：http://tieba.baidu.com/f?kz=150791801

 IO - 同步，异步，阻塞，非阻塞
同步（synchronous） IO和异步（asynchronous） IO，阻塞（blocking） IO和非阻塞（non-blocking）IO ，我相信这几个词困扰过很多人，更痛苦的是，如果你查阅过文献资料，你会发现不同的资料中的解释是不一样的，例如在wiki中，异步和非阻塞被当成了一个概念 。
出现这种情况的原因，我认为很大程度上是因为IO这个概念本身就很宽泛，它其实包含了好几个层面。比如说，你可以把它看做是一个物理上的设备，也可以看做是 OS抽象出来的一个软件，还可以看做是平时写程序用的read(),write()函数，不同的层面对于这几个词的理解也是不一样的。

先看一个较低的层次。如果从CPU的角度看，其实大部分的IO都是异步的：因为CPU启动这个IO操作后，就去干其它的事情了，一直到产生一个中断，告诉它IO完成了。
“Most physical I/O is asynchronous—the CPU starts the transfer and goes off to do something else until the interrupt arrives. User programs are much easier to write if the I/O operations are blocking—after a read system call the program is automatically suspended until the data are available in the buffer. It is up to the operating system to make operations that are actually interrupt-driven look blocking to the user programs.” （引自 Modern Operating Systems, 2ed）

不过，本文并不想探究那么底层的东东。作为程序员，更多的还是从应用层面来考虑。所以，以下重点介绍的是应用程序中能够采用的四种IO机制。
（说明，下文中图片引用自 http://www.ibm.com/developerworks/cn/linux/l-async/ ）

首先，从最常用到的，也是最容易理解的同步阻塞IO 说起。

在这个模型中，应用程序（application）为了执行这个read操作，会调用相应的一个system call，将系统控制权交给kernel，然后就进行等待（这其实就是被阻塞了）。kernel开始执行这个system call，执行完毕后会向应用程序返回响应，应用程序得到响应后，就不再阻塞，并进行后面的工作。
 

 
例如，“在调用 read 系统调用时，应用程序会阻塞并对内核进行上下文切换。然后会触发读操作，当响应返回时（从我们正在从中读取的设备中返回），数据就被移动到用户空间的缓冲区中。然后应用程序就会解除阻塞（read 调用返回）。”

 举一个浅显的例子，就好比你去一个银行柜台存钱。首先，你会将存钱的单子填好，然后交给柜员。这里，你就好比是application，单子就是调用的 system call，柜员就是kernel。提交好单子后，你就坐在柜台前等，相当于开始进行等待。柜员办好以后会给你一个回执，表示办好了，这就是 response。然后你就可以拿着回执干其它的事了。注意，这个时候，如果你办完之后马上去查账，存的钱已经打到你的账户上了。后面你会发现，这点很重要。

接下来谈同步非阻塞IO 。
先看这个图，

 

在linux下，应用程序可以通过设置文件描述符的属性O_NONBLOCK，I/O操作可以立即返回，但是并不保证I/O操作成功。
也就是说，当应用程序设置了O_NONBLOCK之后，执行write操作，调用相应的system call，这个system call会从内核中立即返回。但是在这个返回的时间点，数据可能还没有被真正的写入到指定的地方。也就是说，kernel只是很快的返回了这个 system call（这样，应用程序不会被这个IO操作blocking），但是这个system call具体要执行的事情（写数据）可能并没有完成。而对于应用程序，虽然这个IO操作很快就返回了，但是它并不知道这个IO操作是否真的成功了，如果想知道，需要应用程序主动地去问kernel。

这次不是去银行存钱，而是去银行汇款。同样的，你也需要填写汇款单然后交给柜员，柜员进行一些简单的手续处理就能够给你回执。但是，你拿到回执并不意味着钱已经打到了对方的账上。事实上，一般汇款的周期大概是24个小时，如果你要以存钱的模式来汇款的话，意味着你需要在银行等24个小时，这显然是不现实的。所以，同步非阻塞IO在实际生活中也是有它的意义的。

再来谈谈异步阻塞IO 。
在linux中，常常通过select/poll来实现这种机制。

 
以图为例，
和之前一样，应用程序要执行read操作，因此调用一个system call，这个system call被传递给了kernel。但在应用程序这边，它调用system call之后，并不等待kernel返回response，这一点是和前面两种机制不一样的地方。这也是为什么它被称为异步的原因。但是为什么称其为阻塞呢？这是因为虽然应用程序是一个异步的方式，但是select()函数会将应用程序阻塞住，一直等到这个system call有结果返回了，再通知应用程序。也就是说，“在这种模型中，配置的是非阻塞 I/O，然后使用阻塞 select 系统调用来确定一个 I/O 描述符何时有操作。”
所以，从IO操作的实际效果来看，异步阻塞IO和第一种同步阻塞IO是一样的，应用程序都是一直等到IO操作成功之后（数据已经被写入或者读取），才开始进行下面的工作。异步阻塞IO的好处在于一个select函数可以为多个描述符提供通知，提高了并发性。

关于提高并发性这点，我们还以银行为例说明。比如说一个银行柜台，现在有10个人想存钱。按照现在银行的做法，一个个排队。第一个人先填存款单，然后提交，然后柜员处理，然后给回执，成功后再轮到下一个人。大家应该都在银行排过对，这样的流程是很痛苦的。如果按照异步阻塞的机制，10个人都填好存款单，然后都提交给柜台，提交完之后所有的10个人就在银行大厅等待。这时候会专门有个人，他会了解存款单处理的情况，一旦有存款单处理完毕，他会将回执交给相应的正在大厅等待的人，这个拿到回执的人就可以去干其他的事情了。而前面提到的这个专人，就对应于select函数。

最后，谈谈异步非阻塞IO 。
这个概念相对前面两个反而更容易理解一些。

 
如图所示，应用程序提交read请求的system call，然后，kernel开始处理相应的IO操作，而同时，应用程序并不等kernel返回响应，就会开始执行其他的处理操作（应用程序没有被IO操作所阻塞）。当kernel执行完毕，返回read的响应，就会产生一个信号或执行一个基于线程的回调函数来完成这次 I/O 处理过程。

比如银行存钱。现在某银行新开通了一项存钱业务。用户之需要将存款单交给柜台，然后无需等待就可以离开了。柜台办好以后会给用户发送一条短信，告知交易成功。这样用户不需要在柜台前进行长时间的等待，同时，也能够得到确切的消息知道交易完成。

从前面的介绍中可以看出，所谓的同步和异步，在这里指的是application和kernel之间的交互方式。如果application不需要等待 kernel的回应，那么它就是异步的。如果application提交完IO请求后，需要等待“回执”，那么它就是同步的。
而阻塞和非阻塞，指的是application是否等待IO操作的完成。如果application必须等到IO操作实际完成以后再执行下面的操作，那么它是阻塞的。反之，如果不等待IO操作的完成就开始执行其它操作，那么它是非阻塞的。

 

本文来自CSDN博客，转载请标明出处：http://blog.csdn.net/historyasamirror/archive/2009/06/15/4270633.aspx

可以使用 STL的string。  
#include   <string>  
using   namespace   std;

但肯定不如CString功能强大，其实在非MFC程序中使用CString，也是可以的，具体方法如下：

  为了使用CString类，首先源文件必须是以cpp结尾的，这是因为vc默认对不同的扩展名采用不同的编译方法和错误检查，mfc的支持文件Afx.h只有由cpp为扩展名的文件包含才能够正常编译。对于exe和库要采用不同的方式。下面分别讨论：

  一、在非dll或者lib的工程里，使用CString非常容易，只要两步：

  1、对于没有包含<Windows.h>的stdafx.h中，只要包含了afx.h即可，而对于已经包含了<windows.h>的stdafx.h, 一定需要保证afx.h在windows.h之前被包含。另外由于默认的控制台程序采用的单线程运行库，我们要把它改成多线程库，这些工作只要在stdafx.h中进行修改就可以了（详细信息可以参考候捷的<<mfc 深入浅出>>），我使用的一个stdafx.h的例子如下（这是一个从向导生成的win32位GUI的程序的stdafx.h修改的）：

// stdafx。h
#if !defined(AFX_STDAFX_H__A9DB83DB_A9FD_11D0_BFD1_444553540000__INCLUDED_)
#define AFX_STDAFX_H__A9DB83DB_A9FD_11D0_BFD1_444553540000__INCLUDED_

#if _MSC_VER > 1000
#pragma once
#endif // _MSC_VER > 1000

#define WIN32_LEAN_AND_MEAN // Exclude rarely-used stuff from Windows headers

#include <afx.h> // 加在这里

// Windows Header Files:
#include <windows.h>

// C RunTime Header Files
#include <stdlib.h>
#include <malloc.h>
#include <memory.h>
#include <tchar.h>
#ifdef _DEBUG
  #pragma comment(lib, "libcmtd.lib")
#else
  #pragma comment(lib, "libcmt.lib")
#endif
// Local Header Files

#endif // !defined(AFX_STDAFX_H__A9DB83DB_A9FD_11D0_BFD1_444553540000__INCLUDED_)
这样就可以在程序中正常使用CString类了。

  二、在dll或者lib的工程中，由于afx.h默认带了一个DllMain，致使要使用CString类需要几个步骤。

  1、首先和控制台程序一样，如果编译环境设置了采用单线程库, 要改成多线程库，这个可以从工程属性里进行修改，详细信息可以参考候捷的<<mfc 深入浅出>>. 下面给出的是我常用的方式，可以直接把它复制到工程里使用：

  #ifdef _DEBUG
  #pragma comment(lib, "libcmtd.lib")
  #else
  #pragma comment(lib, "libcmt.lib")
  #endif  
2、工程目录下创建一个DLLMODUL.CPP文件，并且把它加入到当前工程中。

  3、打开DLLMODUL.CPP文件，编辑这个文件为这样：
  #include "stdafx.h"
  #ifdef _DEBUG
  #undef THIS_FILE
  static char THIS_FILE[] = __FILE__;
  #endif

  #define new DEBUG_NEW

  /////////////////////////////////////////////////////////////////////////////
  // global data

  // The following symbol used to force inclusion of this module for _USRDLL
  #ifdef _X86_
  extern "C" { int _afxForceUSRDLL; }
  #else
  extern "C" { int __afxForceUSRDLL; }
  #endif
4、打开stdafx.h，把afx.h包含在windows.h前面。现在可以正常的使用CString了。

当在vs2005中添加类或者变量是会出现 “当前页面脚本发生错误”的提示，如下图所示：

该解决方案如下：
（1）下载vs2005 补丁,下载链接为：Microsoft Visual C++ 2005 SP1 Redistributable Package (x86) ，安装之。。。
（2）下载需要修改注册表的一个工程,下载地址为：http://download.csdn.net/source/1145363，运行之。。。
至此，问题就已解决！

当然引起该问题的主要原因是由于IE8的使用，如果你觉得以上方法比较复杂，可直接卸载掉IE8.。。。

在此，我要感谢http://jiangsheng.spaces.live.com/blog/cns!1BE894DEAF296E0A!878.entry 文章的博主。。。。

同步：函数没有执行完不返回，线程被挂起

阻塞：没有收完数据函数不返回，线程也被挂起

异步：函数立即返回，通过事件或是信号通知调用者

非阻塞：函数立即返回，通过select通知调用者

这样看来异步和非阻塞有什么区别呢？

异步=非阻塞？

同步是在操作系统层面上，阻塞是在套接字上？

Reactor是同步 Proactor是异步？

回答：

同步、异步、阻塞和非阻塞的概念

　　在进行网络编程时，我们常常见到同步、异步、阻塞和非阻塞四种调用方式。这些方式彼此概念并不好理解。下面是我对这些术语的理解。

同步
　　所谓同步，就是在发出一个功能调用时，在没有得到结果之前，该调用就不返回。按照这个定义，其实绝大多数函数都是同步调用（例如sin, isdigit等）。但是一般而言，我们在说同步、异步的时候，特指那些需要其他部件协作或者需要一定时间完成的任务。最常见的例子就是 SendMessage。该函数发送一个消息给某个窗口，在对方处理完消息之前，这个函数不返回。当对方处理完毕以后，该函数才把消息处理函数所返回的 LRESULT值返回给调用者。

异步
　　异步的概念和同步相对。当一个异步过程调用发出后，调用者不能立刻得到结果。实际处理这个调用的部件在完成后，通过状态、通知和回调来通知调用者。以 CAsycSocket类为例（注意，CSocket从CAsyncSocket派生，但是起功能已经由异步转化为同步），当一个客户端通过调用 Connect函数发出一个连接请求后，调用者线程立刻可以朝下运行。当连接真正建立起来以后，socket底层会发送一个消息通知该对象。这里提到执行 部件和调用者通过三种途径返回结果：状态、通知和回调。可以使用哪一种依赖于执行部件的实现，除非执行部件提供多种选择，否则不受调用者控制。如果执行部 件用状态来通知，那么调用者就需要每隔一定时间检查一次，效率就很低（有些初学多线程编程的人，总喜欢用一个循环去检查某个变量的值，这其实是一种很严重 的错误）。如果是使用通知的方式，效率则很高，因为执行部件几乎不需要做额外的操作。至于回调函数，其实和通知没太多区别。

阻塞
　　阻塞调用是指调用结果返回之前，当前线程会被挂起。函数只有在得到结果之后才会返回。有人也许会把阻塞调用和同步调用等同起来，实际上他是不同的。对于同 步调用来说，很多时候当前线程还是激活的，只是从逻辑上当前函数没有返回而已。例如，我们在CSocket中调用Receive函数，如果缓冲区中没有数 据，这个函数就会一直等待，直到有数据才返回。而此时，当前线程还会继续处理各种各样的消息。如果主窗口和调用函数在同一个线程中，除非你在特殊的界面操 作函数中调用，其实主界面还是应该可以刷新。socket接收数据的另外一个函数recv则是一个阻塞调用的例子。当socket工作在阻塞模式的时候， 如果没有数据的情况下调用该函数，则当前线程就会被挂起，直到有数据为止。

非阻塞
　　非阻塞和阻塞的概念相对应，指在不能立刻得到结果之前，该函数不会阻塞当前线程，而会立刻返回。

　　对象的阻塞模式和阻塞函数调用
　　对象是否处于阻塞模式和函数是不是阻塞调用有很强的相关性，但是并不是一一对应的。阻塞对象上可以有非阻塞的调用方式，我们可以通过一定的API去轮询状 态，在适当的时候调用阻塞函数，就可以避免阻塞。而对于非阻塞对象，调用特殊的函数也可以进入阻塞调用。函数select就是这样的一个例子。

阻塞通信

--------------------------------------------------------------------------------

　　通过重叠通信和计算在许多系统能提高性能。由一个智能通信控制器自动地执行通信的系统是真实的。轻－重线索是取得这种重叠的一种机制。导致好性能的 一个可选的机制是使用非阻塞通信。一个阻塞发送开始调用初始化这个发送操作，但不完成它。在这个消息被从这个发送缓存拷出以前，这个发送开始调用将返回。 需要一个独立的“发送完成”调用完成这个通信，例如，检验从发送缓存拷出的数据。用适当的硬件，在发送被初始化后和它完成以前，来自发送者存储的数据转换 可以和在发送者完成的计算同时进行。类似地，一个非阻塞“接收开始调用”初始化这个接收操作, 但不完成它。在一个消息被存入这个接收缓存以前，这个调用将返回。须要一个独立的“接收完成”调用完成这个接收操作，并检验被接收到这个接收缓存的数据。 用适当的硬件，在接收操作初始化后和它完成以前，到接收者存储的数据转换可以和计算同时进行。非阻塞接收的使用虽着信息较早地在接收缓存位置被提供，也可 以避免系统缓存和存储器到存储器拷贝。

　　非阻塞发送开始调用能使用与阻塞发送一样的四种模式: 标准, 缓存, 同步和准备好模式。这些具有同样的意义。无论一个匹配接收是否已登入，能开始除“准备好”以外的所有模式的发送；只要一个匹配接收已登入，就能开始一个非 阻塞“准备好”发送。在所有情况下，发送开始调用是局部的：无论其它进程的状态如何，它立刻返回。如果这个调用使得一些系统资源用完，那么它将失败并返回 一个错误代码。高质量的MPI实现应保证这种情况只在“病态”时发生。即，一个MPI实现将能支持大数量挂起非阻塞操作。　　

　　当数据已被从发送缓存拷出时，这个发送完成调用返回。它可以带有附加的意义，这取决于发送模式。　

　　如果发送模式是“同步的”，那么只有一个匹配接收已开始这个发送才能完成。即，一个接收已被登入，并已和这个发送匹配。这时，这个发送完成调用是非 局部的。注意，在接收完成调用发生以前，如果一个同步、非阻塞发送和一个非阻塞接收匹配, 它可以完成。(发送者一“知道”转换将结束，它就能完成，但在接收者“知道”转换将结束以前)。　　

　　如果发送模式是“缓存”，并没有挂起接收，那么消息必须被缓存。这时，发送完成调用是局部的，而且无论一个匹配接收的状态如何，它必须成功。　　

　　如果发送模式是标准的，同时这个消息被缓存，那么在一个匹配接收发生以前，发送结束调用可以返回。另一方面，发送完成直到一个匹配接收发生才可以完成，并且这个消息已被拷到接收缓存。　　

　　非阻塞发送能被用阻塞接收匹配，反过来也可以。

　　给用户的建议. 一个发送操作的完成, 对于标准模式可以被延迟, 对于同部模式必须延迟, 直到一个匹配接收登入。这两种情况下非阻塞发送的使用允许发送者提前于接收者进行，以便在两进程的速度方面，计算更容忍波动。　　

　　缓存和准备好模式中的非阻塞发送有一个更有限的影响。一可能一个非阻塞发送将返回，而一个阻塞发送将在数据被从发送者存储拷出后返回。只要在数据拷贝能和计算同时的情况下，非阻塞发送的使用有优点。

　　消息发送模式隐含着由发送者初始化通信。当发送者初始化通信(数据被直接移到接收缓存, 并不要求排队一个挂起发送请求) 时，如果一个接收已登入，这个通信一般将有较低的额外负担。但是，只在匹配发送已发生后，一个接收操作能完成。当非阻塞接收等待发送时，没有阻塞接收，它 的使用允许得到较低的通信额外负担。（给用户的建议结束）。

原文出处：http://www.kuqin.com/networkprog/20090221/35947.html

包含 <omp.h>




















文章出处：
http://blog.csdn.net/drzhouweiming/archive/2006/08/28/1131537.aspx
http://blog.csdn.net/drzhouweiming/archive/2006/09/04/1175848.aspx

1:安装office2007;安装序列号:(下面的序列号任选一组或使用算号器Office 2007 Keygen算一组序列号)
Keygen: 点击下载此文件
VBQF2-6K94C-KCT26-R4XQF-C2QQ8
GM26K-7MYV2-338DJ-4DKMG-DTJBJ
CTKXX-M97FT-89PW2-DHKD3-74MYJ(Enterprise密钥,2009-03-25 10:29:53测试通过验证)

重新输入序列号的方法:HKEY_LOCAL_MACHINE\Software\Microsoft\Office\12.0\Registration\{90120000-0030-0000-0000-0000000FF1CE},删除子键DigitalProductID,ProductName及ProductID.重新打开Office就会提示输入序列号.

已经安装Office2007的直接进行以下步骤:

2:打开微软正版验证的网页:
http://www.microsoft.com/genuine/default.aspx?displaylang=zh-cn

3:验证office2007,安装验证控件,验证显示失败!

4:用附件内OGACheckControl.dll文件:版本号为:1.7.105.14,替换windows\system32\ 目录下同名文件。
将OGACheckControl.dll文件复制粘贴到windows\system32\ 目录下即可替换(64位系统为system64\目录下)
注意:OGACheckControl.dll文件的版本号与系统windows\system32\下同名文件版本号一致
Dll下载: 点击下载此文件

5:再次验证office2007,通过微软的正版验证!

注意:2008年10月20日微软更新OGACheckControl.dll文件,最新版本号为:1.7.105.14,在未替换OGACheckControl.dll文件不能通过正版验证前不要打开任何office2007组件,以免出现"星星"警告!

版本号为"1.7.111.0"的OGACheckControl.dll文件: 点击下载此文件

已经不幸中招有"星星"警告的,请用附件中OGA卸载工具,解压后点鼠标右键中卸载,直接点击不能卸载,卸载OGACheckControl.dll文件,重启计算机,更换office安装序列号,用附件中OGACheckControl.dll重新替换系统windows\system32\ 下同名文件,再激活office2007.
星星卸载: 点击下载此文件
或者干脆结束掉星星并替换掉星星程序.可用下面的批处理文件.
点击下载此文件

Office下载(推荐迅雷):
企业版:ftp://ribbitar.3322.org/Soft/MicrosoftOfficeEnterprise2007.iso
专业版:ftp://ribbitar.3322.org/Soft/MicrosoftOfficeProfessionalPlus2007.iso




转载于：
http://1vr.cn/article.asp?id=411

利用MFC进行编程时，我们从对话框中利用GetWindowText得到的字符串是CString类型，CString是属于MFC的类。而一些标准C/C++库函数是不能直接对CString类型进行操作的，所以我们经常遇到将CString类型转化char*等等其他数据类型的情况。这里总结备忘于此！ 首先要明确，标准C中是不存在string类型的，string是标准C++扩充字符串操作的一个类。但是我们知道标准C中有string.h这个头文件，这里要区分清楚，此string非彼string。string.h这个头文件中定义了一些我们经常用到的操作字符串的函数，如：strcpy、strcat、strcmp等等，但是这些函数的操作对象都是char*指向的字符串。 而C++的string类操作对象是string类型字符串，该类重装了一些运算符，添加了一些字符串操作成员函数，使得操作字符串更加方便。有的时候我们要将string串和char*串配合使用，所以也会涉及到这两个类型的转化问题。 1.CString和string的转化 stringstr="ksarea"; CStringcstr(str.c_str());//或者CString cstr(str.data());初始化时才行 cstr=str.c_str();或者cstr=str.data(); str=cstr.GetBuffer(0); //CString -> string cstr.format("%s", str.c_str()); //string->CString cstr.format("%s", str.data()); //string->CString str = LPCSTR(cstr); //CString->string /*c_str()和data()区别是：前者返回带'\0'的字符串，后者则返回不带'\0'的字符串*/ 2.CString和int的转换 inti=123; CStringstr; str.format("%d",i);//int->CString 其他的基本类型转化类似 i=atoi(str);//CString->int 还有(atof,atol) 3.char*和CString的转换 CStringcstr="ksarea"; char* ptemp=cstr.getbuffer(0); char* str; strcpy(str,ptemp);//CString->char* cstr.releasebuffer(-1); char*str="lovesha"; CStringcstr=str;//char*->CString string类型不能直接赋值给CString 至于int与float、string与char*之间的转化可以使用强制转化，或者标准库函数进行。对于CString与其他类型的转化方法很多，但其实都殊途同归，朝着一个方向即将类型首先转化为char*类型，因为char*是不同类型之间的桥梁。得到char*类型，转化为其他类型就非常容易了。

主要有以下文章：
http://blog.csdn.net/bitxinhai/archive/2008/04/14/2292014.aspx
http://www.vczx.com/article/show.php?id=845
http://www.vczx.com/article/show.php?id=846

要看访问受限的QQ空间很简单啊,用手工.

在地址栏里输入
http://qqxoo.com/main.html?qqid=80224567   这样就可能看对方的空间
http://qqshow-user.tencent.com/80224567/11/00 看MM的QQ绣
http://shuqian.qq.com/80224567/  QQ        书签
http://h.qbar.qq.com/80224567 这个是看她的Q吧
http://shop.paipai.com/80224567 看MM的拍拍
http://wenwen.soso.com/z/ShowUser.e?sp=80224567 这个是什么呢，问问
http://images.5d6d.net/dz61/smilies/default/mad.gif[/img]Q]http://wpa.qq.com/pa?p=1Q号:4
  这个是查看好友在不在就看这个了 ，MM是不是在线


用手工的是很简单.不信就试试,反正也就一分钟

PS:红色部分改成你想的QQ就可以了
原帖来自：http://qzone.qq.com/blog/80224567-1239195902