jianlinzhang

        最近一段時間安裝了boost，但是由于以前無這方面的經(jīng)驗，導致了在安裝完boost后，運用到vs2005或者vs2008時，visual assist 會不停的解析boost，導致我的虛擬內存會不斷增加，最后死機或者vs崩潰，開始還以為自己在編譯boost庫時出現(xiàn)了問題，因此繼續(xù)上網(wǎng)尋找關于這方面的問題，時至今日才發(fā)現(xiàn)網(wǎng)絡也并非萬能，或者可能我的問題大家都沒遇到過，總之，該問題我一直沒有解決，只好忍痛割愛，將va的設置中不添加boost一項。盡管關于boost的程序編譯，運行都沒有問題，但在缺少了va的強力支撐下，編寫boost程序的相當?shù)姆爆崱！！?br>        今天，我終于發(fā)現(xiàn)了其中的緣由，原來是因為我的boost目錄中包含的有中文字符串。。。哎，沒想到啊。在重新設置了boost的目錄后，一切就ok了。。。
        希望這對于有些同行來說有點用處。。。O(∩_∩)O哈哈~

1	堆和棧的區(qū)別 (轉貼)
	堆和棧的區(qū)別 (轉貼)  非本人作也!因非常經(jīng)典,所以收歸旗下,與眾人閱之!原作者不祥! 堆和棧的區(qū)別 一、預備知識—程序的內存分配 一個由c/C++編譯的程序占用的內存分為以下幾個部分 1、棧區(qū)（stack）— 由編譯器自動分配釋放 ，存放函數(shù)的參數(shù)值，局部變量的值等。其操作方式類似于數(shù)據(jù)結構中的棧。 2、堆區(qū)（heap） — 一般由程序員分配釋放， 若程序員不釋放，程序結束時可能由OS回收 。注意它與數(shù)據(jù)結構中的堆是兩回事，分配方式倒是類似于鏈表，呵呵。 3、全局區(qū)（靜態(tài)區(qū)）（static）—，全局變量和靜態(tài)變量的存儲是放在一塊的，初始化的全局變量和靜態(tài)變量在一塊區(qū)域， 未初始化的全局變量和未初始化的靜態(tài)變量在相鄰的另一塊區(qū)域。 - 程序結束后有系統(tǒng)釋放  4、文字常量區(qū)—常量字符串就是放在這里的。 程序結束后由系統(tǒng)釋放 5、程序代碼區(qū)—存放函數(shù)體的二進制代碼。 二、例子程序  這是一個前輩寫的，非常詳細  //main.cpp  int a = 0; 全局初始化區(qū)  char *p1; 全局未初始化區(qū)  main()  {  int b; 棧  char s[] = "abc"; 棧  char *p2; 棧  char *p3 = "123456"; 123456\0在常量區(qū)，p3在棧上。  static int c =0； 全局（靜態(tài)）初始化區(qū)  p1 = (char *)malloc(10);  p2 = (char *)malloc(20);  分配得來得10和20字節(jié)的區(qū)域就在堆區(qū)。  strcpy(p1, "123456"); 123456\0放在常量區(qū)，編譯器可能會將它與p3所指向的"123456"優(yōu)化成一個地方。  }    二、堆和棧的理論知識  2.1申請方式  stack:  由系統(tǒng)自動分配。 例如，聲明在函數(shù)中一個局部變量 int b; 系統(tǒng)自動在棧中為b開辟空間  heap:  需要程序員自己申請，并指明大小，在c中malloc函數(shù)  如p1 = (char *)malloc(10);  在C++中用new運算符  如p2 = (char *)malloc(10);  但是注意p1、p2本身是在棧中的。  2.2  申請后系統(tǒng)的響應  棧：只要棧的剩余空間大于所申請空間，系統(tǒng)將為程序提供內存，否則將報異常提示棧溢出。  堆：首先應該知道操作系統(tǒng)有一個記錄空閑內存地址的鏈表，當系統(tǒng)收到程序的申請時，  會遍歷該鏈表，尋找第一個空間大于所申請空間的堆結點，然后將該結點從空閑結點鏈表中刪除，并將該結點的空間分配給程序，另外，對于大多數(shù)系統(tǒng)，會在這塊內存空間中的首地址處記錄本次分配的大小，這樣，代碼中的delete語句才能正確的釋放本內存空間。另外，由于找到的堆結點的大小不一定正好等于申請的大小，系統(tǒng)會自動的將多余的那部分重新放入空閑鏈表中。  2.3申請大小的限制  棧：在Windows下,棧是向低地址擴展的數(shù)據(jù)結構，是一塊連續(xù)的內存的區(qū)域。這句話的意思是棧頂?shù)牡刂泛蜅５淖畲笕萘渴窍到y(tǒng)預先規(guī)定好的，在WINDOWS下，棧的大小是2M（也有的說是1M，總之是一個編譯時就確定的常數(shù)），如果申請的空間超過棧的剩余空間時，將提示overflow。因此，能從棧獲得的空間較小。  堆：堆是向高地址擴展的數(shù)據(jù)結構，是不連續(xù)的內存區(qū)域。這是由于系統(tǒng)是用鏈表來存儲的空閑內存地址的，自然是不連續(xù)的，而鏈表的遍歷方向是由低地址向高地址。堆的大小受限于計算機系統(tǒng)中有效的虛擬內存。由此可見，堆獲得的空間比較靈活，也比較大。  2.4申請效率的比較：  棧由系統(tǒng)自動分配，速度較快。但程序員是無法控制的。  堆是由new分配的內存，一般速度比較慢，而且容易產生內存碎片,不過用起來最方便.  另外，在WINDOWS下，最好的方式是用VirtualAlloc分配內存，他不是在堆，也不是在棧是直接在進程的地址空間中保留一快內存，雖然用起來最不方便。但是速度快，也最靈活。  2.5堆和棧中的存儲內容  棧： 在函數(shù)調用時，第一個進棧的是主函數(shù)中后的下一條指令（函數(shù)調用語句的下一條可執(zhí)行語句）的地址，然后是函數(shù)的各個參數(shù)，在大多數(shù)的C編譯器中，參數(shù)是由右往左入棧的，然后是函數(shù)中的局部變量。注意靜態(tài)變量是不入棧的。
	作者：121.30.67.* 2006-11-26 23:15 回復此發(fā)言

