進程通信

Win32應用程序中進程間通信方法分析與比較

posted @ 2009-10-23 09:01 深邃者 閱讀(219) | 評論 (0) | 編輯 收藏

vs2005 調試

1，斷點設置有技巧：

1）設置條件斷點，比如i==10,變量改變時斷點；

2）如何讓斷點在指定的命中次數或者大于某個次數時觸發呢?方法是設定幾個斷點的HitCount,右鍵單擊斷點,在彈出菜單中選擇Hit Count；

3）When Hit,這個選項可以讓我們在命中斷點后做一些事情,包括輸出一些內容,或者調用宏,比如輸出一個程序中變量的值；

4）利用斷點的Filter功能,比如我希望斷點只有被機器名為yizhu的機器訪問才能觸發；

具體參見：一篇介紹VS2005調試斷點技巧的文章

2. 怎樣判斷加載的dll的正確性？

   調試時，打開Debug->Window->Modules，在窗口中顯示的就是當前進程加載的所有dll及其詳細信息，如果

斷點無法擊中，可以檢查這里，看是否有匹配的pdb文件或者是加載了錯誤的dll

3. 已經開始調試的工程加入另外的進程并且調試

   如果你在調試客戶端，但是服務器需要調試，那么使用菜單中的Tools-> Attach to process進行進程掛接，這種方法可以掛接所有windows下的程序，能否調試，就看其是否調試版和有調試用的PDB文件

4. 同時啟動多進程進行調試

  在Solution的屬性中的Common Properties->Startup Project。選擇Multiple startup projects。這個選項是可以記憶的，下次打開可以直接調試，非常方便

5.調試Windows Service

 MSDN推薦的方法
1、調試windows服務的初始化、啟動
　　另寫一個程序控制服務的初始化和啟動
　　注意：OnStart里寫Log, OnStart里要在30秒返回. 不然啟動就失敗了! 所以OnStart里不要放太多代碼! 可以用異步或線程.
2、調試windows服務的其他方面
1 ) 安裝您的服務 : intallutils xx.exe
2) 可從“服務控制管理器”、“服務器資源管理器”或代碼啟動服務
3) vs: 設置相關斷點，啟動調試，再在工具欄中選擇 調試->附加到進程..., 選擇您的服務, 確定。
3、trace方法
1）添加調試方法

private static void DebugRun(string[] args)

2）改寫程序入口為如下：

public static void Main(string[] args)
{
#if DEBUG
DebugRun(args);
#else
/*
初始化服務
*/
#endif
}

3）加入2種調試代碼

EventLog.WriteEntry("...");
System.Diagnostics.Debug.WriteLine("...");

6，遠程調試技術

    顧名思義，就是要調試的程序和調試器本身并不在一臺機器上。由于虛擬機技術的盛行，在虛擬機里面運行待調試的程序，而在外面運行調試器，也是一種比較流行的做法。

1 為什么使用遠程調試
   遠程調試有如下好處：
    a. 能讓產品運行在一個比較干凈的環境。有的時候如果產品安裝在一個裝好集成環境的機器上，某些bug并不能顯示出來。
    b. 易于部署調試環境。很多產品都非常復雜，比如很多都以service方式運行或者要load很復雜的resource，想在調試器里面直接按F5運行，越來越難。
    c. 對于游戲等全屏方式運行的程序，尤其有用。以前我對調試directx程序非常頭疼。

2 怎樣使用遠程調試
   使用vs2005進行遠程調試，詳細的介紹參考：http://support.microsoft.com/kb/910448

   簡單的來說，
   1)在被調試的機器上面運行Msvsmon.exe
   2)在調試機器上面運行vs2005,并attach到遠程機器的某個進程

3 注意事項

   a. 設置好正確的權限
   被調試機器和調試機器需要互相信任的權限(two-way)。如果兩臺機器在同一個workgroup，讓兩臺機器擁有一個相同的賬號和密碼，然后以這個賬號運行。如果兩臺機器在一個域里面，比較簡單，Msvsmon可以設置權限。如果一臺機器在domain里面，另外一臺不在，同樣是讓兩臺機器擁有一個相同的賬號和密碼，然后以這個賬號運行。
   對于Windows XP要特別注意一下，設置匿名的訪問權限才可以work , http://support.microsoft.com/kb/908099

   b.設置好symbol
   什么，你不知道什么是symbol？簡單的來說,symbol file(*.pdb) is for source-level debugging. VS2005就是靠它來調試exe的。默認情況下debug版本生成的，而release版本不生成pdb.設置好 [Project proerties]-[C/C++]-[Debug Information Format]-Program Database就可以了。
   為了減少symbol方面的麻煩，最簡單的做法是讓被調試機器上的binary版本和本地compile出來保持一致。

