Lab 14-1: Generic Programming -
Template of Managed Pointer

    Fred.h
    #ifndef Fred_H
    #define Fred_H
    
    class Fred
    {
    public:
        Fred();
        ~Fred();
        void service();
    private:
        static int m_serialID;
        const int m_objectID;
    };
    
    #endif
    

    Fred.cpp
    #include "Fred.h"

    #include <iostream>
    using namespace std;
    
    int Fred::m_serialID = 0;
    
    Fred::Fred():m_objectID(m_serialID++)
    {
        cout << "Fred::ctor ID=" << m_objectID << endl; 
    }
    
    Fred::~Fred()
    {
        cout << "Fred::dtor ID=" << m_objectID << endl;
    }
    
    void Fred::service()
    {
        cout << "Fred::service() ID=" << m_objectID << endl; 
    }

下面的 FredPtr 類別我們稱為 Managed pointer, 基本上把一個 Fred 物件的指標包裝起來, 希望對於寫程式的人來說這個類別的物件的使用方法和 C/C++ 內建的 Fred 指標變數一模一樣, 但是額外增加了資源管理的功能, 在解構 FredPtr 物件時, 自動幫程式設計者刪除指標所指到的 Fred 物件。 有的時候寫程式的人動態地配置了一塊記憶體, 但是很容易忘記釋放它; 或是在運用 C++ Exception Handling 時, 由於 Exception 的發生, 執行時跳過了正常釋放的程式碼, 此時若是運用下面這個 FredPtr 類別就能夠自動地釋放所配置的記憶體:

    FredPtr.h
    #ifndef FredPtr_h
    #define Fredptr_h
    
    #include "Fred.h"
    
    class FredPtr
    {
    public:
        FredPtr(Fred* ptr=0);
        ~FredPtr();
        void deallocate();
        FredPtr& operator=(Fred* ptr);
        Fred* operator->();
        Fred& operator*();
        Fred* relinguishOwnership();
    private:
        Fred* m_ptr;
        FredPtr& operator=(const FredPtr &); // unimplemented
        FredPtr(const FredPtr &);            // unimplemented
    };
    
    #endif

    FredPtr.cpp
    #include "FredPtr.h"
    #include <assert.h>
    
    FredPtr::FredPtr(Fred* ptr)
        : m_ptr(ptr) 
    {
    }
    
    FredPtr::~FredPtr()
    {
        deallocate();
    }
    
    void FredPtr::deallocate()
    {
        delete m_ptr; 
        m_ptr = 0;
    }
    
    FredPtr& FredPtr::operator=(Fred* ptr)
    {
        deallocate();
        m_ptr = ptr;
        return *this;
    }
    
    Fred* FredPtr::operator->()
    {
        assert(m_ptr != 0);
        return m_ptr;
    }
    
    Fred& FredPtr::operator*()
    {
        assert(m_ptr != 0);
        return *m_ptr;
    }
    
    // 使得 FredPtr 物件不再擁有一 Fred 物件
    Fred* FredPtr::relinguishOwnership()
    {
        Fred* old = m_ptr;
        m_ptr = 0;
        return old;
    }

    TestFredPtr01.cpp
    #include "Fred.h"
    #include "FredPtr.h"
    #include <iostream>
    using namespace std;
    
    void main()
    {
        FredPtr ptrFred1, ptrFred2(new Fred);
        // ptrFred2 擁有一 Fred 物件 (ID=0)
    
        ptrFred1 = new Fred; // ptrFred1 擁有該 Fred 物件 (ID=1)
    
        ptrFred1 = 0; // 刪除該 Fred 物件 (ID=1)
    
        ptrFred2->service();
        (*ptrFred2).service();
    
        Fred *ptrFred;
        ptrFred = ptrFred2.relinguishOwnership();
        delete ptrFred;     // without this line, memory is
                            //  leaking 刪除 Fred 物件 (ID=0)
    }

