代理模式

1、代理模式：为其他对象提供一种代理以控制对这个对象的访问。它是真实对象的代替品。

2、好处：（1）、某些情况下，调用者不能直接引用另一个对象，可以代理其它对象去使用该对象。（2）、实现代码隐藏。

3、代理模式中的角色：

（1）、抽象角色：该角色通常为抽象类，为真实对象提供共同的接口。

（2）、代理角色：代理角色内部含有对真实对象的引用，从而可以操作真是对象。同时对代理对象提供与真是对象相同的接口，以便在任何时候都能替换真是对象。同时可以在执行对象操作时，附加其它的操作，相当于对真是对象的封装。它不干事！

（3）、真实角色：最终引用的对象。它是正在干事的人。

4、应用场景：

（1）、远程代理，也就是为一个对象在不同的地址空间提供局部代理，这样可以隐藏一个对象存在于不同的地址空间的事实。

（2）、虚拟代理。根据需要创建开销很大的对象。通过它来存放实例化需要很长时间的对象。

（3）、安全代理，用于控制真实对象访问时的权限。

（4）、只能引用，当调用真实对象时，代理处理另外一些事情。

 

实例：一哥们A去喜欢一个美女，但是自己没胆识去追，就让另一个哥们B代替他去送花。但是这个美女并不认识A

 

1、写一个送礼的抽象类

//送礼的抽象类
class givegift {
public:
    givegift();
    virtual ~givegift();
    virtual void giveDolls() = 0;
    virtual void giveFlows() = 0;
};//这里没什么好实现的，因此就不写了

2、写被代理的抽象类，即题目中的哥们A扮演的角色。这里的业务仅仅是送礼，因此不需要加入其它内容

//被代理的类。
class pursuerGiveGift:public givegift{
public:
    pursuerGiveGift(schoolGirl girl);
    pursuerGiveGift(){};
    virtual ~pursuerGiveGift();
    virtual void giveDolls();//实现送礼的函数
    virtual void giveFlows();
private:
    schoolGirl girl;//需要指导这个美女的名字，因此组合了美女类对象
};


/*实现该类中的成员函数*/
pursuerGiveGift::pursuerGiveGift(schoolGirl girl) {
    this->girl = girl;
}

pursuerGiveGift::~pursuerGiveGift() {
}

void pursuerGiveGift::giveDolls()
{
//这种方法访问不到girl.name。因为这个成员是私有的。在pursuerGiveGift类中，只是组合了schoolGirl这个类
//    cout << this->girl.nm << "送你的洋娃娃!" << endl;
    this->girl.show();
    cout << "送你的洋娃娃!" << endl;
}

void pursuerGiveGift::giveFlows()
{
//    cout << this->girl.nm << "送你的玫瑰花!" << endl;
    this->girl.show();
    cout << "送你的玫瑰花!" << endl;
}

3、实现一个代理类，它的功能与被代理的类相同。只是没有它里面的功能全部是调用被代理类去实现的。

//代理者类。同样继承givegift
class agentGiveGift:public givegift{
public:
    agentGiveGift(pursuerGiveGift pursuer);
    virtual ~agentGiveGift();
    virtual void giveDolls();
    virtual void giveFlows();
private:
    pursuerGiveGift pursuer;
};

/*实现该类中的函数*/
agentGiveGift::agentGiveGift(pursuerGiveGift pursuer){
    this->pursuer = pursuer;
}

agentGiveGift::~agentGiveGift() {
    // TODO Auto-generated destructor stub
}

void agentGiveGift::giveDolls()    
{
    this->pursuer.giveDolls();//这里的代理者只是去调用追求者，但是正真做事情的还是最求者
}

void agentGiveGift::giveFlows()
{
    this->pursuer.giveFlows();
}

4、实现女孩类

class schoolGirl {
public:
    schoolGirl(string name);
    schoolGirl(){};
    virtual ~schoolGirl();
    void show();
private:
    string nm;
};

/*实现该类中的函数*/
schoolGirl::schoolGirl(string nm) {
    this->nm = nm;
}

schoolGirl::~schoolGirl() {
    // TODO Auto-generated destructor stub
}

void schoolGirl::show()
{
    cout << this->nm;
}

5、调用示例

void fun()
{
    givegift *p;
    schoolGirl girl("美女");//创建一个美女
    pursuerGiveGift pursuer(girl);//创建一个追求者
    agentGiveGift agent(pursuer);//创建一个代理者（需要代理谁这里的构造函数中就传谁进去）。让代理追求者去追美女
    p  = &agent;
    p->giveDolls();//代理者给美女送花，美女只认识代理者，但是不知道真正最求她的人是谁
    p->giveFlows();
    /*这里可以这样调用，因为它们的父类都是givegift。这样它们就有共同的接口，调用效果一样。
     *这就是为什么要让pursuerGiveGift类和agentGiveGift类都去继承givegift类的原因*/
//    p = &pursuer;
//    p->giveDolls();
//    p->giveFlows();
}

int main(int argc, char *argv[])
{
    fun();
    return 0;
}