posted @ 2009-10-23 08:59 深邃者 閱讀(840) | 評論 (0) | 編輯 收藏

windbg調試器

WinDbg調試器

堆棧顯示指令 

k [b|p|P|v] 

在內核調試的時候,k命令用來顯示內核棧的內容 

先說說內核棧用來干嘛的 看了些資料個人理解是這樣的 

比如我們的代碼運行時,肯定會有函數函數然后還會調用函數 但是系統如何記錄是哪個父函數調用了這個子函數,在子函數調用之前整個狀態又是怎樣的,其實系統是利用了堆棧記錄的 棧這個東西好阿  先進后出  最近調用的函數記錄在最頂層 函數執行完后就從棧內彈出之前記錄的參數,如果調用函數 一樣的把函數壓進棧內就好了 這樣一來 一旦子函數執行完,從棧內彈出的第一個函數肯定是該子函數的老爹  我們可以看上層堆棧的狀態等等 功能大家慢慢去體會吧我也沒用過  呵呵  不好說什么 下面說些細節的東西 

b 

顯示傳給函數的前三個參數 

p 

顯示傳給函數的全部參數 

P( 大寫) 

跟上面那個一樣 只不過是顯示形式不同而已 

V 

外加顯示一些額外的信息 

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

u [f] 

反匯編指令,嘿嘿 超級有用的指令喲雖然說內核很多東西很復雜 認識偶爾小小反下也是可以的 

u 

反匯編當前寄存器指向的代碼 

uf 函數名(比如nt!ZwCreateFile) 

反匯編指定的函數 

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

t [r] 

單步跟蹤 

r 打開指顯示寄存器的詳細信息,狀態的開關(下面指令一樣有效,在用1次就會關閉哦~) 

ta 地址 

讓程序執行到指定地址 

tb 

讓程序運行到分支語句時停止 

tc 

讓程序運行到下一個函數調用停止 

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

p [r] 

單步執行一跳指令 

r 打開指顯示寄存器的詳細信息,狀態的開關(下面指令一樣有效,在用1次就會關閉哦~) 

pa 

讓程序執行到指定地址 

pc 

讓程序執行到函數調用就停止 

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

wt 

在想查看指定函數的信息而又不想單步通過該函數時很有用。可以到函數的起始地址并執行 wt 命令。(摘自翻譯文檔) 

這個感覺用處不是很大.不細細研究了 

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

Ps: 很多人不清楚到底p指令和t指令有什么區別 其實很簡單 p指令執行到函數時把這個當做一個指令來執行也就是說不會進入函數執行,但是t指令會進入到函數里面執行  就這么簡單~~呵呵

posted @ 2009-10-23 08:58 深邃者 閱讀(2051) | 評論 (0) | 編輯 收藏

#pragma 預處理指令詳解

#pragma 預處理指令詳解

posted @ 2009-10-23 08:56 深邃者 閱讀(104) | 評論 (0) | 編輯 收藏

c++內存布局

07年12月，我寫了一篇《C++虛函數表解析》的文章，引起了大家的興趣。有很多朋友對我的文章留了言，有鼓勵我的，有批評我的，還有很多問問題的。我在這里一并對大家的留言表示感謝。這也是我為什么再寫一篇續言的原因。因為，在上一篇文章中，我用了的示例都是非常簡單的，主要是為了說明一些機理上的問題，也是為了圖一些表達上方便和簡單。不想，這篇文章成為了打開C++對象模型內存布局的一個引子，引發了大家對C++對象的更深層次的討論。當然，我之前的文章還有很多方面沒有涉及，從我個人感覺下來，在談論虛函數表里，至少有以下這些內容沒有涉及：

1）有成員變量的情況。

2）有重復繼承的情況。

3）有虛擬繼承的情況。

4）有鉆石型虛擬繼承的情況。

這些都是我本篇文章需要向大家說明的東西。所以，這篇文章將會是《C++虛函數表解析》的一個續篇，也是一篇高級進階的文章。我希望大家在讀這篇文章之前對C++有一定的基礎和了解，并能先讀我的上一篇文章。因為這篇文章的深度可能會比較深，而且會比較雜亂，我希望你在讀本篇文章時不會有大腦思維紊亂導致大腦死機的情況。;-)

對象的影響因素

簡而言之，我們一個類可能會有如下的影響因素：

1）成員變量

2）虛函數（產生虛函數表）

3）單一繼承（只繼承于一個類）

4）多重繼承（繼承多個類）

5）重復繼承（繼承的多個父類中其父類有相同的超類）

6）虛擬繼承（使用virtual方式繼承，為了保證繼承后父類的內存布局只會存在一份）