2	堆和棧的區(qū)別 (轉貼)
	當本次函數(shù)調用結束后，局部變量先出棧，然后是參數(shù)，最后棧頂指針指向最開始存的地址，也就是主函數(shù)中的下一條指令，程序由該點繼續(xù)運行。  堆：一般是在堆的頭部用一個字節(jié)存放堆的大小。堆中的具體內容有程序員安排。  2.6存取效率的比較  char s1[] = "aaaaaaaaaaaaaaa";  char *s2 = "bbbbbbbbbbbbbbbbb";  aaaaaaaaaaa是在運行時刻賦值的；  而bbbbbbbbbbb是在編譯時就確定的；  但是，在以后的存取中，在棧上的數(shù)組比指針所指向的字符串(例如堆)快。  比如：  #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中，在根據(jù)edx讀取字符，顯然慢了。  2.7小結：  堆和棧的區(qū)別可以用如下的比喻來看出：  使用棧就象我們去飯館里吃飯，只管點菜（發(fā)出申請）、付錢、和吃（使用），吃飽了就走，不必理會切菜、洗菜等準備工作和洗碗、刷鍋等掃尾工作，他的好處是快捷，但是自由度小。  使用堆就象是自己動手做喜歡吃的菜肴，比較麻煩，但是比較符合自己的口味，而且自由度大。  windows進程中的內存結構 在閱讀本文之前，如果你連堆棧是什么多不知道的話，請先閱讀文章后面的基礎知識。  接觸過編程的人都知道，高級語言都能通過變量名來訪問內存中的數(shù)據(jù)。那么這些變量在內存中是如何存放的呢？程序又是如何使用這些變量的呢？下面就會對此進行深入的討論。下文中的C語言代碼如沒有特別聲明，默認都使用VC編譯的release版。  首先，來了解一下 C 語言的變量是如何在內存分部的。C 語言有全局變量(Global)、本地變量(Local)，靜態(tài)變量(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); //打印各靜態(tài)變量的內存地址  printf("0x%08x\n",&s2);  printf("0x%08x\n\n",&s3);  return 0;  }  編譯后的執(zhí)行結果是：  0x0012ff78  0x0012ff7c  0x0012ff80  0x004068d0  0x004068d4  0x004068d8  0x004068dc  0x004068e0  0x004068e4  輸出的結果就是變量的內存地址。其中v1,v2,v3是本地變量，g1,g2,g3是全局變量，s1,s2,s3是靜態(tài)變量。你可以看到這些變量在內存是連續(xù)分布的，但是本地變量和全局變量分配的內存地址差了十萬八千里，而全局變量和靜態(tài)變量分配的內存是連續(xù)的。這是因為本地變量和全局/靜態(tài)變量是分配在不同類型的內存區(qū)域中的結果。對于一個進程的內存空間而言，可以在邏輯上分成3個部份：代碼區(qū)，靜態(tài)數(shù)據(jù)區(qū)和動態(tài)數(shù)據(jù)區(qū)。動態(tài)數(shù)據(jù)區(qū)一般就是“堆棧”。“棧(stack)”和“堆(heap)”是兩種不同的動態(tài)數(shù)據(jù)區(qū)，棧是一種線性結構，堆是一種鏈式結構。進程的每個線程都有私有的“棧”，所以每個線程雖然代碼一樣，但本地變量的數(shù)據(jù)都是互不干擾。一個堆棧可以通過“基地址”和“棧頂”地址來描述。全局變量和靜態(tài)變量分配在靜態(tài)數(shù)據(jù)區(qū)，本地變量分配在動態(tài)數(shù)據(jù)區(qū)，即堆棧中。程序通過堆棧的基地址和偏移量來訪問本地變量。
	作者：121.30.67.* 2006-11-26 23:15 回復此發(fā)言

3	堆和棧的區(qū)別 (轉貼)
	├———————┤低端內存區(qū)域  │ …… │  ├———————┤  │ 動態(tài)數(shù)據(jù)區(qū) │  ├———————┤  │ …… │  ├———————┤  │ 代碼區(qū) │  ├———————┤  │ 靜態(tài)數(shù)據(jù)區(qū) │  ├———————┤  │ …… │  ├———————┤高端內存區(qū)域  堆棧是一個先進后出的數(shù)據(jù)結構，棧頂?shù)刂房偸切∮诘扔跅５幕刂贰Ｎ覀兛梢韵攘私庖幌潞瘮?shù)調用的過程，以便對堆棧在程序中的作用有更深入的了解。不同的語言有不同的函數(shù)調用規(guī)定，這些因素有參數(shù)的壓入規(guī)則和堆棧的平衡。windows API的調用規(guī)則和ANSI C的函數(shù)調用規(guī)則是不一樣的，前者由被調函數(shù)調整堆棧，后者由調用者調整堆棧。兩者通過“__stdcall”和“__cdecl”前綴區(qū)分。先看下面這段代碼：  #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;  }  編譯后的執(zhí)行結果是：  0x0012ff78  0x0012ff7c  0x0012ff80  0x0012ff68  0x0012ff6c  0x0012ff70  ├———————┤<—函數(shù)執(zhí)行時的棧頂（ESP）、低端內存區(qū)域  │ …… │  ├———————┤  │ var 1 │  ├———————┤  │ var 2 │  ├———————┤  │ var 3 │  ├———————┤  │ RET │  ├———————┤<—“__cdecl”函數(shù)返回后的棧頂（ESP）  │ parameter 1 │  ├———————┤  │ parameter 2 │  ├———————┤  │ parameter 3 │  ├———————┤<—“__stdcall”函數(shù)返回后的棧頂（ESP）  │ …… │  ├———————┤<—棧底（基地址 EBP）、高端內存區(qū)域  上圖就是函數(shù)調用過程中堆棧的樣子了。首先，三個參數(shù)以從又到左的次序壓入堆棧，先壓“param3”，再壓“param2”，最后壓入“param1”；然后壓入函數(shù)的返回地址(RET)，接著跳轉到函數(shù)地址接著執(zhí)行（這里要補充一點，介紹UNIX下的緩沖溢出原理的文章中都提到在壓入RET后，繼續(xù)壓入當前EBP，然后用當前ESP代替EBP。然而，有一篇介紹windows下函數(shù)調用的文章中說，在windows下的函數(shù)調用也有這一步驟，但根據(jù)我的實際調試，并未發(fā)現(xiàn)這一步，這還可以從param3和var1之間只有4字節(jié)的間隙這點看出來）；第三步，將棧頂(ESP)減去一個數(shù)，為本地變量分配內存空間，上例中是減去12字節(jié)(ESP=ESP-3*4，每個int變量占用4個字節(jié))；接著就初始化本地變量的內存空間。由于“__stdcall”調用由被調函數(shù)調整堆棧，所以在函數(shù)返回前要恢復堆棧，先回收本地變量占用的內存(ESP=ESP+3*4)，然后取出返回地址，填入EIP寄存器，回收先前壓入?yún)?shù)占用的內存(ESP=ESP+3*4)，繼續(xù)執(zhí)行調用者的代碼。參見下列匯編代碼：  ;--------------func 函數(shù)的匯編代碼-------------------  :00401000 83EC0C sub esp, 0000000C //創(chuàng)建本地變量的內存空間  :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 ;函數(shù)返回，恢復參數(shù)占用的內存空間
	作者：121.30.67.* 2006-11-26 23:15 回復此發(fā)言

