第十節 組合與繼承

基於物件的三種常見關係：

• 繼承(Inheritance)
• 複合(Composition)
• 委託(Delegation)

Composition(複合)

Adapter模式

以Adapter(改造)模式為例。

template<class T>
class queue
{
    ...
    protected:
    deque<T> c;  //底層容器
    public:
    //一下完全利用c的操作函式完成
    bool empty()const{return c.empty();}
    size_type size()const{return c.size();}
    reference front(){return c.front();}
    reference back(){return c.back();}
    //
    void push(const value_type& x){c.push_back(x);}
    void pop(){c.pop_front();}
};

組合關係圖：

記憶體分佈：

sizeof:40

template<class T>
class queue
{
protected:
    deque<T> c;//40----->>
    ...
};

sizeof:16*2+4+4

template<class T>
class deque
{
protected:
    Itr<T> start;//16----->>
    Itr<T> finish;//16
    T** map;//4
    unsigned int map_size;//4
};

sizeof:4*4

template<class T>
struct Itr
{
    T* cur;//4
    T* first;//4
    T* last;//4
    T** node;//4
}

複合關係下的構造和析構

以Container和Component為例：

• 構造由內而外：Container::Container(...):Component(){...},先呼叫內部構造，再去做自己的事情。
• 析構由外而內:Container::_{Container(...):{...}Component"()},先把自己的事情做完，再呼叫內部析構。

Delegation(委託)

Delegation：Composition by reference.

即用指標實現組合。

Handle/Body(pImpl)模式：

class String
{
public:
    String();
    String(const char* s);
    String(const String& s);
    String &operator=(const String& s);
    ~String();
private:
    StringRep* rep;//pimpl 
};

#include"String.hpp"
namespace
{
class StringRep
{
    friend class String;
    StringRep(const char* s);
    ~StringRep();
    int count;//reference counting
    char* rep;//指向字串
};
String::String(){...}
}

委託關係圖:

String類提供對外介面，而內部StringRep提供具體實現，與組合用法類似，不同點是委託中兩者通過指標來連線，其中一點好處是隻有在使用時才會為右側分配記憶體，節省資源。

Handle/Body模式也叫編譯防火牆，使程式碼更有彈性，右側無論如何更改不會影響左側，更不會影響客戶端，實現了獨立。

reference counting:統計當前有多少份String指向StringRep(共享rep字串)。

copy on write:當其中一份String想修改rep時，為避免影響其他String讀取原rep，為其copy一份供其更改。

Inheritance(繼承)

示例程式碼：

struct _List_node_base
{
    _List_node_base* _N_next;
    _List_node_base* _M_prev;
};

template<typename _Tp>
struct _List_node
    :public _List_node_base
{
    _Tp _M_data;
};

繼承關係圖:

常用的繼承是公有繼承(public)，在公有繼承中基類的私有在子類中不可訪問，基類中的保護在子類中仍然是保護。因此，當我們想把資料封裝在當前類中不希望任何人（包括子類）訪問時可以將它設為私有，如果希望在子類中處理則設為保護。

繼承關係下的構造和析構

Derived作為Base的子類，包含Base，記憶體與程式碼兩個角度都是這樣。視Base為內部，Derived為外部。其構造與析構有以下關係：

• 構造由內而外：先呼叫內部的建構函式，再呼叫外部。
• 析構由外而內：先呼叫外部的建構函式，再呼叫內部。

示例如下：

另外，基類的析構必須是virtual，否則會出現undefined behavior的錯誤。

第十一節 虛擬函式與多型

Inheritance with virtual functions

• non-virtual函式：不希望derived class 重新定義(override)它。
• virtual函式：希望derived class重新定義，並且已經有預設定義。
• pure virtual函式：希望derived class一定要重新定義，且對它沒有預設定義。

Template Method模式

(MFC使用該模式)

//Application framework

CDocument::OnFileOpen()
{
    ...
    Serialize()
    ...
}
//該函式設計了一系列動作（用...表示）,
//其中一個動作（Serialize()）現在無法決定,
//可能要退後幾年去實現,
//則將他設計為虛擬函式。

class CMyDoc:public CDocument
{
    virtual Serialize(){...}
};

main()
 {
    CMyDoc myDoc;
    ...
    myDoc.OnFileOpen();
    //編譯器轉化為
    //CDocument::OnFileOpen(&myDoc)
    //&myDoc作為this指標傳入函式
 }

解析：在主函式中執行myDoc.OnFileOpen()，並將&myDoc作為this指標傳入基類的OnFileOpen()函式，當遇到虛擬函式時，根據this指標跳轉到相對應的子類中執行相對應的函式。

Template Method模式例項

#include<iostream>
using namespace std;

class CDocument
{
public:
    void OnFileOpen()
    {
        //這是個演算法，每個cout輸出代表一個實際動作
        cout<<"dialog..."<<endl;
        cout<<"check file status..."<<endl;
        cout<<"open file..."<<endl;
        Serialize();
        cout<<"close file..."<<endl;
        cout<<"updata all views..."<<endl;
    }
    virtual void Serialize(){};//可以定義為純虛擬函式
};

class CMyDoc:public CDocument
{
public:
    virtual void Serialize()
    {
        //只有應用程式本身才知道如何讀取自己的檔案(格式)
        cout<<"CMyDocheritance+Composition::Serialize()"<<endl;
    }
};

in main()
{
    CMyDoc myDoc;//假設對應[File/Open]
    myDoc.OnFileOpen();
}

Inheritance+Composition關係下的構造和析構

Derived包含其他兩類，所以Derived為外部，Base,Component為內部。

Component為內部，Base為Component的外部，Derived為Base的外部。

• 構造由內而外
• 析構由外而內

Inheritance+Delegation例項

Observer觀察者模式

class Subject//內容物
{
    int m_value;
    vector<Observer*>m_views;
 public:
    void attach(Observer* obs)//註冊觀察許可權，將觀察方式傳入
    {
        m_views.push_back(obs);
    }
    void set_val(int value)
    {
        m_value=value;
        notify();
    }
    void notify()//便利更新資料
    {
        for(int i=0;i<m_views.size();++i)
            m_views[i]->updata(this,m_value);
    }
};

class Observer
{
public:
    virtual void update()Subject* sub,int value)=0;    
};