上述的東西通常是C++這門語言在語義方面對對象內部的影響因素，當然，還會有編譯器的影響（比如優化），還有字節對齊的影響。在這里我們都不討論，我們只討論C++語言上的影響。

本篇文章著重討論下述幾個情況下的C++對象的內存布局情況。

1）單一的一般繼承（帶成員變量、虛函數、虛函數覆蓋）

2）單一的虛擬繼承（帶成員變量、虛函數、虛函數覆蓋）

3）多重繼承（帶成員變量、虛函數、虛函數覆蓋）

4）重復多重繼承（帶成員變量、虛函數、虛函數覆蓋）

5）鉆石型的虛擬多重繼承（帶成員變量、虛函數、虛函數覆蓋）

我們的目標就是，讓事情越來越復雜。

知識復習

我們簡單地復習一下，我們可以通過對象的地址來取得虛函數表的地址，如：

          typedef void(*Fun)(void);

            Base b;

            Fun pFun = NULL;

            cout << "虛函數表地址：" << (int*)(&b) << endl;

            cout << "虛函數表 — 第一個函數地址：" << (int*)*(int*)(&b) << endl;

            // Invoke the first virtual function 

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

            pFun();

我們同樣可以用這種方式來取得整個對象實例的內存布局。因為這些東西在內存中都是連續分布的，我們只需要使用適當的地址偏移量，我們就可以獲得整個內存對象的布局。

本篇文章中的例程或內存布局主要使用如下編譯器和系統：

1）Windows XP 和 VC++ 2003

2）Cygwin 和 G++ 3.4.4

單一的一般繼承

下面，我們假設有如下所示的一個繼承關系：

請注意，在這個繼承關系中，父類，子類，孫子類都有自己的一個成員變量。而了類覆蓋了父類的f()方法，孫子類覆蓋了子類的g_child()及其超類的f()。

我們的源程序如下所示：

class Parent {

public:

    int iparent;

    Parent ():iparent (10) {}

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

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

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

};

class Child : public Parent {

public:

    int ichild;

    Child():ichild(100) {}

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

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

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

};

class GrandChild : public Child{

public:

    int igrandchild;

    GrandChild():igrandchild(1000) {}

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

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

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

};

我們使用以下程序作為測試程序：（下面程序中，我使用了一個int** pVtab 來作為遍歷對象內存布局的指針，這樣，我就可以方便地像使用數組一樣來遍歷所有的成員包括其虛函數表了，在后面的程序中，我也是用這樣的方法的，請不必感到奇怪，）

    typedef void(*Fun)(void);

    GrandChild gc;

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

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

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

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

                cout << "    ["<<i<<"] ";

                pFun();

    }

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

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

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

其運行結果如下所示：（在VC++ 2003和G++ 3.4.4下）

使用圖片表示如下：

可見以下幾個方面：

1）虛函數表在最前面的位置。

2）成員變量根據其繼承和聲明順序依次放在后面。

3）在單一的繼承中，被overwrite的虛函數在虛函數表中得到了更新。

多重繼承

下面，再讓我們來看看多重繼承中的情況，假設有下面這樣一個類的繼承關系。注意：子類只overwrite了父類的f()函數，而還有一個是自己的函數（我們這樣做的目的是為了用g1()作為一個標記來標明子類的虛函數表）。而且每個類中都有一個自己的成員變量：

我們的類繼承的源代碼如下所示：父類的成員初始為10，20，30，子類的為100

class Base1 {

public:

    int ibase1;

    Base1():ibase1(10) {}

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

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

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

};

class Base2 {

public:

    int ibase2;

    Base2():ibase2(20) {}

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

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

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

};

class Base3 {

public:

    int ibase3;

    Base3():ibase3(30) {}

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

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

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

};

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

public:

    int iderive;

    Derive():iderive(100) {}

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

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

};

我們通過下面的程序來查看子類實例的內存布局：下面程序中，注意我使用了一個s變量，其中用到了sizof(Base)來找下一個類的偏移量。（因為我聲明的是int成員，所以是4個字節，所以沒有對齊問題。關于內存的對齊問題，大家可以自行試驗，我在這里就不多說了）

             typedef void(*Fun)(void);

               Derive d;

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

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

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

                cout << "     [0] ";

                pFun();

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

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

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

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

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

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

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

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

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

                int s = sizeof(Base1)/4;

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

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

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

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

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

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

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

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

                out << "     [3] ";

                cout<<pFun<<endl;

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

                s = s + sizeof(Base2)/4;

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

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

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

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

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

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

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

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

                 cout << "     [3] ";

                cout<<pFun<<endl;

                s++;

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

                s++;

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

其運行結果如下所示：（在VC++ 2003和G++ 3.4.4下）

使用圖片表示是下面這個樣子：

我們可以看到：