4	堆和棧的區(qū)別 (轉貼)
	;如果是“__cdecl”的話，這里是“ret”，堆棧將由調用者恢復  ;-------------------函數(shù)結束-------------------------  ;--------------主程序調用func函數(shù)的代碼--------------  :00401080 6A03 push 00000003 //壓入?yún)?shù)param3  :00401082 6A02 push 00000002 //壓入?yún)?shù)param2  :00401084 6A01 push 00000001 //壓入?yún)?shù)param1  :00401086 E875FFFFFF call 00401000 //調用func函數(shù)  ;如果是“__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;  }  編譯后執(zhí)行一下回怎么樣？哈，“"0x00414141"指令引用的"0x00000000"內存。該內存不能為"read"。”，“非法操作”嘍！"41"就是"A"的16進制的ASCII碼了，那明顯就是strcat這句出的問題了。"lpBuff"的大小只有8字節(jié)，算進結尾的\0，那strcat最多只能寫入7個"A"，但程序實際寫入了11個"A"外加1個\0。再來看看上面那幅圖，多出來的4個字節(jié)正好覆蓋了RET的所在的內存空間，導致函數(shù)返回到一個錯誤的內存地址，執(zhí)行了錯誤的指令。如果能精心構造這個字符串，使它分成三部分，前一部份僅僅是填充的無意義數(shù)據(jù)以達到溢出的目的，接著是一個覆蓋RET的數(shù)據(jù)，緊接著是一段shellcode，那只要著個RET地址能指向這段shellcode的第一個指令，那函數(shù)返回時就能執(zhí)行shellcode了。但是軟件的不同版本和不同的運行環(huán)境都可能影響這段shellcode在內存中的位置，那么要構造這個RET是十分困難的。一般都在RET和shellcode之間填充大量的NOP指令，使得exploit有更強的通用性。  ├———————┤<—低端內存區(qū)域  │ …… │  ├———————┤<—由exploit填入數(shù)據(jù)的開始  │ │  │ buffer │<—填入無用的數(shù)據(jù)  │ │  ├———————┤  │ RET │<—指向shellcode，或NOP指令的范圍  ├———————┤  │ NOP │  │ …… │<—填入的NOP指令，是RET可指向的范圍  │ NOP │  ├———————┤  │ │  │ shellcode │  │ │  ├———————┤<—由exploit填入數(shù)據(jù)的結束  │ …… │  ├———————┤<—高端內存區(qū)域  windows下的動態(tài)數(shù)據(jù)除了可存放在棧中，還可以存放在堆中。了解C++的朋友都知道，C++可以使用new關鍵字來動態(tài)分配內存。來看下面的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); //打印靜態(tài)變量的內存地址  }  void main()  {  func();  return;  }  程序執(zhí)行結果為：  0x004107d0  0x0012ff04  0x004068c0  可以發(fā)現(xiàn)用new關鍵字分配的內存即不在棧中，也不在靜態(tài)數(shù)據(jù)區(qū)。VC編譯器是通過windows下的“堆(heap)”來實現(xiàn)new關鍵字的內存動態(tài)分配。在講“堆”之前，先來了解一下和“堆”有關的幾個API函數(shù)：  HeapAlloc 在堆中申請內存空間  HeapCreate 創(chuàng)建一個新的堆對象  HeapDestroy 銷毀一個堆對象  HeapFree 釋放申請的內存  HeapWalk 枚舉堆對象的所有內存塊  GetProcessHeap 取得進程的默認堆對象  GetProcessHeaps 取得進程所有的堆對象  LocalAlloc  GlobalAlloc  當進程初始化時，系統(tǒng)會自動為進程創(chuàng)建一個默認堆，這個堆默認所占內存的大小為1M。堆對象由系統(tǒng)進行管理，它在內存中以鏈式結構存在。通過下面的代碼可以通過堆動態(tài)申請內存空間：
	作者：121.30.67.* 2006-11-26 23:15 回復此發(fā)言

5	堆和棧的區(qū)別 (轉貼)
	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函數(shù)printf  /*---------------------------------------------------------------------------  寫到這里，我們順便來復習一下前面所講的知識：  (*注)printf函數(shù)是C語言的標準函數(shù)庫中函數(shù)，VC的標準函數(shù)庫由msvcrt.dll模塊實現(xiàn)。  由函數(shù)定義可見，printf的參數(shù)個數(shù)是可變的，函數(shù)內部無法預先知道調用者壓入的參數(shù)個數(shù)，函數(shù)只能通過分析第一個參數(shù)字符串的格式來獲得壓入?yún)?shù)的信息，由于這里參數(shù)的個數(shù)是動態(tài)的，所以必須由調用者來平衡堆棧，這里便使用了__cdecl調用規(guī)則。BTW，Windows系統(tǒng)的API函數(shù)基本上是__stdcall調用形式，只有一個API例外，那就是wsprintf，它使用__cdecl調用規(guī)則，同printf函數(shù)一樣，這是由于它的參數(shù)個數(shù)是可變的緣故。  ---------------------------------------------------------------------------*/  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);  }  執(zhí)行結果為：  0x00130000  0x00133100  0x00133118  hHeap的值怎么和那個buff的值那么接近呢？其實hHeap這個句柄就是指向HEAP首部的地址。在進程的用戶區(qū)存著一個叫PEB(進程環(huán)境塊)的結構，這個結構中存放著一些有關進程的重要信息，其中在PEB首地址偏移0x18處存放的ProcessHeap就是進程默認堆的地址，而偏移0x90處存放了指向進程所有堆的地址列表的指針。windows有很多API都使用進程的默認堆來存放動態(tài)數(shù)據(jù)，如windows 2000下的所有ANSI版本的函數(shù)都是在默認堆中申請內存來轉換ANSI字符串到Unicode字符串的。對一個堆的訪問是順序進行的，同一時刻只能有一個線程訪問堆中的數(shù)據(jù)，當多個線程同時有訪問要求時，只能排隊等待，這樣便造成程序執(zhí)行效率下降。  最后來說說內存中的數(shù)據(jù)對齊。所位數(shù)據(jù)對齊，是指數(shù)據(jù)所在的內存地址必須是該數(shù)據(jù)長度的整數(shù)倍，DWORD數(shù)據(jù)的內存起始地址能被4除盡，WORD數(shù)據(jù)的內存起始地址能被2除盡，x86 CPU能直接訪問對齊的數(shù)據(jù)，當他試圖訪問一個未對齊的數(shù)據(jù)時，會在內部進行一系列的調整，這些調整對于程序來說是透明的，但是會降低運行速度，所以編譯器在編譯程序時會盡量保證數(shù)據(jù)對齊。同樣一段代碼，我們來看看用VC、Dev-C++和lcc三個不同編譯器編譯出來的程序的執(zhí)行結果：  #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編譯后的執(zhí)行結果：  0x0012ff7c  0x0012ff7b  0x0012ff80  變量在內存中的順序：b(1字節(jié))-a(4字節(jié))-c(4字節(jié))。  這是用Dev-C++編譯后的執(zhí)行結果：  0x0022ff7c  0x0022ff7b  0x0022ff74  變量在內存中的順序：c(4字節(jié))-中間相隔3字節(jié)-b(占1字節(jié))-a(4字節(jié))。  這是用lcc編譯后的執(zhí)行結果：  0x0012ff6c  0x0012ff6b  0x0012ff64  變量在內存中的順序：同上。  三個編譯器都做到了數(shù)據(jù)對齊，但是后兩個編譯器顯然沒VC“聰明”，讓一個char占了4字節(jié)，浪費內存哦。  基礎知識：  堆棧是一種簡單的數(shù)據(jù)結構，是一種只允許在其一端進行插入或刪除的線性表。允許插入或刪除操作的一端稱為棧頂，另一端稱為棧底，對堆棧的插入和刪除操作被稱為入棧和出棧。有一組CPU指令可以實現(xiàn)對進程的內存實現(xiàn)堆棧訪問。其中，POP指令實現(xiàn)出棧操作，PUSH指令實現(xiàn)入棧操作。CPU的ESP寄存器存放當前線程的棧頂指針，EBP寄存器中保存當前線程的棧底指針。CPU的EIP寄存器存放下一個CPU指令存放的內存地址，當CPU執(zhí)行完當前的指令后，從EIP寄存器中讀取下一條指令的內存地址，然后繼續(xù)執(zhí)行。
	作者：121.30.67.* 2006-11-26 23:15 回復此發(fā)言

