代理模式

代理模式 为另一个对象提供一个替身或占位符以控制对这个对象的访问。

#include <iostream>

using namespace std;

class CSubject {
public:
    CSubject() {};
    virtual ~CSubject() {}
    virtual void Request() = 0;
};

class CRealSubject : public CSubject {
public:
    CRealSubject() {}
    ~CRealSubject() {}
    void Request() {
        cout << "CRealSubject Request" << endl;
    }
};

class CProxy : public CSubject
{
public:
    CProxy() : m_pRealSubject(NULL) {}
    ~CProxy() {
        delete m_pRealSubject;
    }
    void Request() {
        if (NULL == m_pRealSubject) {
            m_pRealSubject = new CRealSubject();
        }
        cout << "CProxy Request" << endl;
        m_pRealSubject->Request();
    }

private:
    CRealSubject *m_pRealSubject;
};


int main(int argc, char **argv)
{
    CSubject *client = new CProxy();

    client->Request();

    delete client;
}

利用代理模式实现的SmartPointer：

#include <iostream>

using namespace std;

class KRefCount {
public:
    KRefCount():m_nCount(0){}

public:
    int AddRef(){ return ++m_nCount; }
    int Release(){ return --m_nCount; }
    void Reset(){ m_nCount = 0; }

private:
    int m_nCount;
};

template <typename T>
class SmartPtr {
public:
    SmartPtr(void) : m_pData(NULL) {
        m_pReference = new KRefCount();
        m_pReference->AddRef();
    }

    SmartPtr(T* pValue) : m_pData(pValue) {
        m_pReference = new KRefCount();
        m_pReference->AddRef();
    }

    SmartPtr(const SmartPtr<T>& sp)
        : m_pData(sp.m_pData)
        , m_pReference(sp.m_pReference) {
        m_pReference->AddRef();
    }

    ~SmartPtr(void) {
        if (m_pReference && m_pReference->Release() == 0) {
            delete m_pData;
            delete m_pReference;
        }
    }

    inline T& operator*() {
        return *m_pData;
    }

    inline T* operator->() {
        return m_pData;
    }

    SmartPtr<T>& operator=(const SmartPtr<T>& sp) {
        if (this != &sp) {
            if (m_pReference && m_pReference->Release() == 0) {
                delete m_pData;
                delete m_pReference;
            }

            m_pData = sp.m_pData;
            m_pReference = sp.m_pReference;
            m_pReference->AddRef();
        }

        return *this;
    }

    SmartPtr<T>& operator=(T* pValue) {
        if (m_pReference && m_pReference->Release() == 0) {
            delete m_pData;
            delete m_pReference;
        }

        m_pData = pValue;
        m_pReference = new KRefCount;
        m_pReference->AddRef();
        return *this;
    }

    T* Get() {
        T* ptr = NULL;
        ptr = m_pData;

        return ptr;
    }

    void Attach(T* pObject) {
        if (m_pReference->Release() == 0) {
            delete m_pData;
            delete m_pReference;
        }

        m_pData = pObject;
        m_pReference = new KRefCount;
        m_pReference->AddRef();
    }

    T* Detach() {
        T* ptr = NULL;

        if (m_pData) {
            ptr = m_pData;
            m_pData = NULL;
            m_pReference->Reset();
        }
        return ptr;
    }

private:
    KRefCount* m_pReference;
    T* m_pData;
};

class CTest {
public:
    CTest(int b) : a(b) {
        cout << "create CTest " << a << endl;
    }
    ~CTest() {
        cout << "delete CTest " << a << endl;
    }
private:
    int a;
};

int main(int argc, char **argv)
{
    SmartPtr<CTest> pSmartPtr1(new CTest(10));
    SmartPtr<CTest> pSmartPtr2(new CTest(20));

    pSmartPtr1 = pSmartPtr2;
}