1） 每個父類都有自己的虛表。

2） 子類的成員函數被放到了第一個父類的表中。

3） 內存布局中，其父類布局依次按聲明順序排列。

4） 每個父類的虛表中的f()函數都被overwrite成了子類的f()。這樣做就是為了解決不同的父類類型的指針指向同一個子類實例，而能夠調用到實際的函數。

posted @ 2008-10-18 17:31 深邃者 閱讀(197) | 評論 (0) | 編輯 收藏

c++虛函數表解析

前言

C++中的虛函數的作用主要是實現了多態的機制。關于多態，簡而言之就是用父類型別的指針指向其子類的實例，然后通過父類的指針調用實際子類的成員函數。這種技術可以讓父類的指針有“多種形態”，這是一種泛型技術。所謂泛型技術，說白了就是試圖使用不變的代碼來實現可變的算法。比如：模板技術，RTTI技術，虛函數技術，要么是試圖做到在編譯時決議，要么試圖做到運行時決議。

關于虛函數的使用方法，我在這里不做過多的闡述。大家可以看看相關的C++的書籍。在這篇文章中，我只想從虛函數的實現機制上面為大家 一個清晰的剖析。

當然，相同的文章在網上也出現過一些了，但我總感覺這些文章不是很容易閱讀，大段大段的代碼，沒有圖片，沒有詳細的說明，沒有比較，沒有舉一反三。不利于學習和閱讀，所以這是我想寫下這篇文章的原因。也希望大家多給我提意見。

言歸正傳，讓我們一起進入虛函數的世界。

虛函數表

對C++ 了解的人都應該知道虛函數（Virtual Function）是通過一張虛函數表（Virtual Table）來實現的。簡稱為V-Table。在這個表中，主是要一個類的虛函數的地址表，這張表解決了繼承、覆蓋的問題，保證其容真實反應實際的函數。這樣，在有虛函數的類的實例中這個表被分配在了這個實例的內存中，所以，當我們用父類的指針來操作一個子類的時候，這張虛函數表就顯得由為重要了，它就像一個地圖一樣，指明了實際所應該調用的函數。

這里我們著重看一下這張虛函數表。C++的編譯器應該是保證虛函數表的指針存在于對象實例中最前面的位置（這是為了保證取到虛函數表的有最高的性能——如果有多層繼承或是多重繼承的情況下）。 這意味著我們通過對象實例的地址得到這張虛函數表，然后就可以遍歷其中函數指針，并調用相應的函數。

聽我扯了那么多，我可以感覺出來你現在可能比以前更加暈頭轉向了。 沒關系，下面就是實際的例子，相信聰明的你一看就明白了。

假設我們有這樣的一個類：

class Base {

     public:

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

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

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

};

按照上面的說法，我們可以通過Base的實例來得到虛函數表。 下面是實際例程：

          typedef void(*Fun)(void);

            Base b;

            Fun pFun = NULL;

            cout << "虛函數表地址：" << (int*)(&b) << endl;

            cout << "虛函數表 — 第一個函數地址：" << (int*)*(int*)(&b) << endl;

            // Invoke the first virtual function 

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

            pFun();

實際運行經果如下：(Windows XP+VS2003, Linux 2.6.22 + GCC 4.1.3)

虛函數表地址：0012FED4

虛函數表 — 第一個函數地址：0044F148

Base::f

通過這個示例，我們可以看到，我們可以通過強行把&b轉成int *，取得虛函數表的地址，然后，再次取址就可以得到第一個虛函數的地址了，也就是Base::f()，這在上面的程序中得到了驗證（把int* 強制轉成了函數指針）。通過這個示例，我們就可以知道如果要調用Base::g()和Base::h()，其代碼如下：

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

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

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

這個時候你應該懂了吧。什么？還是有點暈。也是，這樣的代碼看著太亂了。沒問題，讓我畫個圖解釋一下。如下所示：

注意：在上面這個圖中，我在虛函數表的最后多加了一個結點，這是虛函數表的結束結點，就像字符串的結束符“\0”一樣，其標志了虛函數表的結束。這個結束標志的值在不同的編譯器下是不同的。在WinXP+VS2003下，這個值是NULL。而在Ubuntu 7.10 + Linux 2.6.22 + GCC 4.1.3下，這個值是如果1，表示還有下一個虛函數表，如果值是0，表示是最后一個虛函數表。

下面，我將分別說明“無覆蓋”和“有覆蓋”時的虛函數表的樣子。沒有覆蓋父類的虛函數是毫無意義的。我之所以要講述沒有覆蓋的情況，主要目的是為了給一個對比。在比較之下，我們可以更加清楚地知道其內部的具體實現。

一般繼承（無虛函數覆蓋）