6	堆和棧的區(qū)別 (轉貼)
	參考：《Windows下的HEAP溢出及其利用》by: isno  《windows核心編程》by: Jeffrey Richter  摘要： 討論常見的堆性能問題以及如何防范它們。（共 9 頁） 前言 您是否是動態(tài)分配的 C/C++ 對象忠實且幸運的用戶？您是否在模塊間的往返通信中頻繁地使用了“自動化”？您的程序是否因堆分配而運行起來很慢？不僅僅您遇到這樣的問題。幾乎所有項目遲早都會遇到堆問題。大家都想說，“我的代碼真正好，只是堆太慢”。那只是部分正確。更深入理解堆及其用法、以及會發(fā)生什么問題，是很有用的。 什么是堆？ （如果您已經(jīng)知道什么是堆，可以跳到“什么是常見的堆性能問題？”部分） 在程序中，使用堆來動態(tài)分配和釋放對象。在下列情況下，調用堆操作：  事先不知道程序所需對象的數(shù)量和大小。 對象太大而不適合堆棧分配程序。 堆使用了在運行時分配給代碼和堆棧的內存之外的部分內存。下圖給出了堆分配程序的不同層。 GlobalAlloc/GlobalFree：Microsoft Win32 堆調用，這些調用直接與每個進程的默認堆進行對話。 LocalAlloc/LocalFree：Win32 堆調用（為了與 Microsoft Windows NT 兼容），這些調用直接與每個進程的默認堆進行對話。 COM 的 IMalloc 分配程序（或 CoTaskMemAlloc / CoTaskMemFree）：函數(shù)使用每個進程的默認堆。自動化程序使用“組件對象模型 (COM)”的分配程序，而申請的程序使用每個進程堆。 C/C++ 運行時 (CRT) 分配程序：提供了 malloc() 和 free() 以及 new 和 delete 操作符。如 Microsoft Visual Basic 和 Java 等語言也提供了新的操作符并使用垃圾收集來代替堆。CRT 創(chuàng)建自己的私有堆，駐留在 Win32 堆的頂部。 Windows NT 中，Win32 堆是 Windows NT 運行時分配程序周圍的薄層。所有 API 轉發(fā)它們的請求給 NTDLL。 Windows NT 運行時分配程序提供 Windows NT 內的核心堆分配程序。它由具有 128 個大小從 8 到 1,024 字節(jié)的空閑列表的前端分配程序組成。后端分配程序使用虛擬內存來保留和提交頁。 在圖表的底部是“虛擬內存分配程序”，操作系統(tǒng)使用它來保留和提交頁。所有分配程序使用虛擬內存進行數(shù)據(jù)的存取。 分配和釋放塊不就那么簡單嗎？為何花費這么長時間？ 堆實現(xiàn)的注意事項 傳統(tǒng)上，操作系統(tǒng)和運行時庫是與堆的實現(xiàn)共存的。在一個進程的開始，操作系統(tǒng)創(chuàng)建一個默認堆，叫做“進程堆”。如果沒有其他堆可使用，則塊的分配使用“進程堆”。語言運行時也能在進程內創(chuàng)建單獨的堆。（例如，C 運行時創(chuàng)建它自己的堆。）除這些專用的堆外，應用程序或許多已載入的動態(tài)鏈接庫 (DLL) 之一可以創(chuàng)建和使用單獨的堆。Win32 提供一整套 API 來創(chuàng)建和使用私有堆。有關堆函數(shù)（英文）的詳盡指導，請參見 MSDN。 當應用程序或 DLL 創(chuàng)建私有堆時，這些堆存在于進程空間，并且在進程內是可訪問的。從給定堆分配的數(shù)據(jù)將在同一個堆上釋放。（不能從一個堆分配而在另一個堆釋放。） 在所有虛擬內存系統(tǒng)中，堆駐留在操作系統(tǒng)的“虛擬內存管理器”的頂部。語言運行時堆也駐留在虛擬內存頂部。某些情況下，這些堆是操作系統(tǒng)堆中的層，而語言運行時堆則通過大塊的分配來執(zhí)行自己的內存管理。不使用操作系統(tǒng)堆，而使用虛擬內存函數(shù)更利于堆的分配和塊的使用。 典型的堆實現(xiàn)由前、后端分配程序組成。前端分配程序維持固定大小塊的空閑列表。對于一次分配調用，堆嘗試從前端列表找到一個自由塊。如果失敗，堆被迫從后端（保留和提交虛擬內存）分配一個大塊來滿足請求。通用的實現(xiàn)有每塊分配的開銷，這將耗費執(zhí)行周期，也減少了可使用的存儲空間。 Knowledge Base 文章 Q10758，“用 calloc() 和 malloc() 管理內存” （搜索文章編號）, 包含了有關這些主題的更多背景知識。另外，有關堆實現(xiàn)和設計的詳細討論也可在下列著作中找到：“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 回復此發(fā)言

7	堆和棧的區(qū)別 (轉貼)
	Windows NT 的實現(xiàn)（Windows NT 版本 4.0 和更新版本） 使用了 127 個大小從 8 到 1,024 字節(jié)的 8 字節(jié)對齊塊空閑列表和一個“大塊”列表。“大塊”列表（空閑列表[0]） 保存大于 1,024 字節(jié)的塊。空閑列表容納了用雙向鏈表鏈接在一起的對象。默認情況下，“進程堆”執(zhí)行收集操作。（收集是將相鄰空閑塊合并成一個大塊的操作。）收集耗費了額外的周期，但減少了堆塊的內部碎片。 單一全局鎖保護堆，防止多線程式的使用。（請參見“Server Performance and Scalability Killers”中的第一個注意事項, George Reilly 所著，在 “MSDN Online Web Workshop”上（站點：http://msdn.microsoft.com/workshop/server/iis/tencom.asp（英文）。）單一全局鎖本質上是用來保護堆數(shù)據(jù)結構，防止跨多線程的隨機存取。若堆操作太頻繁，單一全局鎖會對性能有不利的影響。 什么是常見的堆性能問題？ 以下是您使用堆時會遇到的最常見問題：  分配操作造成的速度減慢。光分配就耗費很長時間。最可能導致運行速度減慢原因是空閑列表沒有塊，所以運行時分配程序代碼會耗費周期尋找較大的空閑塊，或從后端分配程序分配新塊。 釋放操作造成的速度減慢。釋放操作耗費較多周期，主要是啟用了收集操作。收集期間，每個釋放操作“查找”它的相鄰塊，取出它們并構造成較大塊，然后再把此較大塊插入空閑列表。在查找期間，內存可能會隨機碰到，從而導致高速緩存不能命中，性能降低。 堆競爭造成的速度減慢。當兩個或多個線程同時訪問數(shù)據(jù)，而且一個線程繼續(xù)進行之前必須等待另一個線程完成時就發(fā)生競爭。競爭總是導致麻煩；這也是目前多處理器系統(tǒng)遇到的最大問題。當大量使用內存塊的應用程序或 DLL 以多線程方式運行（或運行于多處理器系統(tǒng)上）時將導致速度減慢。單一鎖定的使用—常用的解決方案—意味著使用堆的所有操作是序列化的。當?shù)却i定時序列化會引起線程切換上下文。可以想象交叉路口閃爍的紅燈處走走停停導致的速度減慢。  競爭通常會導致線程和進程的上下文切換。上下文切換的開銷是很大的，但開銷更大的是數(shù)據(jù)從處理器高速緩存中丟失，以及后來線程復活時的數(shù)據(jù)重建。 堆破壞造成的速度減慢。造成堆破壞的原因是應用程序對堆塊的不正確使用。通常情形包括釋放已釋放的堆塊或使用已釋放的堆塊，以及塊的越界重寫等明顯問題。（破壞不在本文討論范圍之內。有關內存重寫和泄漏等其他細節(jié)，請參見 Microsoft Visual C++(R) 調試文檔 。） 頻繁的分配和重分配造成的速度減慢。這是使用腳本語言時非常普遍的現(xiàn)象。如字符串被反復分配，隨重分配增長和釋放。不要這樣做，如果可能，盡量分配大字符串和使用緩沖區(qū)。另一種方法就是盡量少用連接操作。 競爭是在分配和釋放操作中導致速度減慢的問題。理想情況下，希望使用沒有競爭和快速分配/釋放的堆。可惜，現(xiàn)在還沒有這樣的通用堆，也許將來會有。 在所有的服務器系統(tǒng)中（如 IIS、MSProxy、DatabaseStacks、網(wǎng)絡服務器、 Exchange 和其他）, 堆鎖定實在是個大瓶頸。處理器數(shù)越多，競爭就越會惡化。 盡量減少堆的使用 現(xiàn)在您明白使用堆時存在的問題了，難道您不想擁有能解決這些問題的超級魔棒嗎？我可希望有。但沒有魔法能使堆運行加快—因此不要期望在產品出貨之前的最后一星期能夠大為改觀。如果提前規(guī)劃堆策略，情況將會大大好轉。調整使用堆的方法，減少對堆的操作是提高性能的良方。 如何減少使用堆操作？通過利用數(shù)據(jù)結構內的位置可減少堆操作的次數(shù)。請考慮下列實例： struct ObjectA {    // objectA 的數(shù)據(jù)  } struct ObjectB {    // objectB 的數(shù)據(jù)  } // 同時使用 objectA 和 objectB // // 使用指針  // struct ObjectB {    struct ObjectA * pObjA;    // objectB 的數(shù)據(jù)  } // // 使用嵌入
	作者：121.30.67.* 2006-11-26 23:15 回復此發(fā)言