執行結果範例:

    Fred::ctor ID=0
    Fred::ctor ID=1
    Fred::dtor ID=1
    Fred::service() ID=0
    Fred::service() ID=0
    Fred::dtor ID=0

我們先來嘗試製作這兩個成員函式, 首先是 assignment operator: FredPtr& operator=(const FredPtr&); 實作這個函式最主要的目的是使物件間可以用下列設定敘述來拷貝, 例如:

    FredPtr ptr1(new Fred), ptr2(new Fred);
    ...
    ptr1 = ptr2;

所以在這裡我們實作的時候乾脆拷貝一份, 各自管理自己的 Fred 物件 (請自己先實作看看):

    FredPtr& FredPtr::operator=(const FredPtr &rhs)
    {
        if (&rhs == this) return *this;
        deallocate();
        if (rhs.m_ptr)
            m_ptr = new Fred(*rhs.m_ptr);
        else
            m_ptr = 0;
        return *this;
    }

請把 assignment operator 設為 public 成員函式

接下來我們來考量拷貝建構元 (copy ctor), 這個成員函式最主要由一個已經建構好的 FredPtr 物件建構出一個新的物件, 因為需要擁有所管理的 Fred 物件, 所以在這個成員函式中也需要以原來的 FredPtr 物件所管理的 Fred 物件為範本, 建立一個新的 Fred 物件, (請自己先實作看看):

    FredPtr::FredPtr(const FredPtr &src)
    {
        if (src.m_ptr)
            m_ptr = new Fred(*src.m_ptr);
        else
            m_ptr = 0;
    }

請把拷貝建構元設為 public 成員函式

    #include "Fred.h"
    #include "FredPtr.h"
    #include <iostream>
    using namespace std;
    
    void main()
    {
        FredPtr ptrFred1, ptrFred2(new Fred);
        FredPtr ptrFred3(new Fred);
    
        ptrFred1 = new Fred;
        ptrFred1 = 0;
    
        ptrFred1 = new Fred;
        ptrFred1 = ptrFred3;
        
        FredPtr ptrFred4 = ptrFred1;
    
        ptrFred2->service();
        (*ptrFred2).service();
    
        Fred *ptrFred;
        ptrFred = ptrFred2.relinguishOwnership();
        delete ptrFred; // without this line, memory is leaking
    }

測試結果如下:

    Fred::ctor ID=0
    Fred::ctor ID=1
    Fred::ctor ID=2
    Fred::dtor ID=2
    Fred::ctor ID=3
    Fred::dtor ID=3
    Fred::copy ctor ID=4
    Fred::copy ctor ID=5
    Fred::service() ID=0
    Fred::service() ID=0
    Fred::dtor ID=0

      假設我們的程式裡有一個 Wilson 的類別, 我們也希望
      能夠像 FredPtr 一樣有一個 Managed Pointer 類別能夠 
      包裝 Wilson 物件的指標

這裡我們要運用樣板類別 (template class) 的語法, 修改步驟一、二中的 FredPtr 成為 HeapPtr 類別, 使得編譯器可以根據 HeapPtr 樣板自動幫我們產生新的 Managed Pointer 類別, 就好像我們之前使用 vector<int>, vector<Fred>, vector<double *> 一樣, 我們可以用 HeapPtr<Fred>, HeapPtr<Wilson>, HeapPtr<int>, 每次你做一個新的組合 HeapPtr<NewClass>, 編譯器就幫你合成一個新的 Managed Pointer 類別, 最主要的修改步驟如下:

1. 將類別名稱 FredPtr 改為 HeapPtr
2. 類別宣告前增加 template<class T>
3. 類別中使用到 Fred 類別的地方改為參數 T (也可以沿用 Fred, 在上一步就用 template<class Fred>, 比較不夠一般化就是了)
4. 將所有在 FredPtr.cpp 中定義的 FredPtr 類別成員函式都移到 HeapPtr.h 中
5. 每一個類別成員函式定義前增加 template<class T> , 函式裡使用到 Fred 的地方改成參數 T
6. 將 scope operator FredPtr:: 改為 HeapPtr<T>::
7. 將用到 FredPtr 型態的宣告改為 HeapPtr<T> (VC2010 並沒有要求把每一個 FredPtr 型態都改成 HeapPtr<T>, 也可以是 HeapPtr, 但是我不太確定規則!!! 你也可以在編譯器產生錯誤訊息時再改)

Wilson.h

#ifndef Wilson_H
#define Wilson_H

class Wilson
{
public:
    Wilson();
    Wilson(Wilson &);
    ~Wilson();
    void service();
private:
    static int m_serialID;
    const int m_objectID;
};

#endif

Wilson.cpp

#include "Wilson.h"

#include <iostream>
using namespace std;

int Wilson::m_serialID = 0;

Wilson::Wilson():m_objectID(m_serialID++)
{
    cout << "Wilson::ctor ID=" << m_objectID << endl; 
}

Wilson::~Wilson()
{
    cout << "Wilson::dtor ID=" << m_objectID << endl;
}

Wilson::Wilson(Wilson&):m_objectID(m_serialID++)
{
    cout << "Wilson::copy ctor ID=" << m_objectID << endl; 
}

void Wilson::service()
{
    cout << "Wilson::service() ID=" << m_objectID << endl; 
}

我們可以用下面的程式來測試一下上面的樣板類別

    #include "Fred.h"
    #include "Wilson.h"
    #include "HeapPtr.h"
    #include <iostream>
    using namespace std;

    void main()
    {
        HeapPtr<Fred> ptrFred1, ptrFred2(new Fred);
        HeapPtr<Fred> ptrFred3(new Fred);

        ptrFred1 = new Fred;
        ptrFred1 = 0;

        ptrFred1 = new Fred;
        ptrFred1 = ptrFred3;

        HeapPtr<Fred> ptrFred4 = ptrFred1;

        ptrFred2->service();
        (*ptrFred2).service();

        Fred *ptrFred;
        ptrFred = ptrFred2.relinguishOwnership();
        delete ptrFred; // without this line, memory is leaking

        HeapPtr<Wilson> ptrWilson(new Wilson);
        ptrWilson->service();

        HeapPtr<int> ptrIntAry(new int);
    }

測試結果如下:

    Fred::ctor ID=0
    Fred::ctor ID=1
    Fred::ctor ID=2
    Fred::dtor ID=2
    Fred::ctor ID=3
    Fred::dtor ID=3
    Fred::copy ctor ID=4
    Fred::copy ctor ID=5
    Fred::service() ID=0
    Fred::service() ID=0
    Fred::dtor ID=0
    Wilson::ctor ID=0
    Wilson::service() ID=0

你可以用 VC 中編譯的選項來看看編譯器自動產生的類別的程式碼,

• VC6: Project / Setting / C/C++ / Category: Listing Files / Listing File Type: Assembly With Source Code 或是
• VC2010: 專案 / xxx 屬性 / 組態屬性 / C/C++ / 輸出檔 / 組合語言輸出:有原始程式碼的組譯檔,

重新編譯, 檢視產生出來的組合語言檔案 *.asm, 你應該可以在 TestHeapPtr.asm 中找到編譯器針對 HeapPtr<Fred>, HeapPtr<Wilson>, 和 HeapPtr<int> 所產生的程式碼, 例如下面的組合語言函式是 HeapPtr<Wilson> 類別的解構元函式 ~HeapPtr<Wilson>()

    ; HeapPtr<Wilson>::~HeapPtr<Wilson>, COMDAT
    ??1?$HeapPtr@VWilson@@@@QAE@XZ PROC NEAR 
    ; Line 31
    	push	ebp
    	mov	ebp, esp
    	push	ecx
    	mov	DWORD PTR _this$[ebp], ecx
    ; Line 32
    	mov	ecx, DWORD PTR _this$[ebp]
        ; HeapPtr<Wilson>::deallocate
    	call	?deallocate@?$HeapPtr@VWilson@@@@QAEXXZ
    ; Line 33
    	mov	esp, ebp
    	pop	ebp
    	ret	0
    ??1?$HeapPtr@VWilson@@@@QAE@XZ ENDP
    ; HeapPtr<Wilson>::~HeapPtr<Wilson>