下面，再讓我們來看看繼承時的虛函數表是什么樣的。假設有如下所示的一個繼承關系：

請注意，在這個繼承關系中，子類沒有重載任何父類的函數。那么，在派生類的實例中，其虛函數表如下所示：

對于實例：Derive d; 的虛函數表如下：

我們可以看到下面幾點：

1）虛函數按照其聲明順序放于表中。

2）父類的虛函數在子類的虛函數前面。

我相信聰明的你一定可以參考前面的那個程序，來編寫一段程序來驗證。

一般繼承（有虛函數覆蓋）

覆蓋父類的虛函數是很顯然的事情，不然，虛函數就變得毫無意義。下面，我們來看一下，如果子類中有虛函數重載了父類的虛函數，會是一個什么樣子？假設，我們有下面這樣的一個繼承關系。

為了讓大家看到被繼承過后的效果，在這個類的設計中，我只覆蓋了父類的一個函數：f()。那么，對于派生類的實例，其虛函數表會是下面的一個樣子：

我們從表中可以看到下面幾點，

1）覆蓋的f()函數被放到了虛表中原來父類虛函數的位置。

2）沒有被覆蓋的函數依舊。

這樣，我們就可以看到對于下面這樣的程序，

            Base *b = new Derive();

            b->f();

由b所指的內存中的虛函數表的f()的位置已經被Derive::f()函數地址所取代，于是在實際調用發生時，是Derive::f()被調用了。這就實現了多態。

多重繼承（無虛函數覆蓋）

下面，再讓我們來看看多重繼承中的情況，假設有下面這樣一個類的繼承關系。注意：子類并沒有覆蓋父類的函數。

對于子類實例中的虛函數表，是下面這個樣子：

我們可以看到：

1） 每個父類都有自己的虛表。

2） 子類的成員函數被放到了第一個父類的表中。（所謂的第一個父類是按照聲明順序來判斷的）

這樣做就是為了解決不同的父類類型的指針指向同一個子類實例，而能夠調用到實際的函數。

多重繼承（有虛函數覆蓋）

下面我們再來看看，如果發生虛函數覆蓋的情況。

下圖中，我們在子類中覆蓋了父類的f()函數。

下面是對于子類實例中的虛函數表的圖：

我們可以看見，三個父類虛函數表中的f()的位置被替換成了子類的函數指針。這樣，我們就可以任一靜態類型的父類來指向子類，并調用子類的f()了。如：

            Derive d;

            Base1 *b1 = &d;

            Base2 *b2 = &d;

            Base3 *b3 = &d;

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

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

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

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

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

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

安全性

每次寫C++的文章，總免不了要批判一下C++。這篇文章也不例外。通過上面的講述，相信我們對虛函數表有一個比較細致的了解了。水可載舟，亦可覆舟。下面，讓我們來看看我們可以用虛函數表來干點什么壞事吧。

一、通過父類型的指針訪問子類自己的虛函數

我們知道，子類沒有重載父類的虛函數是一件毫無意義的事情。因為多態也是要基于函數重載的。雖然在上面的圖中我們可以看到Base1的虛表中有Derive的虛函數，但我們根本不可能使用下面的語句來調用子類的自有虛函數：

          Base1 *b1 = new Derive();

            b1->f1(); //編譯出錯

任何妄圖使用父類指針想調用子類中的未覆蓋父類的成員函數的行為都會被編譯器視為非法，所以，這樣的程序根本無法編譯通過。但在運行時，我們可以通過指針的方式訪問虛函數表來達到違反C++語義的行為。（關于這方面的嘗試，通過閱讀后面附錄的代碼，相信你可以做到這一點）

二、訪問non-public的虛函數

另外，如果父類的虛函數是private或是protected的，但這些非public的虛函數同樣會存在于虛函數表中，所以，我們同樣可以使用訪問虛函數表的方式來訪問這些non-public的虛函數，這是很容易做到的。

如：

class Base {

    private:

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

};

class Derive : public Base{

};

typedef void(*Fun)(void);

void main() {

    Derive d;

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

    pFun();

}

結束語

C++這門語言是一門Magic的語言，對于程序員來說，我們似乎永遠摸不清楚這門語言背著我們在干了什么。需要熟悉這門語言，我們就必需要了解C++里面的那些東西，需要去了解C++中那些危險的東西。不然，這是一種搬起石頭砸自己腳的編程語言。

在文章束之前還是介紹一下自己吧。我從事軟件研發有十個年頭了，目前是軟件開發技術主管，技術方面，主攻Unix/C/C++，比較喜歡網絡上的技術，比如分布式計算，網格計算，P2P，Ajax等一切和互聯網相關的東西。管理方面比較擅長于團隊建設，技術趨勢分析，項目管理。歡迎大家和我交流，我的MSN和Email是：haoel@hotmail.com 