8	堆和棧的區(qū)別 (轉貼)
	// struct ObjectB {    struct ObjectA pObjA;    // objectB 的數(shù)據(jù)  } // // 集合 – 在另一對象內使用 objectA 和 objectB // struct ObjectX {    struct ObjectA  objA;    struct ObjectB  objB; } 避免使用指針關聯(lián)兩個數(shù)據(jù)結構。如果使用指針關聯(lián)兩個數(shù)據(jù)結構，前面實例中的對象 A 和 B 將被分別分配和釋放。這會增加額外開銷—我們要避免這種做法。 把帶指針的子對象嵌入父對象。當對象中有指針時，則意味著對象中有動態(tài)元素（百分之八十）和沒有引用的新位置。嵌入增加了位置從而減少了進一步分配/釋放的需求。這將提高應用程序的性能。 合并小對象形成大對象（聚合）。聚合減少分配和釋放的塊的數(shù)量。如果有幾個開發(fā)者，各自開發(fā)設計的不同部分，則最終會有許多小對象需要合并。集成的挑戰(zhàn)就是要找到正確的聚合邊界。 內聯(lián)緩沖區(qū)能夠滿足百分之八十的需要（aka 80-20 規(guī)則）。個別情況下，需要內存緩沖區(qū)來保存字符串/二進制數(shù)據(jù)，但事先不知道總字節(jié)數(shù)。估計并內聯(lián)一個大小能滿足百分之八十需要的緩沖區(qū)。對剩余的百分之二十，可以分配一個新的緩沖區(qū)和指向這個緩沖區(qū)的指針。這樣，就減少分配和釋放調用并增加數(shù)據(jù)的位置空間，從根本上提高代碼的性能。 在塊中分配對象（塊化）。塊化是以組的方式一次分配多個對象的方法。如果對列表的項連續(xù)跟蹤，例如對一個 {名稱，值} 對的列表，有兩種選擇：選擇一是為每一個“名稱-值”對分配一個節(jié)點；選擇二是分配一個能容納（如五個）“名稱-值”對的結構。例如，一般情況下，如果存儲四對，就可減少節(jié)點的數(shù)量，如果需要額外的空間數(shù)量，則使用附加的鏈表指針。  塊化是友好的處理器高速緩存，特別是對于 L1-高速緩存，因為它提供了增加的位置 —不用說對于塊分配，很多數(shù)據(jù)塊會在同一個虛擬頁中。 正確使用 _amblksiz。C 運行時 (CRT) 有它的自定義前端分配程序，該分配程序從后端（Win32 堆）分配大小為 _amblksiz 的塊。將 _amblksiz 設置為較高的值能潛在地減少對后端的調用次數(shù)。這只對廣泛使用 CRT 的程序適用。 使用上述技術將獲得的好處會因對象類型、大小及工作量而有所不同。但總能在性能和可升縮性方面有所收獲。另一方面，代碼會有點特殊，但如果經(jīng)過深思熟慮，代碼還是很容易管理的。 其他提高性能的技術 下面是一些提高速度的技術：  使用 Windows NT5 堆  由于幾個同事的努力和辛勤工作，1998 年初 Microsoft Windows(R) 2000 中有了幾個重大改進： 改進了堆代碼內的鎖定。堆代碼對每堆一個鎖。全局鎖保護堆數(shù)據(jù)結構，防止多線程式的使用。但不幸的是，在高通信量的情況下，堆仍受困于全局鎖，導致高競爭和低性能。Windows 2000 中，鎖內代碼的臨界區(qū)將競爭的可能性減到最小,從而提高了可伸縮性。 使用 “Lookaside”列表。堆數(shù)據(jù)結構對塊的所有空閑項使用了大小在 8 到 1,024 字節(jié)（以 8-字節(jié)遞增）的快速高速緩存。快速高速緩存最初保護在全局鎖內。現(xiàn)在，使用 lookaside 列表來訪問這些快速高速緩存空閑列表。這些列表不要求鎖定，而是使用 64 位的互鎖操作，因此提高了性能。 內部數(shù)據(jù)結構算法也得到改進。 這些改進避免了對分配高速緩存的需求，但不排除其他的優(yōu)化。使用 Windows NT5 堆評估您的代碼；它對小于 1,024 字節(jié) (1 KB) 的塊（來自前端分配程序的塊）是最佳的。GlobalAlloc() 和 LocalAlloc() 建立在同一堆上，是存取每個進程堆的通用機制。如果希望獲得高的局部性能，則使用 Heap(R) API 來存取每個進程堆，或為分配操作創(chuàng)建自己的堆。如果需要對大塊操作，也可以直接使用 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 回復此發(fā)言

9

堆和棧的區(qū)別 (轉貼)

