设计模式之Visitor访问者模式

1. 抽象类

1.1. 访问者

class Apple;
class Pork;
class Visitor
{
public:
	virtual ~Visitor() = default;
	virtual void visit(Apple* apple) = 0;
	virtual void visit(Pork* pork) = 0;
protected:
	Visitor() = default;
};

1.2. 元素

//Element（抽象元素）
class Element
{
public:
	virtual ~Element() = default;
	virtual void accept(Visitor* visitor) = 0;

	void setPrice(const double& price)
	{
		m_dPrice = price;
	}
	double getPrice()
	{
		return m_dPrice;
	}

	void setNum(const int& num)
	{
		m_iNum = num;
	}
	int getNum()
	{
		return m_iNum;
	}

	void setName(const std::string& name)
	{
		m_sName = name;
	}
	std::string getName()
	{
		return m_sName;
	}

protected:
	Element()
	{
		m_dPrice = 0.0;
		m_iNum = 0;
	}

	double m_dPrice;
	int m_iNum;
	std::string m_sName;
};

2. 具体类

2.1. 元素 

//ConcreteElement（具体元素）
class Apple : public Element
{
public:
	Apple(const std::string& name, int price)
	{
		setPrice(price);
		setNum(0);
		setName(name);
		std::cout << "Apple 构造函数，name = " << name << std::endl;
	}
	~Apple()
	{
		std::cout << "Apple 析构函数，name = " << m_sName << std::endl;
	}
	void accept(Visitor*) override;
private:

};

class Pork : public Element
{
public:
	Pork(const std::string& name, int price)
	{
		setPrice(price);
		setNum(0);
		setName(name);
		std::cout << "Pork 构造函数，name = " << name << std::endl;
	}
	~Pork()
	{
		std::cout << "Pork 析构函数，name = " << m_sName << std::endl;
	}
	void accept(Visitor*) override;
private:

};

/// 放在 Visitor 类后
void Apple::accept(Visitor* visitor) {
	visitor->visit(this);
}
void Pork::accept(Visitor* visitor) {
	visitor->visit(this);
}

2.2. 访问者

//ConcreteVisitor（具体访问者）
class Customer : public Visitor
{
public:
	explicit Customer(const std::string& name)
	{
		m_sName = name;
		std::cout << "Customer 构造函数" << std::endl;
	}
	~Customer() override
	{
		std::cout << "Customer 析构函数" << std::endl;
	}
	void setNum(Apple* apple, const int& num)
	{
		apple->setNum(num);
	}
	void setNum(Pork* pork, const int& num)
	{
		pork->setNum(num);
	}
	void visit(Apple* apple) override {
		std::cout << apple->getName() << "\t 单价: " << apple->getPrice() << "元/kg" << std::endl;
	}
	void visit(Pork* pork) override {
		std::cout << pork->getName() << "\t 单价: " << pork->getPrice() << "元/kg" << std::endl;
	}
private:
	std::string m_sName;
};

class Cashier : public Visitor
{
public:
	explicit Cashier()
	{
		std::cout << "Cashier 构造函数" << std::endl;
	}
	~Cashier() override
	{
		std::cout << "Cashier 析构函数" << std::endl;
	}

	void visit(Apple* apple) override
	{
		std::string name = apple->getName();
		double price = apple->getPrice();
		int num = apple->getNum();
		double total = price * num;
		std::cout << name << "\t 总价：" << total << "元" << std::endl;
	}

	void visit(Pork* pork) override
	{
		std::string name = pork->getName();
		double price = pork->getPrice();
		int num = pork->getNum();
		double total = price * num;
		std::cout << name << "\t 总价：" << total << "元" << std::endl;
	}

private:

};

3. 对象结构

//ObjectStructure（对象结构）
class ShoppingCart
{
public:
	ShoppingCart()
	{
		std::cout << "ShoppingCart 构造函数" << std::endl;
	}
	~ShoppingCart()
	{
		std::cout << "ShoppingCart 析构函数" << std::endl;
	}
	void  addElement(Element* element)
	{
		std::cout << "商品：" << element->getName() << "\t 数量：" << element->getNum() << "\t 加入购物车！" << std::endl;
		m_ElementVector.push_back(element);
	}
	void accept(Visitor* visitor)
	{
		for (auto ele : m_ElementVector)
		{
			ele->accept(visitor);
		}
	}

private:
	std::vector<Element*> m_ElementVector;
};

4. 主函数

#include <string>
#include <vector>
#include <map>
#include <iostream> 
int main()
{
	Apple *apple1 = new Apple("大兴西瓜", 5);
	Apple *apple2 = new Apple("平谷大桃", 5);
	Pork *pork1 = new Pork("猪肉", 24);
	Pork *pork2 = new Pork("五花肉", 40);

	auto* cashier = new Cashier();
	auto* customer = new Customer(std::string("张三").c_str());
	customer->setNum(apple1, 3);
	customer->setNum(apple2, 4);
	customer->setNum(pork1, 1);
	customer->setNum(pork2, 2);

	auto* shoppingCart = new ShoppingCart();
	std::cout << "===购物车添加商品===" << std::endl;
	shoppingCart->addElement(apple1);
	shoppingCart->addElement(apple2);
	shoppingCart->addElement(pork1);
	shoppingCart->addElement(pork2);
	std::cout << "===顾客选择的商品===" << std::endl;
	shoppingCart->accept(customer);
	std::cout << "===收银员计算的价格===" << std::endl;
	shoppingCart->accept(cashier);
	std::cout << "========" << std::endl;

	delete apple1; delete apple2;
	delete pork1; delete pork2;
	delete cashier; delete customer;
	delete shoppingCart;

	getchar();

	return 0;
}