請注意: 對於 C++ 來說 template 是一個比較晚才加入的功能, 如果你在兩個模組 (.cpp) 中都使用到 vector<int>, 編譯器其實幫你產生了兩份 vector<int> 的類別, 低階的類別名稱一模一樣, 所以對於這兩個模組來說 vector<int> 是相同的型態, 比較特別的是這兩份的程式碼都給 linker 以後, linker 並不會說它們重複定義, 這兩個 vector<int> 會標示為 Weak symbols (local), 就好像連結 library 時, 如果有重複的函式 linker 也不會說重複定義, 以先找到的為準

//------ MyClass.h -----
class MyClass
{
public:
    MyClass(void);
    template <class T> void func(T x);
};

#include <iostream>
#include <iomanip>
template <class T> void MyClass::func(T x)
{
    std::cout << "in func(" << typeid(x).name() << "): "
              << x << std::endl;
}
//------ end of MyClass.h -----

這樣子的設計比較奇怪的地方是一個物件的介面是可以沒有限定個數的, 如果有兩個客戶都使用相同的 MyClass 類別的物件, 但是使用 x.func(r) 的時候, r 的型態不同, 此時兩個 MyClass 是相同的嗎? 請想辦法測試一下 (testTemplate1.rar), 詳細測試以後會發現 linker 能夠組合各個模組裡面重複的 MyClass::func(T), 如果 T 是相同的, 因為是 Weak symbol, 所以 linker 隨便挑選一份, 如果 T 不同, 則 linker 會統一組合成 MyClass

請參考 testTemplate.rar

請注意這個 testTemplate 專案你下載以後是沒有辦法直接建置成功的, 因為我故意把上面 void MyClass::func(T x){ ... }的定義放在 MyClass.cpp 裡, 請特別注意連結器的錯誤訊息, 請適當修改以後再測試

當 template <class T> void MyClass::func(T x) { ... }
沒有定義在 MyClass.h 檔案中時, 因為 main() 中使用 x.func(r) 和 x.func(s),
編譯器在編譯 main.cpp 時, 只看到 MyClass.h 裡面類別的宣告,
沒有看到你寫在 MyClass.cpp 裡的 template <class T> void MyClass::func(T x) { ... }
所以不會幫你產生 func<double>() 和 func<int>() 兩個成員函式, 因此
會出現下面兩個連結錯誤:

1> LINK : 最後的累加連結找不到或未建置 C:\user\pyting\testTemplate\Debug\testTemplate.exe，正在執行完整連結
1>main.obj : error LNK2019: 無法解析的外部符號 "public: void __thiscall MyClass::func<double>(double)" (??$func@N@MyClass@@QAEXN@Z) 在函式 _main 中被參考
1>main.obj : error LNK2019: 無法解析的外部符號 "public: void __thiscall MyClass::func<int>(int)" (??$func@H@MyClass@@QAEXH@Z) 在函式 _main 中被參考
1>C:\user\pyting\testTemplate\Debug\testTemplate.exe : fatal error LNK1120: 2 個無法解析的外部符號

不過 func<char *>(char *) 因為是在 MyClass() 函式中使用到的,
不管你 template <class T> void MyClass::func(T x)
是定義在 MyClass.h 或是 MyClass.cpp 中,
compiler 在編譯 MyClass.cpp 時是一定會產生的