使用分配高速緩存  分配高速緩存允許高速緩存分配的塊，以便將來重用。這能夠減少對進程堆（或全局堆）的分配/釋放調用的次數(shù)，也允許最大限度的重用曾經(jīng)分配的塊。另外，分配高速緩存允許收集統(tǒng)計信息,以便較好地理解對象在較高層次上的使用。 典型地，自定義堆分配程序在進程堆的頂部實現(xiàn)。自定義堆分配程序與系統(tǒng)堆的行為很相似。主要的差別是它在進程堆的頂部為分配的對象提供高速緩存。高速緩存設計成一套固定大小（如 32 字節(jié)、64 字節(jié)、128 字節(jié)等）。這一個很好的策略，但這種自定義堆分配程序丟失與分配和釋放的對象相關的“語義信息”。  與自定義堆分配程序相反，“分配高速緩存”作為每類分配高速緩存來實現(xiàn)。除能夠提供自定義堆分配程序的所有好處之外，它們還能夠保留大量語義信息。每個分配高速緩存處理程序與一個目標二進制對象關聯(lián)。它能夠使用一套參數(shù)進行初始化，這些參數(shù)表示并發(fā)級別、對象大小和保持在空閑列表中的元素的數(shù)量等。分配高速緩存處理程序對象維持自己的私有空閑實體池（不超過指定的閥值）并使用私有保護鎖。合在一起，分配高速緩存和私有鎖減少了與主系統(tǒng)堆的通信量，因而提供了增加的并發(fā)、最大限度的重用和較高的可伸縮性。 需要使用清理程序來定期檢查所有分配高速緩存處理程序的活動情況并回收未用的資源。如果發(fā)現(xiàn)沒有活動，將釋放分配對象的池，從而提高性能。 可以審核每個分配/釋放活動。第一級信息包括對象、分配和釋放調用的總數(shù)。通過查看它們的統(tǒng)計信息可以得出各個對象之間的語義關系。利用以上介紹的許多技術之一，這種關系可以用來減少內存分配。 分配高速緩存也起到了調試助手的作用，幫助您跟蹤沒有完全清除的對象數(shù)量。通過查看動態(tài)堆棧返回蹤跡和除沒有清除的對象之外的簽名，甚至能夠找到確切的失敗的調用者。 MP 堆  MP 堆是對多處理器友好的分布式分配的程序包，在 Win32 SDK（Windows NT 4.0 和更新版本）中可以得到。最初由 JVert 實現(xiàn)，此處堆抽象建立在 Win32 堆程序包的頂部。MP 堆創(chuàng)建多個 Win32 堆，并試圖將分配調用分布到不同堆，以減少在所有單一鎖上的競爭。 本程序包是好的步驟 —一種改進的 MP-友好的自定義堆分配程序。但是，它不提供語義信息和缺乏統(tǒng)計功能。通常將 MP 堆作為 SDK 庫來使用。如果使用這個 SDK 創(chuàng)建可重用組件，您將大大受益。但是，如果在每個 DLL 中建立這個 SDK 庫，將增加工作設置。 重新思考算法和數(shù)據(jù)結構  要在多處理器機器上伸縮，則算法、實現(xiàn)、數(shù)據(jù)結構和硬件必須動態(tài)伸縮。請看最經(jīng)常分配和釋放的數(shù)據(jù)結構。試問，“我能用不同的數(shù)據(jù)結構完成此工作嗎？”例如，如果在應用程序初始化時加載了只讀項的列表，這個列表不必是線性鏈接的列表。如果是動態(tài)分配的數(shù)組就非常好。動態(tài)分配的數(shù)組將減少內存中的堆塊和碎片，從而增強性能。 減少需要的小對象的數(shù)量減少堆分配程序的負載。例如，我們在服務器的關鍵處理路徑上使用五個不同的對象，每個對象單獨分配和釋放。一起高速緩存這些對象，把堆調用從五個減少到一個，顯著減少了堆的負載，特別當每秒鐘處理 1,000 個以上的請求時。 如果大量使用“Automation”結構，請考慮從主線代碼中刪除“Automation BSTR”，或至少避免重復的 BSTR 操作。（BSTR 連接導致過多的重分配和分配/釋放操作。） 摘要 對所有平臺往往都存在堆實現(xiàn)，因此有巨大的開銷。每個單獨代碼都有特定的要求，但設計能采用本文討論的基本理論來減少堆之間的相互作用。  評價您的代碼中堆的使用。 改進您的代碼，以使用較少的堆調用：分析關鍵路徑和固定數(shù)據(jù)結構。 在實現(xiàn)自定義的包裝程序之前使用量化堆調用成本的方法。 如果對性能不滿意，請要求 OS 組改進堆。更多這類請求意味著對改進堆的更多關注。 要求 C 運行時組針對 OS 所提供的堆制作小巧的分配包裝程序。隨著 OS 堆的改進，C 運行時堆調用的成本將減小。 操作系統(tǒng)（Windows NT 家族）正在不斷改進堆。請隨時關注和利用這些改進。 Murali Krishnan 是 Internet Information Server (IIS) 組的首席軟件設計工程師。從 1.0 版本開始他就設計 IIS，并成功發(fā)行了 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 ，我相信這幾個詞困擾過很多人，更痛苦的是，如果你查閱過文獻資料，你會發(fā)現(xiàn)不同的資料中的解釋是不一樣的，例如在wiki中，異步和非阻塞被當成了一個概念 。
出現(xiàn)這種情況的原因，我認為很大程度上是因為IO這個概念本身就很寬泛，它其實包含了好幾個層面。比如說，你可以把它看做是一個物理上的設備，也可以看做是 OS抽象出來的一個軟件，還可以看做是平時寫程序用的read(),write()函數(shù)，不同的層面對于這幾個詞的理解也是不一樣的。

先看一個較低的層次。如果從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）為了執(zhí)行這個read操作，會調用相應的一個system call，將系統(tǒng)控制權交給kernel，然后就進行等待（這其實就是被阻塞了）。kernel開始執(zhí)行這個system call，執(zhí)行完畢后會向應用程序返回響應，應用程序得到響應后，就不再阻塞，并進行后面的工作。
 

 
例如，“在調用 read 系統(tǒng)調用時，應用程序會阻塞并對內核進行上下文切換。然后會觸發(fā)讀操作，當響應返回時（從我們正在從中讀取的設備中返回），數(shù)據(jù)就被移動到用戶空間的緩沖區(qū)中。然后應用程序就會解除阻塞（read 調用返回）。”

 舉一個淺顯的例子，就好比你去一個銀行柜臺存錢。首先，你會將存錢的單子填好，然后交給柜員。這里，你就好比是application，單子就是調用的 system call，柜員就是kernel。提交好單子后，你就坐在柜臺前等，相當于開始進行等待。柜員辦好以后會給你一個回執(zhí)，表示辦好了，這就是 response。然后你就可以拿著回執(zhí)干其它的事了。注意，這個時候，如果你辦完之后馬上去查賬，存的錢已經(jīng)打到你的賬戶上了。后面你會發(fā)現(xiàn)，這點很重要。

接下來談同步非阻塞IO 。
先看這個圖，

 

在linux下，應用程序可以通過設置文件描述符的屬性O_NONBLOCK，I/O操作可以立即返回，但是并不保證I/O操作成功。
也就是說，當應用程序設置了O_NONBLOCK之后，執(zhí)行write操作，調用相應的system call，這個system call會從內核中立即返回。但是在這個返回的時間點，數(shù)據(jù)可能還沒有被真正的寫入到指定的地方。也就是說，kernel只是很快的返回了這個 system call（這樣，應用程序不會被這個IO操作blocking），但是這個system call具體要執(zhí)行的事情（寫數(shù)據(jù)）可能并沒有完成。而對于應用程序，雖然這個IO操作很快就返回了，但是它并不知道這個IO操作是否真的成功了，如果想知道，需要應用程序主動地去問kernel。

這次不是去銀行存錢，而是去銀行匯款。同樣的，你也需要填寫匯款單然后交給柜員，柜員進行一些簡單的手續(xù)處理就能夠給你回執(zhí)。但是，你拿到回執(zhí)并不意味著錢已經(jīng)打到了對方的賬上。事實上，一般匯款的周期大概是24個小時，如果你要以存錢的模式來匯款的話，意味著你需要在銀行等24個小時，這顯然是不現(xiàn)實的。所以，同步非阻塞IO在實際生活中也是有它的意義的。

再來談談異步阻塞IO 。
在linux中，常常通過select/poll來實現(xiàn)這種機制。

 
以圖為例，
和之前一樣，應用程序要執(zhí)行read操作，因此調用一個system call，這個system call被傳遞給了kernel。但在應用程序這邊，它調用system call之后，并不等待kernel返回response，這一點是和前面兩種機制不一樣的地方。這也是為什么它被稱為異步的原因。但是為什么稱其為阻塞呢？這是因為雖然應用程序是一個異步的方式，但是select()函數(shù)會將應用程序阻塞住，一直等到這個system call有結果返回了，再通知應用程序。也就是說，“在這種模型中，配置的是非阻塞 I/O，然后使用阻塞 select 系統(tǒng)調用來確定一個 I/O 描述符何時有操作。”
所以，從IO操作的實際效果來看，異步阻塞IO和第一種同步阻塞IO是一樣的，應用程序都是一直等到IO操作成功之后（數(shù)據(jù)已經(jīng)被寫入或者讀取），才開始進行下面的工作。異步阻塞IO的好處在于一個select函數(shù)可以為多個描述符提供通知，提高了并發(fā)性。

