Introduction
Let's start with the reason why I
wrote this article. One day, a colleague asked me to help him debug
a problem he had. So I was watching him stepping in
his code, when I noticed the following line:
Collapseint test = GetLastError();
He did this, because he wanted to know the error code, if the previous
function failed. He was adding this line every time he wanted to know the error
code. I advised him to remove all those lines and use the @ERR pseudoregister in
his watch window. He didn't know what it was and asking around in the office, a
lot of other people didn't. So I came up with this article for people who have never
heard of pseudoregisters.
What is a pseudoregister anyway?
A pseudoregister is not an actual hardware
register, but is displayed as though it were a hardware register. With a
pseudoregister, you can see and use certain values (error codes,
thread information block...) in the debugger.
Let's have a look at the @ERR pseudoregister. Fire up your debugger with your
favourite home-written application. Put a breakpoint in your code so that the
debugger will break execution. Open the watch window if it isn't already (do
this by right clicking on some empty toolbar space, and select "Watch" from this
list). Add @ERR in this watch window. You should see 0 in the Value column. Now
step through your code, and watch this value. It will always show the
GetLastError() number for the current thread. So if something goes wrong in your
code, this value will change.
If you want to test this, but your code doesn't
have any errors, I advise to put some in (but don't forget to remove them
afterwards). You can insert something like this:
Collapse
FILE *fp = fopen("c:\\a_file_that_does_not_exist.txt", "r");
If you step over this line, you'll see that the @ERR value changed to 2. Go to Tools->Error Lookup to see
what this error value means ("The system cannot find the file specified" if you
were wondering). Lazy bums like me, and smart lads / lasses like you can change
the @ERR pseudoregister to @ERR,hr . Doing this will change the value of the
pseudoregister to the error string. Now you even don't have to lookup the error.
I leave the @ERR,hr in the watch window all the time.
Conditional Expressions
Pseudoregisters can also
be used in conditional expressions. To try this out, put following lines after
the fopen:
Collapse
if (fp)
{
fclose(fp);
}
Put a breakpoint on the if (fp) line. Go to Edit->Breakpoints (or
press Alt-F9). Select the breakpoint you just inserted and press the "Condition"
button. Here, you can enter the @ERR==2 condition. Now start the debugger. The
debugger will break on this breakpoint if fopen() failed because it couldn't find
the file. If the file does exist, the debugger won't break, even if it
encountered another error (say error 4: could not open the file). Try this out by
running the code (not stepping) after creating, and deleting the
"a_file_that_does_not_exist.txt" file on c:\.
Just for the very curious (and
otherwise totally irrelevant to this article) : what does @ERR do? How does it
get the error number? As it turns out, @ERR does exactly the same thing as
GetLastError() does. These functions have a whopping 3 lines of assembly code:
Collapse
mov eax,fs:[00000018h]
mov eax,dword ptr [eax+34h]
ret
So @ERR grabs the DWORD at
offset 0x34 in the thread environment block pointed to by fs:[18h].
The @TIB pseudoregister
The @ERR pseudoregister is not the only one that exists. Another important pseudoregister
is @TIB. This is the thread information block for the current thread and is
extremely helpful in multi-threaded debugging. If you place a breakpoint in a
function that is called by multiple threads, the debugger will break execution
every time no matter which thread passes the breakpoint. Even if you're stepping
through your code, the debugger can jump to the breakpoint if another thread
called the function. To solve this, you'll need to do the following. If
execution breaks in the thread you want, add @TIB in the watch window. You will
see some value like "0x7ffa6000" or "2147115008" in regular display. Go to the
breakpoint menu (Alt-F9) and select the breakpoint. You can now add the
@TIB==0x7ffa6000 condition filter. Doing this, the debugger will only break
execution for this thread. All other threads using the same function will not
result in a break.
This doesn't work in Windows 98 though. For Windows 98,
you'll need to look at the Intel CPU FS register, which is unique for each
thread. You can use the expression @FS==value
Complete list of pseudoregisters
|
Pseudoregister
|
Description
|
|
@ERR
|
Last error value; the same value returned by the GetLastError() API function
|
|
@TIB
|
Thread information block for the current thread; necessary because the debugger doesn't handle the "FS:0" format
|
|
@CLK
|
Undocumented clock register; usable only in the Watch window
|
|
@EAX, @EBX, @ECX, @EDX, @ESI, @EDI, @EIP, @ESP, @EBP, @EFL
|
Intel CPU registers
|
|
@CS, @DS, @ES, @SS, @FS, @GS
|
Intel CPU segment registers
|
|
@ST0, @ST1, @ST2, @ST3, @ST4, @ST5, @ST6, @ST7
|
Intel CPU floating-point registers
|
4，工具
C++的輔助工具繁多，我們分門別類的為大家作介紹：
4.1 文檔類
(1) Doxygen
參考站點：http://www.doxygen.org/
Doxygen是一種適合C風格語言（如C++、C、IDL、Java甚至包括C#和PHP）的、
開放源碼的、基于命令行的文檔產生器。
(2) C++2HTML
參考站點：http://www.bedaux.net/cpp2html/
把C++代碼變成語法高亮的HTML
(3) CodeColorizer
參考站點：http://www.chami.com/colorizer/
它能把好幾種語言的源代碼著色為HTML
(4) Doc-O-Matic
參考站點：http://www.doc-o-matic.com/
Doc-O_Matic為你的C/C++，C++.net，Delphi/Pascal, VB.NET，C#和Java程序
或者組件產生準確的文檔。Doc-O-Matic使用源代碼中的符號和注釋以及外部的文檔
文件創建與流行的文檔樣式一致的文檔。
(5) DocVizor
參考站點：http://www.ucancode.net/Products/DocBuilder/Features.htm
DocVizor滿足了面向對象軟件開發者的基本要求——它讓我們能夠看到C++工程
中的類層次結構。DocVizor快速地產生完整可供打印的類層次結構圖，包括從第三
方庫中來的那些類，除此之外DocVizor還能從類信息中產生HTML文件。
(6) SourcePublisher C++
參考站點：http://www.scitools.com/sourcepublisher_c.html
給源代碼產生提供快速直觀的HTML報表，包括代碼，類層次結構，調用和被調
用樹，包含和被包含樹。支持多種操作系統。
(7) Understand
參考站點：http://www.scitools.com/ucpp.html
分析任何規模的C或者C++工程，幫助我們更好的理解以及編寫文檔。
4.2 代碼類
(1) CC-Rider
參考站點：http://www.cc-rider.com/
CC-Rider是用于C/C++程序強大的代碼可視化工具，通過交互式瀏覽、編輯及自
動文件來促進程序的維持和發展。
(2) CodeInspect
參考站點：http://www.yokasoft.com/
一種新的C/C++代碼分析工具。它檢查我們的源代碼找出非標準的，可能的，以
及普通的錯誤代碼。
(3) CodeWizard
參考站點：http://www.parasoft.com/
先進的C/C++源代碼分析工具，使用超過500個編碼規范自動化地標明危險的，
但是編譯器不能檢查到的代碼結構。
(4) C++ Validation Test Suites
參考站點：http://www.plumhall.com/suites.html
一組用于測試編譯器和庫對于標準吻合程度的代碼庫。
(5) CppRefactory
參考站點：http://cpptool.sourceforge.net/
CPPRefactory是一個使得開發者能夠重構他們的C++代碼的程序。目的是使得C
++代碼的重構能夠盡可能的有效率和簡單。
(6) Lzz
參考站點：http://www.lazycplusplus.com/
Lzz是一個自動化許多C++編程中的體力活的工具。它能夠節省我們許多事件并
且使得編碼更加有樂趣。給出一系列的聲明，Lzz會給我們創建頭文件和源文件。
(7) QA C++ Generation 2000
參考站點：http://www.programmingresearch.com/solutions/qacpp.htm
它關注面向對象的C++源代碼，對有關于設計，效率，可靠性，可維護性的部分
提出警告信息。
(8) s-mail project - Java to C++DOL
參考站點：http://sadlocha.strefa.pl/s-mail/ja2dol.html
把Java源代碼翻譯為相應的C++源代碼的命令行工具。
(9) SNIP from Cleanscape Software International
參考站點：http://www.cleanscape.net/stdprod/snip/index.html
一個填平編碼和設計之間溝壑的易于使用的C++開發工具，節省大量編輯和調試
的事件，它還使得開發者能夠指定設計模式作為對象模型，自動從對象模型中產生
C++的類。
(10) SourceStyler C++
參考站點：http://www.ochresoftware.com/
對C/C++源代碼提供完整的格式化和排版控制的工具。提供多于75個的格式化選
項以及完全支持ANSI C++。
4.3 編譯類
(1) Compilercache
參考站點：http://www.erikyyy.de/compilercache/
Compilercache是一個對你的C和C++編譯器的封裝腳本。每次我們進行編譯，封
裝腳本，把編譯的結果放入緩存，一旦編譯相同的東西，結果將從緩存中取出而不
是再次編譯。
(2) Ccache
參考站點：http://ccache.samba.org/
Ccache是一個編譯器緩存。它使用起來就像C/C++編譯器的緩存預處理器，編譯
速度通常能提高普通編譯過程的5~10倍。
(3) Cmm (C++ with MultiMethods)
參考站點：http://www.op59.net/cmm/cmm-0.28/users.html
這是一種C++語言的擴展。讀入Cmm源代碼輸出C++的源代碼，功能是對C++語言
添加了對multimethod的支持。
(4) The Frost Project
參考站點：http://frost.flewid.de/
Forst使得你能夠在C++程序中像原生的C++特性一樣使用multimethod以及虛函
數參數。它是一個編譯器的外殼。
4.4 測試和調試類
(1) CPPUnit
CppUnit 是個基于 LGPL 的開源項目，最初版本移植自 JUnit，是一個非常優
秀的開源測試框架。CppUnit 和 JUnit 一樣主要思想來源于極限編程。主要功能就
是對單元測試進行管理，并可進行自動化測試。
(2) C++Test
參考站點：http://www.parasoft.com/
C++ Test是一個單元測試工具，它自動化了C和C++類，函數或者組件的測試。
(3) Cantata++
參考站點：http://www.iplbath.com/products/tools/pt400.shtml
設計的目的是為了滿足在合理的經濟開銷下使用這個工具可以讓開發工程師開
展單元測試和集成測試的需求.
(4) Purify
參考站點：http://www-900.ibm.com/cn/software/rational/products/purif
yplus/index.shtml
IBM Rational PurifyPlus是一套完整的運行時分析工具，旨在提高應用程序的
可靠性和性能。PurifyPlus將內存錯誤和泄漏檢測、應用程序性能描述、代碼覆蓋
分析等功能組合在一個單一、完整的工具包中。
(5) BoundsChecker
BoundsChecker是一個C++運行時錯誤檢測和調試工具。它通過在Visual Studi
o內自動化調試過程加速開發并且縮短上市的周期。BoundsChecker提供清楚，詳細
的程序錯誤分析，許多是對C++獨有的并且在static，stack和heap內存中檢測和診
斷錯誤，以及發現內存和資源的泄漏。 (6) Insure++
參考站點：http://www.parasoft.com/
一個自動化的運行時程序測試工具，檢查難以察覺的錯誤,如內存覆蓋，內存泄
漏，內存分配錯誤，變量初始化錯誤，變量定義沖突，指針錯誤，庫錯誤，邏輯錯
誤和算法錯誤等。
(7) GlowCode
參考站點：http://www.glowcode.com/
GlowCode包括內存泄漏檢查，code profiler，函數調用跟蹤等功能。給C++開
發者提供完整的錯誤診斷，和運行時性能分析工具包。
(8) Stack Spy
參考站點：http://www.imperioustech.com/
它能捕捉stack corruption, stack over run, stack overflow等有關棧的錯
誤。
------------------------------------------------------------------------
5，庫
在C++中，庫的地位是非常高的。C++之父 Bjarne Stroustrup先生多次表示了
設計庫來擴充功能要好過設計更多的語法的言論。現實中，C++的庫門類繁多，解決
的問題也是極其廣泛，庫從輕量級到重量級的都有。不少都是讓人眼界大開，亦或
是望而生嘆的思維杰作。由于庫的數量非常龐大，而且限于筆者水平，其中很多并
不了解。所以文中所提的一些庫都是比較著名的大型庫。
5.1 標準庫
標準庫中提供了C++程序的基本設施。雖然C++標準庫隨著C++標準折騰了許多年
，直到標準的出臺才正式定型，但是在標準庫的實現上卻很令人欣慰得看到多種實
現，并且已被實踐證明為有工業級別強度的佳作。
(1) Dinkumware C++ Library
參考站點：http://www.dinkumware.com/
P.J. Plauger編寫的高品質的標準庫。P.J. Plauger博士是Dr. Dobb's程序設
計杰出獎的獲得者。其編寫的庫長期被Microsoft采用，并且最近Borland也取得了
其OEM的license，在其C/C++的產品中采用Dinkumware的庫。
(2) RogueWave Standard C++ Library
參考站點：http://www.roguewave.com/
這個庫在Borland C++ Builder的早期版本中曾經被采用，后來被其他的庫給替
換了。筆者不推薦使用。
(3) SGI STL
參考站點：http://www.roguewave.com/
SGI公司的C++標準模版庫。
(4) STLport
參考站點：http://www.stlport.org/
SGI STL庫的跨平臺可移植版本。
5.2 “準”標準庫 - Boost
參考站點：http://www.boost.org/
國內鏡像：http://www.c-view.org/tech/lib/boost/index.htm
Boost庫是一個經過千錘百煉、可移植、提供源代碼的C++庫，作為標準庫的后
備，是C++標準化進程的發動機之一。 Boost庫由C++標準委員會庫工作組成員發起
，在C++社區中影響甚大，其成員已近2000人。 Boost庫為我們帶來了最新、最酷、
最實用的技術，是不折不扣的“準”標準庫。
Boost中比較有名氣的有這么幾個庫：
Regex
正則表達式庫
Spirit
LL parser framework，用C++代碼直接表達EBNF
Graph
圖組件和算法
Lambda
在調用的地方定義短小匿名的函數對象，很實用的functional功能
concept check
檢查泛型編程中的concept
Mpl
用模板實現的元編程框架
Thread
可移植的C++多線程庫
Python
把C++類和函數映射到Python之中
Pool
內存池管理
smart_ptr
5個智能指針，學習智能指針必讀，一份不錯的參考是來自CUJ的文章：
Smart Pointers in Boost，哦，這篇文章可以查到，CUJ是提供在線瀏覽的。
中文版見筆者在《Dr. Dobb's Journal軟件研發雜志》第7輯上的譯文。
Boost總體來說是實用價值很高，質量很高的庫。并且由于其對跨平臺的強調，
對標準C++的強調，是編寫平臺無關，現代C++的開發者必備的工具。但是Boost中也
有很多是實驗性質的東西，在實際的開發中實用需要謹慎。并且很多Boost中的庫功
能堪稱對語言功能的擴展，其構造用盡精巧的手法，不要貿然的花費時間研讀。Bo
ost另外一面，比如Graph這樣的庫則是具有工業強度，結構良好，非常值得研讀的
精品代碼，并且也可以放心的在產品代碼中多多利用。
5.3 GUI
在眾多C++的庫中，GUI部分的庫算是比較繁榮，也比較引人注目的。在實際開
發中，GUI庫的選擇也是非常重要的一件事情，下面我們綜述一下可選擇的GUI庫，
各自的特點以及相關工具的支持。
(1) MFC
大名鼎鼎的微軟基礎類庫（Microsoft Foundation Class）。大凡學過VC++的
人都應該知道這個庫。雖然從技術角度講，MFC是不大漂亮的，但是它構建于Windo
ws API 之上，能夠使程序員的工作更容易,編程效率高，減少了大量在建立 Windo
ws 程序時必須編寫的代碼，同時它還提供了所有一般 C++ 編程的優點，例如繼承
和封裝。MFC 編寫的程序在各個版本的Windows操作系統上是可移植的，例如，在
Windows 3.1下編寫的代碼可以很容易地移植到 Windows NT 或 Windows 95 上。但
是在最近發展以及官方支持上日漸勢微。
(2) QT
參考網站：http://www.trolltech.com/
Qt是Trolltech公司的一個多平臺的C++圖形用戶界面應用程序框架。它提供給
應用程序開發者建立藝術級的圖形用戶界面所需的所用功能。Qt是完全面向對象的
很容易擴展，并且允許真正地組件編程。自從1996年早些時候，Qt進入商業領域，
它已經成為全世界范圍內數千種成功的應用程序的基礎。Qt也是流行的Linux桌面環
境KDE 的基礎，同時它還支持Windows、Macintosh、Unix/X11等多種平臺。
(3) WxWindows
參考網站：http://www.wxwindows.org/
跨平臺的GUI庫。因為其類層次極像MFC，所以有文章介紹從MFC到WxWindows的
代碼移植以實現跨平臺的功能。通過多年的開發也是一個日趨完善的GUI庫，支持同
樣不弱于前面兩個庫。并且是完全開放源代碼的。新近的C++ Builder X的GUI設計
器就是基于這個庫的。
(4) Fox
參考網站：http://www.fox-toolkit.org/
開放源代碼的GUI庫。作者從自己親身的開發經驗中得出了一個理想的GUI庫應
該是什么樣子的感受出發，從而開始了對這個庫的開發。有興趣的可以嘗試一下。
(5) WTL
基于ATL的一個庫。因為使用了大量ATL的輕量級手法，模板等技術，在代碼尺
寸，以及速度優化方面做得非常到位。主要面向的使用群體是開發COM輕量級供網絡
下載的可視化控件的開發者。
(6) GTK
參考網站：http://gtkmm.sourceforge.net/
GTK是一個大名鼎鼎的C的開源GUI庫。在Linux世界中有Gnome這樣的殺手應用。
而GTK就是這個庫的C++封裝版本。
5.4 網絡通信
(1) ACE
參考網站：http://www.cs.wustl.edu/~schmidt/ACE.html
C++庫的代表，超重量級的網絡通信開發框架。ACE自適配通信環境（Adaptive
Communication Environment）是可以自由使用、開放源代碼的面向對象框架，在
其中實現了許多用于并發通信軟件的核心模式。ACE提供了一組豐富的可復用C++包
裝外觀（Wrapper Facade）和框架組件，可跨越多種平臺完成通用的通信軟件任務
，其中包括：事件多路分離和事件處理器分派、信號處理、服務初始化、進程間通
信、共享內存管理、消息路由、分布式服務動態（重）配置、并發執行和同步，等
等。
(2) StreamModule
參考網站：http://www.omnifarious.org/StrMod/
設計用于簡化編寫分布式程序的庫。嘗試著使得編寫處理異步行為的程序更容
易，而不是用同步的外殼包起異步的本質。
(3) SimpleSocket
參考網站：http://home.hetnet.nl/~lcbokkers/simsock.htm
這個類庫讓編寫基于socket的客戶/服務器程序更加容易。
(4) A Stream Socket API for C++
參考網站：http://www.pcs.cnu.edu/~dgame/sockets/socketsC++/sockets.h
tml
又一個對Socket的封裝庫。
5.5 XML
(1) Xerces
參考網站：http://xml.apache.org/xerces-c/
Xerces-C++ 是一個非常健壯的XML解析器，它提供了驗證，以及SAX和DOM API
。XML驗證在文檔類型定義(Document Type Definition，DTD)方面有很好的支持，
并且在2001年12月增加了支持W3C XML Schema 的基本完整的開放標準。
(2) XMLBooster
參考網站：http://www.xmlbooster.com/
這個庫通過產生特制的parser的辦法極大的提高了XML解析的速度，并且能夠產
生相應的GUI程序來修改這個parser。在DOM和SAX兩大主流XML解析辦法之外提供了
另外一個可行的解決方案。
(3) Pull Parser
參考網站：http://www.extreme.indiana.edu/xgws/xsoap/xpp/
這個庫采用pull方法的parser。在每個SAX的parser底層都有一個pull的parse
r，這個xpp把這層暴露出來直接給大家使用。在要充分考慮速度的時候值得嘗試。
(4) Xalan
參考網站：http://xml.apache.org/xalan-c/
Xalan是一個用于把XML文檔轉換為HTML，純文本或者其他XML類型文檔的XSLT處
理器。
(5) CMarkup
參考網站：http://www.firstobject.com/xml.htm
這是一種使用EDOM的XML解析器。在很多思路上面非常靈活實用。值得大家在D
OM和SAX之外尋求一點靈感。
(6) libxml++
http://libxmlplusplus.sourceforge.net/
libxml++是對著名的libxml XML解析器的C++封裝版本
5.6 科學計算
(1) Blitz++
參考網站：http://www.oonumerics.org/blitz/
Blitz++ 是一個高效率的數值計算函數庫，它的設計目的是希望建立一套既具
像C++ 一樣方便，同時又比Fortran速度更快的數值計算環境。通常，用C++所寫出
的數值程序，比 Fortran慢20%左右，因此Blitz++正是要改掉這個缺點。方法是利
用C++的template技術，程序執行甚至可以比Fortran更快。Blitz++目前仍在發展中
，對于常見的SVD，FFTs，QMRES等常見的線性代數方法并不提供，不過使用者可以
很容易地利用Blitz++所提供的函數來構建。
(2) POOMA
參考網站：http://www.codesourcery.com/pooma/pooma
POOMA是一個免費的高性能的C++庫，用于處理并行式科學計算。POOMA的面向對
象設計方便了快速的程序開發，對并行機器進行了優化以達到最高的效率，方便在
工業和研究環境中使用。
(3) MTL
參考網站：http://www.osl.iu.edu/research/mtl/
Matrix Template Library(MTL)是一個高性能的泛型組件庫，提供了各種格式
矩陣的大量線性代數方面的功能。在某些應用使用高性能編譯器的情況下，比如In
tel的編譯器，從產生的匯編代碼可以看出其與手寫幾乎沒有兩樣的效能。
(4) CGAL
參考網站：http://www.cgal.org/
Computational Geometry Algorithms Library的目的是把在計算幾何方面的大
部分重要的解決方案和方法以C++庫的形式提供給工業和學術界的用戶。
5.7 游戲開發
(1) Audio/Video 3D C++ Programming Library
參考網站：http://www.galacticasoftware.com/products/av/
AV3D是一個跨平臺，高性能的C++庫。主要的特性是提供3D圖形，聲效支持（S
B,以及S3M），控制接口（鍵盤，鼠標和遙感），XMS。
(2) KlayGE
參考網站：http://home.g365.net/enginedev/
國內游戲開發高手自己用C++開發的游戲引擎。KlayGE是一個開放源代碼、跨平
臺的游戲引擎，并使用Python作腳本語言。KlayGE在LGPL協議下發行。感謝龔敏敏
先生為中國游戲開發事業所做出的貢獻。
(3) OGRE
參考網站：http://www.ogre3d.org/
OGRE（面向對象的圖形渲染引擎）是用C++開發的，使用靈活的面向對象3D引擎
。它的目的是讓開發者能更方便和直接地開發基于3D硬件設備的應用程序或游戲。
引擎中的類庫對更底層的系統庫（如：Direct3D和OpenGL）的全部使用細節進行了
抽象，并提供了基于現實世界對象的接口和其它類。
5.8 線程
(1) C++ Threads
參考網站：http://threads.sourceforge.net/
這個庫的目標是給程序員提供易于使用的類，這些類被繼承以提供在Linux環境
中很難看到的大量的線程方面的功能。
(2) ZThreads
參考網站：http://zthread.sourceforge.net/
一個先進的面向對象，跨平臺的C++線程和同步庫。
5.9 序列化
(1) s11n
參考網站：http://s11n.net/
一個基于STL的C++庫，用于序列化POD，STL容器以及用戶定義的類型。
(2) Simple XML Persistence Library
參考網站：http://sxp.sourceforge.net/
這是一個把對象序列化為XML的輕量級的C++庫。
5.10 字符串
(1) C++ Str Library
參考網站：http://www.utilitycode.com/str/
操作字符串和字符的庫，支持Windows和支持gcc的多種平臺。提供高度優化的
代碼，并且支持多線程環境和Unicode，同時還有正則表達式的支持。
(2) Common Text Transformation Library
參考網站：http://cttl.sourceforge.net/
這是一個解析和修改STL字符串的庫。CTTL substring類可以用來比較，插入，
替換以及用EBNF的語法進行解析。
(3) GRETA
參考網站：http://research.microsoft.com/projects/greta/
這是由微軟研究院的研究人員開發的處理正則表達式的庫。在小型匹配的情況
下有非常優秀的表現。
5.11 綜合
(1) P::Classes
參考網站：http://pclasses.com/
一個高度可移植的C++應用程序框架。當前關注類型和線程安全的signal/slot
機制，i/o系統包括基于插件的網絡協議透明的i/o架構，基于插件的應用程序消息
日志框架，訪問sql數據庫的類等等。
(2) ACDK - Artefaktur Component Development Kit
參考網站：http://acdk.sourceforge.net/
這是一個平臺無關的C++組件框架，類似于Java或者.NET中的框架（反射機制，
線程，Unicode，廢料收集，I/O，網絡，實用工具，XML，等等），以及對Java, P
erl, Python, TCL, Lisp, COM 和 CORBA的集成。
(3) dlib C++ library
參考網站：http://www.cis.ohio-state.edu/~kingd/dlib/
各種各樣的類的一個綜合。大整數，Socket，線程，GUI，容器類,以及瀏覽目
錄的API等等。
(4) Chilkat C++ Libraries
參考網站：http://www.chilkatsoft.com/cpp_libraries.asp
這是提供zip，e-mail，編碼，S/MIME，XML等方面的庫。
(5) C++ Portable Types Library (PTypes)
參考網站：http://www.melikyan.com/ptypes/
這是STL的比較簡單的替代品，以及可移植的多線程和網絡庫。
(6) LFC
參考網站：http://lfc.sourceforge.net/
哦，這又是一個嘗試提供一切的C++庫
5.12 其他庫
(1) Loki
參考網站：http://www.moderncppdesign.com/
哦，你可能抱怨我早該和Boost一起介紹它，一個實驗性質的庫。作者在loki中
把C++模板的功能發揮到了極致。并且嘗試把類似設計模式這樣思想層面的東西通過
庫來提供。同時還提供了智能指針這樣比較實用的功能。
(2) ATL
ATL(Active Template Library)
是一組小巧、高效、靈活的類，這些類為創建可互操作的COM組件提供了基本的
設施。
(3) FC++: The Functional C++ Library
這個庫提供了一些函數式語言中才有的要素。屬于用庫來擴充語言的一個代表
作。如果想要在OOP之外尋找另一分的樂趣，可以去看看函數式程序設計的世界。大
師Peter Norvig在 “Teach Yourself Programming in Ten Years”一文中就將函
數式語言列為至少應當學習的6類編程語言之一。
(4) FACT!
參考網站：http://www.kfa-juelich.de/zam/FACT/start/index.html
另外一個實現函數式語言特性的庫
(5) Crypto++
提供處理密碼，消息驗證，單向hash，公匙加密系統等功能的免費庫。
還有很多非常激動人心或者是極其實用的C++庫，限于我們的水平以及文章的篇
幅不能包括進來。在對于這些已經包含近來的庫的介紹中，由于并不是每一個我們
都使用過，所以難免有偏頗之處，請讀者見諒。
malloc（）是C語言中動態存儲管理的一組標準庫函數之一。其作用是在內存的動態存儲區中分配一個長度為size的連續空間。其參數是一個無符號整形數，返回值是一個指向所分配的連續存儲域的起始地址的指針。
動態內存分配就是指在程序執行的過程中動態地分配或者回收存儲空間的分配內存的方法。動態內存分配不像數組等靜態內存分配方法那樣需要預先分配存儲空間，而是由系統根據程序的需要即時分配，且分配的大小就是程序要求的大小。本文簡單介紹動態內存分配函數malloc（）及幾種實現方法。
1． 簡介
malloc（）是C語言中動態存儲管理的一組標準庫函數之一。其作用是在內存的動態存儲區中分配一個長度為size的連續空間。其參數是一個無符號整形數，返回值是一個指向所分配的連續存儲域的起始地址的指針。還有一點必須注意的是，當函數未能成功分配存儲空間（如內存不足）就會返回一個NULL指針。所以在調用該函數時應該檢測返回值是否為NULL并執行相應的操作。
2． 函數說明
C語言的動態存儲管理由一組標準庫函數實現，其原型在標準文件<stdlib.h>里描述，需要用這些功能時應包含這個文件。與動態存儲分配有關的函數共有四個，其中就包括存儲分配函數malloc（）。函數原型是：void *malloc (size_t n);這里的size_t是標準庫里定義的一個類型，它是一個無符號整型。這個整型能夠滿足所有對存儲塊大小描述的需要，具體相當于哪個整型由具體的C系統確定。malloc的返回值為(void *)類型（這是通用指針的一個重要用途），它分配一片能存放大小為n的數據的存儲塊，返回對應的指針值；如果不能滿足申請（找不到能滿足要求的存儲塊）就返回NULL。在使用時，應該把malloc的返回值轉換到特定指針類型，賦給一個指針。
注意，雖然這里的存儲塊是通過動態分配得到的，但是它的大小也是確定的，同樣不允許越界使用。例如上面程序段分配的塊里能存n個雙精度數據，隨后的使用就必須在這個范圍內進行。越界使用動態分配的存儲塊，尤其是越界賦值，可能引起非常嚴重的后果，通常會破壞程序的運行系統，可能造成本程序或者整個計算機系統垮臺。
下例是一個動態分配的例子：
#include <stdlib.h>
main()
{
int count,*array; /*count是一個計數器，array是一個整型指針，也可以理解為指向一個整型數組的首地址*/
if((array(int *) malloc (10*sizeof(int)))==NULL)
{
printf("不能成功分配存儲空間。");
exit(1);
}
for (count=0;count〈10;count++) /*給數組賦值*/
array[count]=count;
for(count=0;count〈10;count++) /*打印數組元素*/
printf("%2d",array[count]);
}
上例中動態分配了10個整型存儲區域，然后進行賦值并打印。例中if((array(int *) malloc (10*sizeof(int)))==NULL)語句可以分為以下幾步：
1）分配10個整型的連續存儲空間，并返回一個指向其起始地址的整型指針
2）把此整型指針地址賦給array
3）檢測返回值是否為NULL
3． malloc（）工作機制
malloc函數的實質體現在，它有一個將可用的內存塊連接為一個長長的列表的所謂空閑鏈表。調用malloc函數時，它沿連接表尋找一個大到足以滿足用戶請求所需要的內存塊。然后，將該內存塊一分為二（一塊的大小與用戶請求的大小相等，另一塊的大小就是剩下的字節）。接下來，將分配給用戶的那塊內存傳給用戶，并將剩下的那塊（如果有的話）返回到連接表上。調用free函數時，它將用戶釋放的內存塊連接到空閑鏈上。到最后，空閑鏈會被切成很多的小內存片段，如果這時用戶申請一個大的內存片段，那么空閑鏈上可能沒有可以滿足用戶要求的片段了。于是，malloc函數請求延時，并開始在空閑鏈上翻箱倒柜地檢查各內存片段，對它們進行整理，將相鄰的小空閑塊合并成較大的內存塊。
4． malloc（）在操作系統中的實現
在 C 程序中，多次使用malloc () 和 free()。不過，您可能沒有用一些時間去思考它們在您的操作系統中是如何實現的。本節將向您展示 malloc 和 free 的一個最簡化實現的代碼，來幫助說明管理內存時都涉及到了哪些事情。
在大部分操作系統中，內存分配由以下兩個簡單的函數來處理：
void *malloc (long numbytes)：該函數負責分配 numbytes 大小的內存，并返回指向第一個字節的指針。
void free(void *firstbyte)：如果給定一個由先前的 malloc 返回的指針，那么該函數會將分配的空間歸還給進程的“空閑空間”。
malloc_init 將是初始化內存分配程序的函數。它要完成以下三件事：將分配程序標識為已經初始化，找到系統中最后一個有效內存地址，然后建立起指向我們管理的內存的指針。這三個變量都是全局變量：
清單 1. 我們的簡單分配程序的全局變量
int has_initialized = 0;
void *managed_memory_start;
void *last_valid_address;
如前所述，被映射的內存的邊界（最后一個有效地址）常被稱為系統中斷點或者 當前中斷點。在很多 UNIX? 系統中，為了指出當前系統中斷點，必須使用 sbrk(0) 函數。 sbrk 根據參數中給出的字節數移動當前系統中斷點，然后返回新的系統中斷點。使用參數 0 只是返回當前中斷點。這里是我們的 malloc 初始化代碼，它將找到當前中斷點并初始化我們的變量：
清單 2. 分配程序初始化函數
/* Include the sbrk function */
#include
void malloc_init()
{
/* grab the last valid address from the OS */
last_valid_address = sbrk(0);
/* we don't have any memory to manage yet, so
*just set the beginning to be last_valid_address
*/
managed_memory_start = last_valid_address;
/* Okay, we're initialized and ready to go */
has_initialized = 1;
}
現在，為了完全地管理內存，我們需要能夠追蹤要分配和回收哪些內存。在對內存塊進行了 free 調用之后，我們需要做的是諸如將它們標記為未被使用的等事情，并且，在調用 malloc 時，我們要能夠定位未被使用的內存塊。因此， malloc 返回的每塊內存的起始處首先要有這個結構：
清單 3. 內存控制塊結構定義
struct mem_control_block {
int is_available;
int size;
};
現在，您可能會認為當程序調用 malloc 時這會引發問題 —— 它們如何知道這個結構？答案是它們不必知道；在返回指針之前，我們會將其移動到這個結構之后，把它隱藏起來。這使得返回的指針指向沒有用于任何其他用途的內存。那樣，從調用程序的角度來看，它們所得到的全部是空閑的、開放的內存。然后，當通過 free() 將該指針傳遞回來時，我們只需要倒退幾個內存字節就可以再次找到這個結構。
在討論分配內存之前，我們將先討論釋放，因為它更簡單。為了釋放內存，我們必須要做的惟一一件事情就是，獲得我們給出的指針，回退 sizeof(struct mem_control_block) 個字節，并將其標記為可用的。這里是對應的代碼：
清單 4. 解除分配函數
void free(void *firstbyte) {
struct mem_control_block *mcb;
/* Backup from the given pointer to find the
* mem_control_block
*/
mcb = firstbyte - sizeof(struct mem_control_block);
/* Mark the block as being available */
mcb->is_available = 1;
/* That's It! We're done. */
return;
}
如您所見，在這個分配程序中，內存的釋放使用了一個非常簡單的機制，在固定時間內完成內存釋放。分配內存稍微困難一些。以下是該算法的略述：
清單 5. 主分配程序的偽代碼
1. If our allocator has not been initialized, initialize it.
2. Add sizeof(struct mem_control_block) to the size requested.
3. start at managed_memory_start.
4. Are we at last_valid address?
5. If we are:
A. We didn't find any existing space that was large enough
-- ask the operating system for more and return that.
6. Otherwise:
A. Is the current space available (check is_available from
the mem_control_block)?
B. If it is:
i) Is it large enough (check "size" from the
mem_control_block)?
ii) If so:
a. Mark it as unavailable
b. Move past mem_control_block and return the
pointer
iii) Otherwise:
a. Move forward "size" bytes
b. Go back go step 4
C. Otherwise:
i) Move forward "size" bytes
ii) Go back to step 4
我們主要使用連接的指針遍歷內存來尋找開放的內存塊。這里是代碼：
清單 6. 主分配程序
void *malloc(long numbytes) {
/* Holds where we are looking in memory */
void *current_location;
/* This is the same as current_location, but cast to a
* memory_control_block
*/
struct mem_control_block *current_location_mcb;
/* This is the memory location we will return. It will
* be set to 0 until we find something suitable
*/
void *memory_location;
/* Initialize if we haven't already done so */
if(! has_initialized) {
malloc_init();
}
/* The memory we search for has to include the memory
* control block, but the users of malloc don't need
* to know this, so we'll just add it in for them.
*/
numbytes = numbytes + sizeof(struct mem_control_block);
/* Set memory_location to 0 until we find a suitable
* location
*/
memory_location = 0;
/* Begin searching at the start of managed memory */
current_location = managed_memory_start;
/* Keep going until we have searched all allocated space */
while(current_location != last_valid_address)
{
/* current_location and current_location_mcb point
* to the same address. However, current_location_mcb
* is of the correct type, so we can use it as a struct.
* current_location is a void pointer so we can use it
* to calculate addresses.
*/
current_location_mcb =
(struct mem_control_block *)current_location;
if(current_location_mcb->is_available)
{
if(current_location_mcb->size >= numbytes)
{
/* Woohoo! We've found an open,
* appropriately-size location.
*/
/* It is no longer available */
current_location_mcb->is_available = 0;
/* We own it */
memory_location = current_location;
/* Leave the loop */
break;
}
}
/* If we made it here, it's because the Current memory
* block not suitable; move to the next one
*/
current_location = current_location +
current_location_mcb->size;
}
/* If we still don't have a valid location, we'll
* have to ask the operating system for more memory
*/
if(! memory_location)
{
/* Move the program break numbytes further */
sbrk(numbytes);
/* The new memory will be where the last valid
* address left off
*/
memory_location = last_valid_address;
/* We'll move the last valid address forward
* numbytes
*/
last_valid_address = last_valid_address + numbytes;
/* We need to initialize the mem_control_block */
current_location_mcb = memory_location;
current_location_mcb->is_available = 0;
current_location_mcb->size = numbytes;
}
/* Now, no matter what (well, except for error conditions),
* memory_location has the address of the memory, including
* the mem_control_block
*/
/* Move the pointer past the mem_control_block */
memory_location = memory_location + sizeof(struct mem_control_block);
/* Return the pointer */
return memory_location;
}
這就是我們的內存管理器。現在，我們只需要構建它，并在程序中使用它即可。
5． malloc（）的其他實現
malloc() 的實現有很多，這些實現各有優點與缺點。在設計一個分配程序時，要面臨許多需要折衷的選擇，其中包括：
分配的速度。
回收的速度。
有線程的環境的行為。
內存將要被用光時的行為。
局部緩存。
簿記（Bookkeeping）內存開銷。
虛擬內存環境中的行為。
小的或者大的對象。
實時保證。
每一個實現都有其自身的優缺點集合。在我們的簡單的分配程序中，分配非常慢，而回收非常快。另外，由于它在使用虛擬內存系統方面較差，所以它最適于處理大的對象。
還有其他許多分配程序可以使用。其中包括：
Doug Lea Malloc：Doug Lea Malloc 實際上是完整的一組分配程序，其中包括 Doug Lea 的原始分配程序，GNU libc 分配程序和 ptmalloc。 Doug Lea 的分配程序有著與我們的版本非常類似的基本結構，但是它加入了索引，這使得搜索速度更快，并且可以將多個沒有被使用的塊組合為一個大的塊。它還支持緩存，以便更快地再次使用最近釋放的內存。 ptmalloc 是 Doug Lea Malloc 的一個擴展版本，支持多線程。在本文后面的 參考資料部分中，有一篇描述 Doug Lea 的 Malloc 實現的文章。
BSD Malloc：BSD Malloc 是隨 4.2 BSD 發行的實現，包含在 FreeBSD 之中，這個分配程序可以從預先確實大小的對象構成的池中分配對象。它有一些用于對象大小的 size 類，這些對象的大小為 2 的若干次冪減去某一常數。所以，如果您請求給定大小的一個對象，它就簡單地分配一個與之匹配的 size 類。這樣就提供了一個快速的實現，但是可能會浪費內存。在 參考資料部分中，有一篇描述該實現的文章。
Hoard：編寫 Hoard 的目標是使內存分配在多線程環境中進行得非常快。因此，它的構造以鎖的使用為中心，從而使所有進程不必等待分配內存。它可以顯著地加快那些進行很多分配和回收的多線程進程的速度。在 參考資料部分中，有一篇描述該實現的文章。
眾多可用的分配程序中最有名的就是上述這些分配程序。如果您的程序有特別的分配需求，那么您可能更愿意編寫一個定制的能匹配您的程序內存分配方式的分配程序。不過，如果不熟悉分配程序的設計，那么定制分配程序通常會帶來比它們解決的問題更多的問題。
6． 結束語
前面已經提過，多次調用malloc（）后空閑內存被切成很多的小內存片段，這就使得用戶在申請內存使用時，由于找不到足夠大的內存空間，malloc（）需要進行內存整理，使得函數的性能越來越低。聰明的程序員通過總是分配大小為2的冪的內存塊，而最大限度地降低潛在的malloc性能喪失。也就是說，所分配的內存塊大小為4字節、8字節、16字節、18446744073709551616字節，等等。這樣做最大限度地減少了進入空閑鏈的怪異片段（各種尺寸的小片段都有）的數量。盡管看起來這好像浪費了空間，但也容易看出浪費的空間永遠不會超過50%。
參考文獻：
[1] Jonathan Bartlett，內存管理內幕. developerWorks 中國，2004年11月