设计模式之四：代理模式(Proxy)

代理模式：

为某个类提供了一个代理来控制访问它。

Provide a surrogate or placeholder for another object to control access to it.

UML图：



主要包括：

Subject(IMath)：姑且称之为抽象的主题角色吧，这个类为代理类(Proxy)和真实的主题角色(RealSubject)定义了一个统一的接口，这样代理类(Proxy)可以出现在真实的主题角色(RealSubject)出现的任何地方。

RealSubject(Math)：定义了一个代理类(Proxy)将要表示的真实的主题角色。

Proxy(MathProxy)：代理类，这个类包含了一个对RealSubject的引用；它提供了一个和Subject同样的接口这样Proxy就能替换RealSubject；控制访问RealSubject并且负责创建和删除RealSubject。

根据UML图编写的代码如下：

#include <stdio.h>
#include <stdlib.h>
#include <iostream>

class Subject
{
        public:
                virtual void request()=0;
};

class RealSubject:public Subject
{
        public:
                void request()
                {
                    std::cout<<"RealSubject::request()"<<std::endl;
                }

};

class Proxy:public Subject
{
        public:
                void request()
                {
                        //使用延迟初始化的技术
                        if(realSubject==NULL)
                                realSubject=new RealSubject();

                        realSubject->request();
                }
    private:
            RealSubject * realSubject;

};

int main()
{
    std::cout<<"代理模式测试："<<std::endl;
    Proxy * proxy=new Proxy();
    proxy->request();

    delete proxy;
    return 0;
}

输出：




然后是一个真实的例子，使用代理模式实现加减乘除运算：

#include <stdlib.h>
#include <stdio.h>
#include <iostream>

/**一个真实的代理模式的例子
 * Proxy为MathProxy，客户端可见的是这个代理类的对象
 * Subject为IMath,这个是代码类和真实的主题必须遵循的接口
 * RealSubject为Math，真正完成工作的类是这个类
 */
class IMath
{
    public:
            virtual double add(double lhs,double rhs)=0;
            virtual double sub(double lhs,double rhs)=0;
            virtual double div(double lhs,double rhs)=0;
            virtual double mul(double lhs,double rhs)=0;

};

class Math:public IMath
{
    public:
            double add(double lhs,double rhs)
            {
                return lhs+rhs;
            }
            double sub(double lhs,double rhs)
            {
                return lhs-rhs;
            }
            double div(double lhs,double rhs)
            {
                return lhs/rhs;
            }
            double mul(double lhs,double rhs)
            {
                return lhs*rhs;
            }

};

class MathProxy:public IMath
{
    public:
            MathProxy()
            {
                math=new Math();
            }
            ~MathProxy()
            {
                if(math!=NULL)
                {
                    delete math;
                    math=NULL;
                }
            }
            double add(double lhs,double rhs)
            {
                return math->add(lhs,rhs);
            }
            double sub(double lhs,double rhs)
            {
                return math->sub(lhs,rhs);
            }
            double div(double lhs,double rhs)
            {
                return math->div(lhs,rhs);
            }
            double mul(double lhs,double rhs)
            {
                return math->mul(lhs,rhs);
            }

    private:
            Math * math;

};

int main()
{
    std::cout<<"真实的代理模式的例子"<<std::endl;
    MathProxy* proxy=new MathProxy();
    std::cout<<"lhs:1 rhs:2"<<std::endl;
    std::cout<<"proxy->add:"<<proxy->add(1,2)<<std::endl;
    std::cout<<"proxy->sub:"<<proxy->sub(1,2)<<std::endl;
    std::cout<<"proxy->div:"<<proxy->div(1,2)<<std::endl;
    std::cout<<"proxy->mul:"<<proxy->mul(1,2)<<std::endl;
    return 0;
}

输出：