附錄一：VC中查看虛函數表

我們可以在VC的IDE環境中的Debug狀態下展開類的實例就可以看到虛函數表了（并不是很完整的）

附錄 二：例程

下面是一個關于多重繼承的虛函數表訪問的例程：

#include <iostream>

using namespace std;

class Base1 {

public:

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

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

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

};

class Base2 {

public:

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

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

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

};

class Base3 {

public:

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

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

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

};

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

public:

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

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

};

typedef void(*Fun)(void);

int main()

{

            Fun pFun = NULL;

            Derive d;

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

            //Base1's vtable

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

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

            pFun();

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

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

            pFun();

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

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

            pFun();

            //Derive's vtable

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

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

            pFun();

            //The tail of the vtable

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

            cout<<pFun<<endl;

            //Base2's vtable

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

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

            pFun();

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

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

            pFun();

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

            pFun();

            //The tail of the vtable

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

            cout<<pFun<<endl;

            //Base3's vtable

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

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

            pFun();

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

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

            pFun();

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

            pFun();

            //The tail of the vtable

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

            cout<<pFun<<endl;

            return 0;

}

posted @ 2008-10-18 17:29 深邃者 閱讀(112) | 評論 (0) | 編輯 收藏

如何用 Win32 APIs 枚舉應用程序窗口和進程

如何用 Win32 APIs 枚舉應用程序窗口和進程

編譯：NorthTibet

下載源代碼

摘要

　　我們在編寫程序時，常常遇到的一件事情就是要準確列出系統中所有正在運行的程序或者進程。Windows 任務管理器就是這樣的一個程序。它既能列出運行的桌面應用程序，又能列出系統中所有運行的進程。那么，我們在程序中如何實現這樣的任務呢？本文下面將詳細討論這個問題。


枚舉頂層（top-level）窗口

　　枚舉桌面頂層窗口相對于枚舉進程來說可能要容易一些。枚舉桌面頂層窗口的方法是用 EnumWindows() 函數。不要用 GetWindow()來創建窗口列表，因為窗口之間復雜的父子及同胞關系（Z-Order）容易造成混亂而使得枚舉結果不準確。
　　EnumWindows()有兩個參數，一個是指向回調函數的指針，一個是用戶定義的 LPARAM 值， 針對每個桌面窗口（或者頂層窗口）它調用回調函數一次。然后回調函數用該窗口句柄做一些處理，比如將它添加到列表中。這個方法保證枚舉結果不會被窗口復雜的層次關系搞亂，因此，一旦有了窗口句柄，我們就可以通過 GetWindowText() 得到窗口標題。


枚舉進程

　　建立系統進程列表比枚舉窗口稍微復雜一些。這主要是因為所用的 API 函數對于不同的 Win32 操作系統有依賴性。在 Windows 9x、Windows Me、Windows 2000 Professional 以及 Windows XP 中，我們可以用 ToolHelp32 庫中的 APIs 函數。但是在 Windows NT 里，我們必須用 PSAPI 庫中的 APIs 函數， PSAPI 庫是 SDK 的一部分。本文我們將討論上述所有平臺中的實現。附帶的例子程序將對上述庫中的 APIs 進行包裝，以便包裝后的函數能支持所有 Win32 操作系統。


使用 ToolHelp32 庫枚舉進程

　　ToolHelp32 庫函數在 KERNEL32.dll 中，它們都是標準的 API 函數。但是 Windows NT 4.0 不提供這些函。
　　ToolHelp32 庫中有各種各樣的函數可以用來枚舉系統中的進程、線程以及獲取內存和模塊信息。其中枚舉進程 只需用如下三個的函數：CreateToolhelp32Snapshot()、Process32First()和 Process32Next()。
　　使用 ToolHelp32 函數的第一步是用 CreateToolhelp32Snapshot() 函數創建系統信息“快照”。這個函數可以讓你選擇存儲在快照中的信息類型。如果你只是對進程信息感興趣，那么只要包含 TH32CS_SNAPPROCESS 標志即可。 CreateToolhelp32Snapshot() 函數返回一個 HANDLE，完成調用之后，必須將此 HANDLE 傳給 CloseHandle()。
　　接下來是調用一次 Process32First 函數，從快照中獲取進程列表，然后重復調用 Process32Next，直到函數返回 FALSE 為止。這樣將遍歷快照中進程列表。這兩個函數都帶兩個參數，它們分別是快照句柄和一個   PROCESSENTRY32 結構。
　　調用完 Process32First 或 Process32Next 之后，PROCESSENTRY32 中將包含系統中某個進程的關鍵信息。其中進程 ID 就存儲在此結構的 th32ProcessID。此 ID 可以被傳給 OpenProcess() API 以獲得該進程的句柄。對應的可執行文件名及其存放路徑存放在 szExeFile  結構成員中。在該結構中還可以找到其它一些有用的信息。
　　注意：在調用 Process32First() 之前，一定要記住將 PROCESSENTRY32  結構的 dwSize 成員設置成 sizeof(PROCESSENTRY32)。


