C++设计模式之Adapter适配器模式

class FilterAdapter_A
{
public:
	FilterAdapter_A()
	{
		std::cout << "FilterAdapter_A 构造函数" << std::endl;
		m_sType = "FilterAdapter_A";
	}

	~FilterAdapter_A()
	{
		std::cout << "FilterAdapter_A 析构函数" << std::endl;
	}

	void adapterFilter(const char* text)
	{
		std::cout << "过滤器为：" << m_sType << std::endl;
		std::cout << "过滤内容为：" << text << std::endl;
	}

private:
	std::string m_sType;
};

//
class FilterAdapter_B
{
public:
	FilterAdapter_B()
	{
		std::cout << "FilterAdapter_B 构造函数" << std::endl;
		m_sType = "FilterAdapter_B";
	}

	~FilterAdapter_B()
	{
		std::cout << "FilterAdapter_B 析构函数" << std::endl;
	}

	void adapterFilter(const char* text,const std::string& mask)
	{
		std::cout << "过滤器为：" << m_sType << std::endl;
		std::cout << "过滤内容为：" << text << std::endl;
		std::cout << "过滤mask为：" << mask << std::endl;
	}

private:
	std::string m_sType;
};

class FilterTarget
{
public:
	virtual ~FilterTarget() = default;
	virtual void filter(const std::string& text) = 0;

protected:
	FilterTarget() = default;
};

///第一种适配器模式：类适配器///
class Class_FilterAdapter_A : public FilterTarget,private FilterAdapter_A
{
public:
	Class_FilterAdapter_A()
	{
		std::cout << "Class_FilterAdapter_A 构造函数" << std::endl;
	}
	~Class_FilterAdapter_A()
	{
		std::cout << "Class_FilterAdapter_A 构造函数" << std::endl;
	}

	void filter(const std::string& text) override
	{
		const char* temp = text.c_str();
		adapterFilter(temp);
	}
private:

};

class Class_FilterAdapter_B : public FilterTarget, private FilterAdapter_B
{
public:
	Class_FilterAdapter_B()
	{
		std::cout << "Class_FilterAdapter_B 构造函数" << std::endl;
		m_sMask = "MASK_B";
	}
	~Class_FilterAdapter_B()
	{
		std::cout << "Class_FilterAdapter_B 构造函数" << std::endl;
	}

	void filter(const std::string& text) override
	{
		const char* temp = text.c_str();
		adapterFilter(temp, m_sMask);
	}
private:
	std::string m_sMask;
};

/第二种适配器模式：对象适配器///
class Object_FilterAdapter_A : public FilterTarget
{
public:
	Object_FilterAdapter_A()
	{
		std::cout << "Object_FilterAdapter_A 构造函数" << std::endl;
	}

	~Object_FilterAdapter_A()
	{
		std::cout << "Object_FilterAdapter_A 构造函数" << std::endl;
	}

	void filter(const std::string& text) override
	{
		const char* temp = text.c_str();
		m_FilterAdapterA.adapterFilter(temp);//委托
	}

private:
	FilterAdapter_A m_FilterAdapterA;
};

class Object_FilterAdapter_B : public FilterTarget
{
public:
	Object_FilterAdapter_B()
	{
		std::cout << "Object_FilterAdapter_B 构造函数" << std::endl;
		m_sMask = "MASK_B";
	}

	~Object_FilterAdapter_B()
	{
		std::cout << "Object_FilterAdapter_B 构造函数" << std::endl;
	}

	void filter(const std::string& text) override
	{
		const char* temp = text.c_str();
		m_FilterAdapterB.adapterFilter(temp, m_sMask);//委托
	}

private:
	FilterAdapter_B m_FilterAdapterB;
	std::string m_sMask;
};

#include 
#include 
#include   
using namespace std;

void main()
{
	//类适配器模式
	{
		std::list filterList;
		filterList.push_back(new Class_FilterAdapter_A());
		filterList.push_back(new Class_FilterAdapter_B());

		std::list::iterator iter = filterList.begin();
		while (iter != filterList.end())
		{
			FilterTarget* filter = *iter++;
			filter->filter("这是类适配器模式");
		}

		while (!filterList.empty())
		{
			FilterTarget* filter = filterList.front();
			filterList.pop_front();
			delete filter;
		}
	}



	for (size_t i = 0; i < 3; i++)
	{
		std::cout << std::endl;
	}


	//对象适配器模式
	{
		std::list filterList;
		filterList.push_back(new Object_FilterAdapter_A());
		filterList.push_back(new Object_FilterAdapter_B());

		std::list::iterator iter = filterList.begin();
		while (iter != filterList.end())
		{
			FilterTarget* filter = *iter++;
			filter->filter("这是对象适配器模式");
		}

		while (!filterList.empty())
		{
			FilterTarget* filter = filterList.front();
			filterList.pop_front();
			delete filter;
		}
	}

	system("pause");
}