设计模式C++实现（8）——代理模式

代理模式的定义：为其他对象提供一种代理以控制对这个对象的访问。在某些情况下，一个对象不适合或者不能直接引用另一个对象，而代理对象可以在客户端和目标对象之间起到中介的作用。

代理模式的优点：

(1).职责清晰

真实的角色就是实现实际的 业务逻辑，不用关心其他非本职责的事务，通过后期的代理完成一件完成事务，附带的结果就是编程简洁清晰。

(2).代理对象可以在 客户端和目标对象之间起到中介的作用，这样起到了的作用和保护了目标对象的作用。

(3).高扩展性

class Image  
{  
public:  
    Image(string name): m_imageName(name) {}  
    virtual ~Image() {}  
    virtual void Show() {}  
protected:  
    string m_imageName;  
};  

class BigImage: public Image  
{  
public:  
    BigImage(string name):Image(name) {}  
    ~BigImage() {}  
    void Show() { cout<<"Show big image : "<<m_imageName<<endl; }  
};  

class BigImageProxy: public Image  
{  
private:  
    BigImage *m_bigImage;  
public:  
    BigImageProxy(string name):Image(name),m_bigImage(0) {}  
    ~BigImageProxy() { delete m_bigImage; }  
    void Show()   
    {  
        if(m_bigImage == NULL)  
            m_bigImage = new BigImage(m_imageName);  
        m_bigImage->Show();  
    }  
};  

int main()  
{  
    Image *image = new BigImageProxy("proxy.jpg"); //代理  
    image->Show(); //需要时由代理负责打开  
    delete image;  
    return 0;  
}  

以下为引用：出处 http://blog.csdn.net/wuzhekai1985

  在这个例子属于虚代理的情况，下面给两个智能引用的例子。一个是C++中的auto_ptr，另一个是smart_ptr。自己实现了一下。先给出auto_ptr的代码实现：

[cpp]  view plain copy print ?

1. template<class T>    
2. class auto_ptr {    
3. public:    
4.     explicit auto_ptr(T *p = 0): pointee(p) {}    
5.     auto_ptr(auto_ptr<T>& rhs): pointee(rhs.release()) {}    
6.     ~auto_ptr() { delete pointee; }    
7.     auto_ptr<T>& operator=(auto_ptr<T>& rhs)    
8.     {    
9.         if (this != &rhs) reset(rhs.release());    
10.         return *this;    
11.     }    
12.     T& operator*() const { return *pointee; }    
13.     T* operator->() const { return pointee; }    
14.     T* get() const { return pointee; }    
15.     T* release()    
16.     {    
17.         T *oldPointee = pointee;    
18.         pointee = 0;    
19.         return oldPointee;    
20.     }    
21.     void reset(T *p = 0)    
22.     {    
23.         if (pointee != p) {    
24.                delete pointee;    
25.                pointee = p;    
26.             }    
27.         }    
28. private:    
29.     T *pointee;    
30. };    

        阅读上面的代码，我们可以发现 auto_ptr 类就是一个代理，客户只需操作auto_prt的对象，而不需要与被代理的指针pointee打交道。auto_ptr 的好处在于为动态分配的对象提供异常安全。因为它用一个对象存储需要被自动释放的资源，然后依靠对象的析构函数来释放资源。这样客户就不需要关注资源的释放，由auto_ptr 对象自动完成。实现中的一个关键就是重载了解引用操作符和箭头操作符，从而使得auto_ptr的使用与真实指针类似。

       我们知道C++中没有垃圾回收机制，可以通过智能指针来弥补，下面给出智能指针的一种实现，采用了引用计数的策略。

[cpp]  view plain copy print ?

1. template <typename T>  
2. class smart_ptr  
3. {  
4. public:  
5.     smart_ptr(T *p = 0): pointee(p), count(new size_t(1)) { }  //初始的计数值为1  
6.     smart_ptr(const smart_ptr &rhs): pointee(rhs.pointee), count(rhs.count) { ++*count; } //拷贝构造函数，计数加1  
7.     ~smart_ptr() { decr_count(); }              //析构，计数减1，减到0时进行垃圾回收，即释放空间  
8.     smart_ptr& operator= (const smart_ptr& rhs) //重载赋值操作符  
9.     {  
10.         //给自身赋值也对，因为如果自身赋值，计数器先减1，再加1，并未发生改变  
11.         ++*count;  
12.         decr_count();  
13.         pointee = rhs.pointee;  
14.         count = rhs.count;  
15.         return *this;  
16.     }    
17.     //重载箭头操作符和解引用操作符，未提供指针的检查  
18.     T *operator->() { return pointee; }  
19.     const T *operator->() const { return pointee; }  
20.     T &operator*() { return *pointee; }  
21.     const T &operator*() const { return *pointee; }  
22.     size_t get_refcount() { return *count; } //获得引用计数器值  
23. private:   
24.     T *pointee;       //实际指针，被代理    
25.     size_t *count;    //引用计数器  
26.     void decr_count() //计数器减1  
27.     {  
28.         if(--*count == 0)   
29.         {  
30.             delete pointee;  
31.             delete count;  
32.         }  
33.     }  
34. };