【4】代理模式

场景：

设计场景：男孩暗恋女孩 ，但女孩不认识男孩，男孩的伙伴认识女孩，于是男孩委托伙伴向女孩送花

---

解决方案：

设计模式：使用代理模式，将送礼物作为追求者和代理的公共接口。
抽象类：类中至少有一个纯虚函数，抽象类不能生成对象，作为父类，其子类必须实现纯虚函数的定义，否则子类成为抽象类，纯虚函数实现定义后成为虚函数。
接口：是一种特殊的抽象类，类中没有定义任何的成员变量，所有的成员函数都是公有的，所有的成员函数都是纯虚函数。

---

代码如下：

#include"schoolGirl.h"
#include"proxy.h"

using namespace std;

// 代理模式
int main()
{
	// create Girl
	SchoolGirl* nana = new SchoolGirl();
	nana->setName("NANA");
	// create Proxy
	Proxy* proxy = new Proxy(nana); // nana 不认识 pursuit ，proxy 作为红线
	proxy->sendFlower();

	system("pause");
	return 0;
}

#pragma once
#include<string>

// 被追求者类
class SchoolGirl
{
public:
	std::string getName() { return m_name; }
	void setName(std::string name) { m_name = name; }
private:
	std::string m_name;
};

#pragma once

// 接口
class SendGift
{
public:
	virtual void sendFlower() = 0; // 纯虚函数
};

#pragma once
#include"sendGift.h"
#include"pursuit.h"
#include"schoolGirl.h"


// 代理类
class Proxy : public SendGift
{
public:
	Proxy(){}
	Proxy(SchoolGirl* girl )
	{
		// 将 girl 传递给 pursuit
		m_pursuit = new Pursuit(girl);
	}
	// 送花
	void sendFlower() override
	{
		// 调用追求者
		m_pursuit->sendFlower();
	}
private:
	Pursuit* m_pursuit = nullptr;
};

#pragma once
#include"sendGift.h"
#include"schoolGirl.h"

#include<iostream>

// 追求者类
class Pursuit : public SendGift
{
public:
	Pursuit(){}
	Pursuit(SchoolGirl* girl)
	{
		m_girl = girl;
	}
	void sendFlower() override
	{
		std::cout << m_girl->getName()<< "送你鲜花" << std::endl;
	}
private:
	SchoolGirl* m_girl = nullptr;
};