Subject與Observer是委託的關係，Observer與其子類是繼承的關係。

這個例子也是聽得一頭霧水，慢慢消化吧。

今天就到這裡，晚安。

第十二節 委託相關設計

Composite模式

以檔案系統為例。

class Component//基類
{
    int value;
public:
    Component(int val){value=val;}
    virtual void add(Component*){}
};

class Primitive:public Component//檔案（基本單位）
{
public:
    Primitive(int val):Component(val){}
};

class Composite:public Component//目錄
{
    vector<Component*> c;
public:
    Composite(int val):Component(val){}
    void add(Comonent* elem)
    {
        c.push_back(elem);
    }
};

解析：Component類表示目錄類，Primitive表示檔案類，目錄中既可以包含檔案，也可以包含目錄自身，但目錄類中的向量只能儲存一種（相同的）資料型別，這時我們可以通過為檔案類與目錄類建立共同的基類來聯絡二者，並在目錄類中的向量中儲存指向基類的指標。

另外，關於add函式，因為需要在目錄類中重新定義，所以在基類中宣告為虛擬函式，在檔案類中定義空即可（因為檔案不能再新增檔案），在目錄類中重寫。如果設計為純虛擬函式則在檔案類中一定要重寫該函式，但在實際操作中由不可以進行該操作（新增檔案），這種設計是不合理的。

Prototype 模式

該例難度係數較大。

#include<iostream>
enum imageType
{
    LSAT,SPOT
}
class Image
{
public:
    virtual void draw()=0;
    static Imag* findAndClone(imageType);//為陣列中所有指標分配記憶體(只是舉例，特殊情況特殊考慮)
protected:
    virtual imageType returnType()=0;
    virtual Image* clone()=0;//向子類提供分配記憶體介面
    static void addPrototype(Image* image)//用於接受擴充套件類返回的指標
    {
        _prototypes[_nextSlot++]=images;
    }
private:
    static Image* _prototypes[10];//儲存擴充套件類指標
    static int _nextSlot;
};
Image* Image::_prototypes[];
int Image::_nextSlot;

Image* Image::findAndClone(imageType type)
{
    for(int i=0;i<_nextSlot;i++)
    {
        if(_prototypes[i]->returnType()==type)
            return _prototypes[i]->clone();
    }
}

class LandSatImage:public Image//與之後SpotImage同屬擴充套件類，只分析此例
{
public:
    imageType returnType()
    {
        return LSAT;
    }
    void draw()
    {
        cout<<"LandSatImage::draw"<<_id<<endl;
    }
    Image* clone()//分配記憶體（通過呼叫有參函式），通過在父類呼叫陣列中相對應的指標
    {
        return new LandSatImage(1);
    }
protected:
    LandSatImage(int dummy)
    {
        _id=_count++;
    }
private:
    static LandSatImage _landSatImage;//定義自身，呼叫無參構造，返回指標給父類
    LandSatImage()//無參構造，向父類返回指標
    {
        addPrototype(this);    
    }
    int _id;
    static int _count;
};
LandSatImage LandSatImage::_landSatImage;
int LandSatImage::_count=1;

class SpotImage:public Image
{
public:
    imageType returnType()
    {
        return SPOT;
    }
    void draw()
    {
        cout<<"SpotImage::draw"<<_id<<endl;
    }
    Image* clone()
    {
        return new SpotImage(1);
    }
protected:
    SpotImage(int dummy)
    {
        _id=_count++;
    }
pirvate:
    SpotImage()
    {
        addPrototype(this);
    }   
    static SpotImage _spotImage;
    int _id;
    static int _count;
};
SpotImage SpotImage::_spotImage;
int SpotImage::_count=1;

解析：例子很長，我們只分析其中的精華部分。prototype(原型)模式的特點是可以在專案初期只設計一個原型，而在之後可以根據客戶的不同需求擴充套件各種不同的class。那麼它的實現
原理是怎樣的呢？

首相建立一個原型類，在類中通過純虛擬函式宣告之後的擴充套件類需要提供的介面，並定義一個原型類（父類）指標的陣列，用來儲存各種擴充套件類（子類）的指標。

之後我們來設計擴充套件類（anytime），首先我們要在其私有成員中宣告一個靜態的自身，其會呼叫到無參的建構函式，會返回一個指向自身的指標給父類，父類接受到指標後存進陣列，這樣父類就起到了一個監視的作用，可以動態的收集子類指標。但是這裡我們只是返回了一個指標，並不算是一個真正的資料，因為沒有記憶體塊，當我們真正需要使用的時候只需要在父類的陣列中找到相對應的指標，為其分配記憶體即可（通過呼叫有參構造）。

學習完本課程深深地體會到：第一批搞設計模式的人絕對都是世界上最聰明的那類人。