關于提高并發(fā)性這點，我們還以銀行為例說明。比如說一個銀行柜臺，現(xiàn)在有10個人想存錢。按照現(xiàn)在銀行的做法，一個個排隊。第一個人先填存款單，然后提交，然后柜員處理，然后給回執(zhí)，成功后再輪到下一個人。大家應該都在銀行排過對，這樣的流程是很痛苦的。如果按照異步阻塞的機制，10個人都填好存款單，然后都提交給柜臺，提交完之后所有的10個人就在銀行大廳等待。這時候會專門有個人，他會了解存款單處理的情況，一旦有存款單處理完畢，他會將回執(zhí)交給相應的正在大廳等待的人，這個拿到回執(zhí)的人就可以去干其他的事情了。而前面提到的這個專人，就對應于select函數(shù)。

最后，談談異步非阻塞IO 。
這個概念相對前面兩個反而更容易理解一些。

 
如圖所示，應用程序提交read請求的system call，然后，kernel開始處理相應的IO操作，而同時，應用程序并不等kernel返回響應，就會開始執(zhí)行其他的處理操作（應用程序沒有被IO操作所阻塞）。當kernel執(zhí)行完畢，返回read的響應，就會產生一個信號或執(zhí)行一個基于線程的回調函數(shù)來完成這次 I/O 處理過程。

比如銀行存錢。現(xiàn)在某銀行新開通了一項存錢業(yè)務。用戶之需要將存款單交給柜臺，然后無需等待就可以離開了。柜臺辦好以后會給用戶發(fā)送一條短信，告知交易成功。這樣用戶不需要在柜臺前進行長時間的等待，同時，也能夠得到確切的消息知道交易完成。

從前面的介紹中可以看出，所謂的同步和異步，在這里指的是application和kernel之間的交互方式。如果application不需要等待 kernel的回應，那么它就是異步的。如果application提交完IO請求后，需要等待“回執(zhí)”，那么它就是同步的。
而阻塞和非阻塞，指的是application是否等待IO操作的完成。如果application必須等到IO操作實際完成以后再執(zhí)行下面的操作，那么它是阻塞的。反之，如果不等待IO操作的完成就開始執(zhí)行其它操作，那么它是非阻塞的。

 

本文來自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即可，而對于已經(jīng)包含了<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、首先和控制臺程序一樣，如果編譯環(huán)境設置了采用單線程庫, 要改成多線程庫，這個可以從工程屬性里進行修改，詳細信息可以參考候捷的<<mfc 深入淺出>>. 下面給出的是我常用的方式，可以直接把它復制到工程里使用：

  #ifdef _DEBUG
  #pragma comment(lib, "libcmtd.lib")
  #else
  #pragma comment(lib, "libcmt.lib")
  #endif  
2、工程目錄下創(chuàng)建一個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前面。現(xiàn)在可以正常的使用CString了。

當在vs2005中添加類或者變量是會出現(xiàn) “當前頁面腳本發(fā)生錯誤”的提示，如下圖所示：

該解決方案如下：
（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 文章的博主。。。。

同步：函數(shù)沒有執(zhí)行完不返回，線程被掛起

阻塞：沒有收完數(shù)據(jù)函數(shù)不返回，線程也被掛起

異步：函數(shù)立即返回，通過事件或是信號通知調用者

非阻塞：函數(shù)立即返回，通過select通知調用者

這樣看來異步和非阻塞有什么區(qū)別呢？

異步=非阻塞？

同步是在操作系統(tǒng)層面上，阻塞是在套接字上？

Reactor是同步 Proactor是異步？

回答：

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

　　在進行網(wǎng)絡編程時，我們常常見到同步、異步、阻塞和非阻塞四種調用方式。這些方式彼此概念并不好理解。下面是我對這些術語的理解。

同步
　　所謂同步，就是在發(fā)出一個功能調用時，在沒有得到結果之前，該調用就不返回。按照這個定義，其實絕大多數(shù)函數(shù)都是同步調用（例如sin, isdigit等）。但是一般而言，我們在說同步、異步的時候，特指那些需要其他部件協(xié)作或者需要一定時間完成的任務。最常見的例子就是 SendMessage。該函數(shù)發(fā)送一個消息給某個窗口，在對方處理完消息之前，這個函數(shù)不返回。當對方處理完畢以后，該函數(shù)才把消息處理函數(shù)所返回的 LRESULT值返回給調用者。

異步
　　異步的概念和同步相對。當一個異步過程調用發(fā)出后，調用者不能立刻得到結果。實際處理這個調用的部件在完成后，通過狀態(tài)、通知和回調來通知調用者。以 CAsycSocket類為例（注意，CSocket從CAsyncSocket派生，但是起功能已經(jīng)由異步轉化為同步），當一個客戶端通過調用 Connect函數(shù)發(fā)出一個連接請求后，調用者線程立刻可以朝下運行。當連接真正建立起來以后，socket底層會發(fā)送一個消息通知該對象。這里提到執(zhí)行 部件和調用者通過三種途徑返回結果：狀態(tài)、通知和回調。可以使用哪一種依賴于執(zhí)行部件的實現(xiàn)，除非執(zhí)行部件提供多種選擇，否則不受調用者控制。如果執(zhí)行部 件用狀態(tài)來通知，那么調用者就需要每隔一定時間檢查一次，效率就很低（有些初學多線程編程的人，總喜歡用一個循環(huán)去檢查某個變量的值，這其實是一種很嚴重 的錯誤）。如果是使用通知的方式，效率則很高，因為執(zhí)行部件幾乎不需要做額外的操作。至于回調函數(shù)，其實和通知沒太多區(qū)別。

阻塞
　　阻塞調用是指調用結果返回之前，當前線程會被掛起。函數(shù)只有在得到結果之后才會返回。有人也許會把阻塞調用和同步調用等同起來，實際上他是不同的。對于同 步調用來說，很多時候當前線程還是激活的，只是從邏輯上當前函數(shù)沒有返回而已。例如，我們在CSocket中調用Receive函數(shù)，如果緩沖區(qū)中沒有數(shù) 據(jù)，這個函數(shù)就會一直等待，直到有數(shù)據(jù)才返回。而此時，當前線程還會繼續(xù)處理各種各樣的消息。如果主窗口和調用函數(shù)在同一個線程中，除非你在特殊的界面操 作函數(shù)中調用，其實主界面還是應該可以刷新。socket接收數(shù)據(jù)的另外一個函數(shù)recv則是一個阻塞調用的例子。當socket工作在阻塞模式的時候， 如果沒有數(shù)據(jù)的情況下調用該函數(shù)，則當前線程就會被掛起，直到有數(shù)據(jù)為止。

非阻塞
　　非阻塞和阻塞的概念相對應，指在不能立刻得到結果之前，該函數(shù)不會阻塞當前線程，而會立刻返回。

　　對象的阻塞模式和阻塞函數(shù)調用
　　對象是否處于阻塞模式和函數(shù)是不是阻塞調用有很強的相關性，但是并不是一一對應的。阻塞對象上可以有非阻塞的調用方式，我們可以通過一定的API去輪詢狀 態(tài)，在適當?shù)臅r候調用阻塞函數(shù)，就可以避免阻塞。而對于非阻塞對象，調用特殊的函數(shù)也可以進入阻塞調用。函數(shù)select就是這樣的一個例子。

