设计模式之代理模式

在上一篇博文中，我们学习了组合模式，组合模式最大的特点就是叶子对象和组合对象所表现的的行为很相似，使得用户在使用这个模式时，使得单个对象和组合对象的表现行为一致，易于管理，而今天我们继续学习另外一个设计模式——代理模式，根据代理模式的定义：为其他对象提供一种代理以控制对这个对象的访问。怎么来理解呢，我们完全可以将这里的代理想象成现实生活中的代理，现实生活中的代理主要职责就是为普通用户提供服务，而普通用户无需关心这个服务的底层实现流程是怎样的，这个模式有点类似于之前的适配器模式，但是两者之间还是有区别的，希望好好地体会下，好了，下面我们来看看代理模式的代码吧，代码如下：

#ifndef __PROXY__H
#define __PROXY__H

#include <stdio.h>
#include <string>
#include <boost/smart_ptr.hpp>
using namespace std;
using namespace boost;

class Tool
{
    public:
        Tool(string name=string()):name(name)
        {
        }
        virtual ~Tool(){}
        virtual void display()
        {
            printf("name:%s\n",name.c_str());
        }
    protected:
        string name;

};

class Car : public Tool
{
    public:
        Car(string name):Tool(name){}
        ~Car(){}
        void display()
        {
            printf("name:%s\n",name.c_str());
        }
};

class Bike : public Tool
{
    public:
        Bike(string name):Tool(name){}
        ~Bike(){}
        void display()
        {
            printf("name:%s\n",name.c_str());
        }

};
template<class T>
class ToolProxy
{
    public:
        ToolProxy(shared_ptr<T>& tool):tool(tool){}
        ~ToolProxy(){}
        void display()
        {
            tool->display();
        }
    private:
        shared_ptr<T> tool;
};
#endif

#include "Proxy.h"

int main()
{
    shared_ptr<Tool> car(new Tool("car"));
    shared_ptr<Tool> bike(new Tool("bike"));
    ToolProxy<Tool> toolProxy1(car);
    ToolProxy<Tool> toolProxy2(bike);
    toolProxy1.display();
    toolProxy2.display();
    return 0;
}

测试结果

name:car
name:bike

2.设计实现一个简单的shared_ptr指针，代码如下：

#ifndef __SHARED_PTR__H
#define __SHARED_PTR__H

template<class T>
class shared_ptr
{
    public:
        shared_ptr(T* p):pointer(p),count(new int(1)){}
        shared_ptr(const shared_ptr& shptr):pointer(shptr.pointer),count(shptr.count)
        {
            ++*count;
        }
        shared_ptr& operator=(const shared_ptr& shpter)
        {
            if(shpter.pointer == pointer)
                return *this;
            dec_count();
            pointer = shpter.pointer;
            count = shpter.count;
            *count++;
            return *this;
        }
        T* operator->(){return pointer;}
        const T* operator->()const {return pointer;}
        T& operator*(){return *pointer;}
        const T& operator*()const {return *pointer;}
        int get_count(){return *count;}
        void dec_count()
        {
            --*count;
            if(*count ==0)
            {
                delete pointer;
                delete count;
            }
        }
    private:
        T* pointer;
        int* count;
};
#endif

测试程序：

#include "Proxy.h"

int main()
{
    shared_ptr<Tool> car(new Tool("car"));
    shared_ptr<Tool> bike(new Tool("bike"));
    shared_ptr<Tool> car1(car);
    shared_ptr<Tool> bike1(bike);
    printf("%d\n",car.get_count());
    printf("%d\n",car1.get_count());
    printf("%d\n",bike.get_count());
    printf("%d\n",bike1.get_count());
    ToolProxy<Tool> toolProxy1(car1);
    ToolProxy<Tool> toolProxy2(bike1);
    toolProxy1.display();
    toolProxy2.display();
    return 0;
}

测试结果：

2
2
2
2
name:car
name:bike

总结

      本篇博文主要是分析了代理模式一些基本用法，代理模式其实就是通过代理来实现底层对象的各种行为，而在实例程序中，我们实现了一个简单的shared_ptr指针，在这个实例中，我们需要注意一点就是那个计数器，这个计数器需要设计成指针形式，原因很简单，如果设计成指针形式的话，那么不同的shared_ptr就无法共享到这个引用计数器，shared_ptr也就没有多大的意义了，有甚者出现悬空指针的风险，好好地体会下吧，好了，本篇博文到此结束，下篇博文中，我们继续学习设计模式之享元模式。

如果需要，请注明转载，多谢