23种设计模式

一 简单工厂模式

简单工厂模式主要解决接口选择问题。
Factory(工厂)的核心部分，负责实现创建所有产品的内部逻辑，工厂类可以被外界直接调用，创建所需对象即可。

// SingletonPattern.cpp : 此文件包含 "main" 函数。程序执行将在此处开始并结束。
//

#include <iostream>
using namespace std;

//抽象汽车
class AbstractCar
{
public:
    virtual void ShowCarName() = 0;
};

//具体产品的汽车继承->抽象汽车类，并且对他方法进行重写操作
//凯美瑞
class Camry :public AbstractCar
{
    virtual void ShowCarName()
    {
        cout << "Camry Car." << endl;
    }
};
//迈腾
class Magotan :public AbstractCar
{
    virtual void ShowCarName()
    {
        cout << "Magotan Car." << endl;
    }
};
//奥迪
class Aodi :public AbstractCar
{
    virtual void ShowCarName()
    {
        cout << "Aodi Car." << endl;
    }
};

//奔驰
class Benz :public AbstractCar
{
    virtual void ShowCarName()
    {
        cout << "Benz Car." << endl;
    }
};

//通过传递参数来确定需要生成汽车
//汽车工厂
class Carfactory
{
public:
    static AbstractCar* CreateCarFunc(string cname)
    {
        if (cname == "Camry")
            //具体生产细节....
            return new Camry;
        else if (cname == "Magotan")
            //具体生产细节....
            return new Magotan;
        else if (cname == "Aodi")
            //具体生产细节....
            return new Aodi;
        else if (cname == "Benz")
            //具体生产细节....
            return new Benz;
        else
            return nullptr;
    }
};
int main()
{

    //创建工厂
    Carfactory* fty = new Carfactory;

    //创建汽车

    AbstractCar* car;

    //指定工厂需要创建的汽车

    car = fty->CreateCarFunc("Benz");

    car->ShowCarName();

    delete car;


    return 0;

}

二 抽象工厂模式

        抽象工厂模式（Abstract Factory Pattern）隶属于设计模式中的创建型 模式，用于产品族的构建。抽象工厂是所有形态的工厂模式中最为抽象和最具一 般性的一种形态。抽象工厂是指当有多个抽象角色时使用的一种工厂模式。抽象 工厂模式可以向客户端提供一个接口，使客户端在不必指定产品的具体情况下， 创建多个产品族中的产品对象。 工厂模式中的每一个形态都是针对一定问题的解决方案，工厂方法针对的是 多个产品系列结构；而抽象工厂模式针对的是多个产品族结构，一个产品族内有 多个产品系列。

        提供一个创建一系列相互依赖对象的接口，而无需指定它们具体的类。主 要目的解决：主要解决接口问题的选择。

        在抽象工厂模式当中，客户端不再负责对象的创建，而是把这个 责任丢给具体的工厂类，客户端只负责对对象的调用，从而明确各个 类的职责。

抽象工厂模式当中存在四种角色：抽象工厂角色、具体工厂角色， 抽象产品角色，具体产品角色。

代码实例 

#include <iostream>
using namespace std;

// 抽象西瓜
class AbstractWatermelon {
public:
	virtual void PrintName() = 0;
	AbstractWatermelon() {
		cout << "抽象西瓜构造函数." << endl;
	}
	~AbstractWatermelon() {
		cout << "抽象西瓜析构函数." << endl;
	}
};

// 抽象桔子
class AbstractOrange {
public:
	virtual void PrintName() = 0;
	AbstractOrange() {
		cout << "抽象桔子构造函数." << endl;
	}
	~AbstractOrange() {
		cout << "抽象桔子析构函数." << endl;
	}
};

// 中国西瓜
class ChinaWatermelon :public AbstractWatermelon {
public:
	virtual void PrintName() {
		cout << "中国西瓜最好吃." << endl;
	}
	ChinaWatermelon() {
		cout << "中国西瓜构造函数." << endl;
	}
	~ChinaWatermelon() {
		cout << "中国西瓜析构函数." << endl;
	}
};

// 中国桔子
class ChinaOrange :public AbstractOrange
{
public:
	virtual void PrintName() {
		cout << "中国桔子最甜的.\n" << endl;
	}
	ChinaOrange() {
		cout << "中国桔子构造函数." << endl;
	}
	~ChinaOrange() {
		cout << "中国桔子析构函数" << endl;
	}
};