使用 PSAPI 庫枚舉進程

　　在 Windows NT 中，創建進程列表使用 PSAPI 函數，這些函數在 PSAPI.DLL 中。這個文件是隨 Platform SDK 一起分發的，最新版本的 Platform SDK 可以從這里下載：

使用這個庫所需的 PSAPI.h 和 PSAPI.lib 文件也在該 Platform SDK 中。
　　為了使用 PSAPI 庫中的函數，需將 PSAPI.lib 添加到代碼項目中，同時在所有調用 PSAPI API 的模塊中包含 PSAPI.h 文件。記住一定要隨可執行文件一起分發 PSAPI.DLL，因為它不隨 Windows NT 一起分發。你可以點擊這里單獨下載 PSAPI.DLL 的可分發版本（不用完全下載 Platform SDK）。
　　與 ToolHelp32 一樣，PSAPI 庫也包含各種各樣有用的函數。由于篇幅所限，本文只討論與枚舉進程有關函數：EnumProcesses()、 EnumProcessModules()、GetModuleFileNameEx()和 GetModuleBaseName()。
　　創建進程列表的第一步是調用 EnumProcesses()。該函數的聲明如下：

BOOL EnumProcesses( DWORD *lpidProcess, DWORD cb, DWORD *cbNeeded );

EnumProcessModules( hProcess, &hModule, sizeof(hModule), &cbReturned );

INT WINAPI VDMEnumTaskWOWEx( DWORD dwProcessId, TASKENUMPROCEX fp,LPARAM lparam );

　　此處 dwProcessId 是 NTVDM 中擬枚舉的16位任務進程標示符。參數 fp 是回調枚舉函數的指針。參數 lparam 是用戶定義的值，它被傳遞到枚舉函數。枚舉函數應該被定義成如下這樣：

BOOL WINAPI Enum16( DWORD dwThreadId, 
                    WORD hMod16, 
                    WORD hTask16, 
                    PSZ pszModName, 
                    PSZ pszFileName, 
                    LPARAM lpUserDefined );

BOOL WINAPI EnumProcs( PROCENUMPROC lpProc, LPARAM lParam );

使用該函數時，要象下面這樣聲明回調函數：

BOOL CALLBACK Proc( DWORD dw, WORD w16, LPCSTR lpstr, LPARAM lParam );

posted @ 2008-09-22 18:34 深邃者 閱讀(226) | 評論 (0) | 編輯 收藏