阻塞通信

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

　　通過重疊通信和計算在許多系統(tǒng)能提高性能。由一個智能通信控制器自動地執(zhí)行通信的系統(tǒng)是真實的。輕－重線索是取得這種重疊的一種機制。導致好性能的 一個可選的機制是使用非阻塞通信。一個阻塞發(fā)送開始調用初始化這個發(fā)送操作，但不完成它。在這個消息被從這個發(fā)送緩存拷出以前，這個發(fā)送開始調用將返回。 需要一個獨立的“發(fā)送完成”調用完成這個通信，例如，檢驗從發(fā)送緩存拷出的數(shù)據(jù)。用適當?shù)挠布诎l(fā)送被初始化后和它完成以前，來自發(fā)送者存儲的數(shù)據(jù)轉換 可以和在發(fā)送者完成的計算同時進行。類似地，一個非阻塞“接收開始調用”初始化這個接收操作, 但不完成它。在一個消息被存入這個接收緩存以前，這個調用將返回。須要一個獨立的“接收完成”調用完成這個接收操作，并檢驗被接收到這個接收緩存的數(shù)據(jù)。 用適當?shù)挠布诮邮詹僮鞒跏蓟蠛退瓿梢郧埃浇邮照叽鎯Φ臄?shù)據(jù)轉換可以和計算同時進行。非阻塞接收的使用雖著信息較早地在接收緩存位置被提供，也可 以避免系統(tǒng)緩存和存儲器到存儲器拷貝。

　　非阻塞發(fā)送開始調用能使用與阻塞發(fā)送一樣的四種模式: 標準, 緩存, 同步和準備好模式。這些具有同樣的意義。無論一個匹配接收是否已登入，能開始除“準備好”以外的所有模式的發(fā)送；只要一個匹配接收已登入，就能開始一個非 阻塞“準備好”發(fā)送。在所有情況下，發(fā)送開始調用是局部的：無論其它進程的狀態(tài)如何，它立刻返回。如果這個調用使得一些系統(tǒng)資源用完，那么它將失敗并返回 一個錯誤代碼。高質量的MPI實現(xiàn)應保證這種情況只在“病態(tài)”時發(fā)生。即，一個MPI實現(xiàn)將能支持大數(shù)量掛起非阻塞操作。　　

　　當數(shù)據(jù)已被從發(fā)送緩存拷出時，這個發(fā)送完成調用返回。它可以帶有附加的意義，這取決于發(fā)送模式。　

　　如果發(fā)送模式是“同步的”，那么只有一個匹配接收已開始這個發(fā)送才能完成。即，一個接收已被登入，并已和這個發(fā)送匹配。這時，這個發(fā)送完成調用是非 局部的。注意，在接收完成調用發(fā)生以前，如果一個同步、非阻塞發(fā)送和一個非阻塞接收匹配, 它可以完成。(發(fā)送者一“知道”轉換將結束，它就能完成，但在接收者“知道”轉換將結束以前)。　　

　　如果發(fā)送模式是“緩存”，并沒有掛起接收，那么消息必須被緩存。這時，發(fā)送完成調用是局部的，而且無論一個匹配接收的狀態(tài)如何，它必須成功。　　

　　如果發(fā)送模式是標準的，同時這個消息被緩存，那么在一個匹配接收發(fā)生以前，發(fā)送結束調用可以返回。另一方面，發(fā)送完成直到一個匹配接收發(fā)生才可以完成，并且這個消息已被拷到接收緩存。　　

　　非阻塞發(fā)送能被用阻塞接收匹配，反過來也可以。

　　給用戶的建議. 一個發(fā)送操作的完成, 對于標準模式可以被延遲, 對于同部模式必須延遲, 直到一個匹配接收登入。這兩種情況下非阻塞發(fā)送的使用允許發(fā)送者提前于接收者進行，以便在兩進程的速度方面，計算更容忍波動。　　

　　緩存和準備好模式中的非阻塞發(fā)送有一個更有限的影響。一可能一個非阻塞發(fā)送將返回，而一個阻塞發(fā)送將在數(shù)據(jù)被從發(fā)送者存儲拷出后返回。只要在數(shù)據(jù)拷貝能和計算同時的情況下，非阻塞發(fā)送的使用有優(yōu)點。

　　消息發(fā)送模式隱含著由發(fā)送者初始化通信。當發(fā)送者初始化通信(數(shù)據(jù)被直接移到接收緩存, 并不要求排隊一個掛起發(fā)送請求) 時，如果一個接收已登入，這個通信一般將有較低的額外負擔。但是，只在匹配發(fā)送已發(fā)生后，一個接收操作能完成。當非阻塞接收等待發(fā)送時，沒有阻塞接收，它 的使用允許得到較低的通信額外負擔。（給用戶的建議結束）。

原文出處：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就會提示輸入序列號.

已經(jīng)安裝Office2007的直接進行以下步驟:

2:打開微軟正版驗證的網(wǎng)頁:
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位系統(tǒng)為system64\目錄下)
注意:OGACheckControl.dll文件的版本號與系統(tǒng)windows\system32\下同名文件版本號一致
Dll下載: 點擊下載此文件

5:再次驗證office2007,通過微軟的正版驗證!

注意:2008年10月20日微軟更新OGACheckControl.dll文件,最新版本號為:1.7.105.14,在未替換OGACheckControl.dll文件不能通過正版驗證前不要打開任何office2007組件,以免出現(xiàn)"星星"警告!

版本號為"1.7.111.0"的OGACheckControl.dll文件: 點擊下載此文件

已經(jīng)不幸中招有"星星"警告的,請用附件中OGA卸載工具,解壓后點鼠標右鍵中卸載,直接點擊不能卸載,卸載OGACheckControl.dll文件,重啟計算機,更換office安裝序列號,用附件中OGACheckControl.dll重新替換系統(tǒng)windows\system32\ 下同名文件,再激活office2007.
星星卸載: 點擊下載此文件
或者干脆結束掉星星并替換掉星星程序.可用下面的批處理文件.
點擊下載此文件

Office下載(推薦迅雷):
企業(yè)版:ftp://ribbitar.3322.org/Soft/MicrosoftOfficeEnterprise2007.iso
專業(yè)版:ftp://ribbitar.3322.org/Soft/MicrosoftOfficeProfessionalPlus2007.iso




轉載于：
http://1vr.cn/article.asp?id=411

利用MFC進行編程時，我們從對話框中利用GetWindowText得到的字符串是CString類型，CString是屬于MFC的類。而一些標準C/C++庫函數(shù)是不能直接對CString類型進行操作的，所以我們經(jīng)常遇到將CString類型轉化char*等等其他數(shù)據(jù)類型的情況。這里總結備忘于此！ 首先要明確，標準C中是不存在string類型的，string是標準C++擴充字符串操作的一個類。但是我們知道標準C中有string.h這個頭文件，這里要區(qū)分清楚，此string非彼string。string.h這個頭文件中定義了一些我們經(jīng)常用到的操作字符串的函數(shù)，如：strcpy、strcat、strcmp等等，但是這些函數(shù)的操作對象都是char*指向的字符串。 而C++的string類操作對象是string類型字符串，該類重裝了一些運算符，添加了一些字符串操作成員函數(shù)，使得操作字符串更加方便。有的時候我們要將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()區(qū)別是：前者返回帶'\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*之間的轉化可以使用強制轉化，或者標準庫函數(shù)進行。對于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