// 埃及西瓜
class EgyptWatermelon :public AbstractWatermelon {
public:
	virtual void PrintName() {
		cout << "埃及西瓜：早在四千年前就种植西瓜." << endl;
	}
	EgyptWatermelon() {
		cout << "埃及西瓜构造函数." << endl;
	}
	~EgyptWatermelon() {
		cout << "埃及西瓜析构函数." << endl;
	}
};

// 埃及桔子
class EgyptOrange :public AbstractOrange {
public:
	virtual void PrintName() {
		cout << "埃及桔子光照条件最好，供应高质量的桔子.\n" << endl;
	}
	EgyptOrange() {
		cout << "埃及桔子构造函数." << endl;
	}
	~EgyptOrange() {
		cout << "埃及桔子析构函数." << endl;
	}
};


// 抽象工厂 主要针对产品转换
class AbstrctFactory {
public:
	virtual AbstractWatermelon* CreateWatermelon() = 0;
	virtual AbstractOrange* CreateOrange() = 0;

	AbstrctFactory() {
		cout << "抽象工厂构造函数." << endl;
	}
	~AbstrctFactory() {
		cout << "抽象工厂析构函数." << endl;
	}
};

// 中国工厂
class ChinaFactory :public AbstrctFactory
{
public:
	virtual AbstractWatermelon* CreateWatermelon() {
		return new ChinaWatermelon;
	}
	virtual AbstractOrange* CreateOrange() {
		return new ChinaOrange;
	}
	ChinaFactory() {
		cout << "中国工厂构造函数." << endl;
	}
	~ChinaFactory() {
		cout << "中国工厂析构函数." << endl;
	}


};

// 埃及工厂
class EgyptFactory :public AbstrctFactory {
public:
	virtual AbstractWatermelon* CreateWatermelon() {
		return new EgyptWatermelon;
	}
	virtual AbstractOrange* CreateOrange() {
		return new EgyptOrange;
	}
	EgyptFactory() {
		cout << "埃及工厂构造函数." << endl;
	}
	~EgyptFactory() {
		cout << "埃及工厂析构函数." << endl;
	}
};


int main()
{
	cout << "****************************************************************************" << endl;
	//抽象工厂基类指针派生类对象
	AbstrctFactory* cfactory = new ChinaFactory;
	/*
	抽象工厂构造函数.
	中国工厂构造函数.
	*/
	//抽象西瓜基类指针
	AbstractWatermelon* cwatermelon = cfactory->CreateWatermelon();
	/*
	抽象西瓜构造函数.
	中国西瓜构造函数.
	*/
	AbstractOrange* corange = cfactory->CreateOrange();
	/*
	抽象桔子构造函数.
	中国桔子构造函数.
	*/
	cwatermelon->PrintName();
	/*
	中国西瓜最好吃.
	*/
	corange->PrintName();
	/*
	中国桔子最甜的.
	*/

	delete corange; corange = nullptr;
	//抽象桔子析构函数.
	delete cwatermelon; cwatermelon = nullptr;
	//抽象西瓜析构函数.
	delete cfactory; cfactory = nullptr;
	//抽象工厂析构函数.
	cout << "****************************************************************************" << endl;


	cout << "\n\n****************************************************************************" << endl;
	AbstrctFactory* efactory = new EgyptFactory;
	/*
	抽象工厂构造函数.
	埃及工厂构造函数
	*/
	AbstractWatermelon* ewatermelon = efactory->CreateWatermelon();
	/*
	抽象西瓜构造函数
	埃及西瓜构造函数.
	*/
	AbstractOrange* eorange = efactory->CreateOrange();
	/*
	抽象橘子构造函数
	埃及橘子构造函数.
	*/
	ewatermelon->PrintName();
	/*
	埃及西瓜：早在四千年前就种植西瓜.
	*/
	eorange->PrintName();
	/*
	埃及桔子光照条件最好，供应高质量的桔子.
	*/
	delete eorange; eorange = nullptr;//抽象桔子析构函数.
	delete ewatermelon; ewatermelon = nullptr;//抽象西瓜析构函数.
	delete efactory; efactory = nullptr;
	/*
	抽象工厂析构函数.
	*/
	cout << "****************************************************************************" << endl;
	return 0;
}