如何“干凈地”終止 Win32 中的應用程序

   //******************

   // 頭文件 TermApp.h

   //******************

   #include <windows.h>

   #define TA_FAILED 0

   #define TA_SUCCESS_CLEAN 1

   #define TA_SUCCESS_KILL 2

   #define TA_SUCCESS_16 3


   DWORD WINAPI TerminateApp( DWORD dwPID, DWORD dwTimeout ) ;

   DWORD WINAPI Terminate16App( DWORD dwPID, DWORD dwThread,

                        WORD w16Task, DWORD dwTimeout );



   //*********************

   // 實現代碼 TermApp.cpp

   //*********************

   #include "TermApp.h"

   #include <vdmdbg.h>

   typedef struct

   {

      DWORD   dwID ;

      DWORD   dwThread ;

   } TERMINFO ;

   // 聲明回調枚舉函數.

   BOOL CALLBACK TerminateAppEnum( HWND hwnd, LPARAM lParam ) ;

   BOOL CALLBACK Terminate16AppEnum( HWND hwnd, LPARAM lParam ) ;

   /*----------------------------------------------------------------

   DWORD WINAPI TerminateApp( DWORD dwPID, DWORD dwTimeout )

   功能:

      關閉 32-位進程(或  Windows 95 下的 16-位進程)

   參數:

      dwPID

         要關閉之進程的進程 ID.

      dwTimeout

         進程關閉前等待的毫秒時間.

   返回值:

      TA_FAILED —— 如果關閉失敗.

      TA_SUCCESS_CLEAN —— 如果使用 WM_CLOSE 關閉了進程.

      TA_SUCCESS_KILL —— 如果使用 TerminateProcess() 關閉了進程.

      返回值的定義參見頭文件.

   ----------------------------------------------------------------*/

   DWORD WINAPI TerminateApp( DWORD dwPID, DWORD dwTimeout )

   {

      HANDLE   hProc ;

      DWORD   dwRet ;

      // 如果無法用 PROCESS_TERMINATE 權限打開進程，那么立即放棄。

      hProc = OpenProcess(SYNCHRONIZE|PROCESS_TERMINATE, FALSE,dwPID);

      if(hProc == NULL)

      {
         return TA_FAILED ;
      }


      // TerminateAppEnum() 將 WM_CLOSE 消息發到所有其進程ID 與你所提供的進程ID 匹配的窗口.

      EnumWindows((WNDENUMPROC)TerminateAppEnum, (LPARAM) dwPID) ;


      // 等待處理，如果成功，OK。如果超時，則干掉它.

      if(WaitForSingleObject(hProc, dwTimeout)!=WAIT_OBJECT_0)

         dwRet=(TerminateProcess(hProc,0)?TA_SUCCESS_KILL:TA_FAILED);

      else

         dwRet = TA_SUCCESS_CLEAN ;

      CloseHandle(hProc) ;

      return dwRet ;

   }


   /*----------------------------------------------------------------

   DWORD WINAPI Terminate16App( DWORD dwPID, DWORD dwThread,

                        WORD w16Task, DWORD dwTimeout )

   功能:

      關閉 Win16 應用程序.

   參數:

      dwPID

         16-位程序運行其中的 NTVDM 進程 ID.

      dwThread

         16-位程序中執行線程的線程 ID.

      w16Task

         應用程序的 16-位任務句柄.

      dwTimeout

         任務關閉前等待的毫秒時間.



   返回值:

      如果成功, 返回 TA_SUCCESS_16

      如果不成功, 返回 TA_FAILED.      

       返回值的定義參見該函數的頭文件.

   注意:

      你可以通過 VDMEnumTaskWOW() 或 VDMEnumTaskWOWEx() 函數獲得 Win16 和線程 ID.

   ----------------------------------------------------------------*/

   DWORD WINAPI Terminate16App( DWORD dwPID, DWORD dwThread,

                        WORD w16Task, DWORD dwTimeout )

   {

      HINSTANCE      hInstLib ;

      TERMINFO      info ;

      // 你必須通過外部鏈接調用函數，以便代碼在所有  Win32 平臺上都兼容。

      BOOL (WINAPI *lpfVDMTerminateTaskWOW)(DWORD dwProcessId,WORD htask) ;

      hInstLib = LoadLibraryA( "VDMDBG.DLL" ) ;

      if( hInstLib == NULL )
         return TA_FAILED ;

      // 獲得函數過程地址.

      lpfVDMTerminateTaskWOW = (BOOL (WINAPI *)(DWORD, WORD ))

         GetProcAddress( hInstLib, "VDMTerminateTaskWOW" ) ;

      if( lpfVDMTerminateTaskWOW == NULL )

      {

         FreeLibrary( hInstLib ) ;

         return TA_FAILED ;

      }

      // 向所有匹配進程 ID 和線程的窗口發送 WM_CLOSE 消息.

      info.dwID = dwPID ;

      info.dwThread = dwThread ;

      EnumWindows((WNDENUMPROC)Terminate16AppEnum, (LPARAM) &info) ;

      // 等待.

      Sleep( dwTimeout ) ;

      // 然后終止.

      lpfVDMTerminateTaskWOW(dwPID, w16Task) ;

      FreeLibrary( hInstLib ) ;

      return TA_SUCCESS_16 ;

   }



   BOOL CALLBACK TerminateAppEnum( HWND hwnd, LPARAM lParam )

   {

      DWORD dwID ;

      GetWindowThreadProcessId(hwnd, &dwID) ;

      if(dwID == (DWORD)lParam)

      {

         PostMessage(hwnd, WM_CLOSE, 0, 0) ;

      }

      return TRUE ;
   }



   BOOL CALLBACK Terminate16AppEnum( HWND hwnd, LPARAM lParam )

   {

      DWORD      dwID ;

      DWORD      dwThread ;

      TERMINFO   *termInfo ;

      termInfo = (TERMINFO *)lParam ;

      dwThread = GetWindowThreadProcessId(hwnd, &dwID) ;

      if(dwID == termInfo->dwID && termInfo->dwThread == dwThread )

      {

         PostMessage(hwnd, WM_CLOSE, 0, 0) ;

      }

      return TRUE ;

   }

posted @ 2008-09-22 18:33 深邃者 閱讀(223) | 評論 (0) | 編輯 收藏

SQL

posted @ 2008-09-17 09:45 深邃者 閱讀(112) | 評論 (0) | 編輯 收藏

LIST控件

CListCtrl使用技巧

posted @ 2008-09-16 16:24 深邃者 閱讀(397) | 評論 (0) | 編輯 收藏