C++设计模式

设计模式：问题，解决方案和环境。

设计模式分类主要为创建型模式、结构型模式和行为型模式。

设计模式的基本原则：开放封闭原则、依赖倒置原则、接口隔离原则、里氏替换原则、合成复用原则、迪米特法则。

简单工厂模式：通过专门定义一个类来创建其他类的实例。

工厂方法模式同样属于类的创建型模式，又被称为多态工厂模式。

抽象工厂模式：可以创造多个产品组的产品对象。

三种工厂模式的区别：

简单工厂：对于增加新的产品，无能为力。

工厂模式：支持增加新的产品。

抽象工厂：可以增加产品族。

 

以下为简单工厂模式

#include<iostream>     //简单工厂
using namespace std;
class Car
{
public:
	virtual void show()=0; 
};
class BENZ : public Car
{
public:
	void show()
	{
		cout << "BENZ" << endl;
	}
};
class HONDA : public Car
{
public:
	void show()
	{
		cout << "HONDA" << endl;
	}
};
class BMW : public Car
{
public:
	void show()
	{
		cout << "BMW" << endl;
	}
};
class Factory                                
{
public:
	Car *CreateBMW()
	{
		return new BMW;
	}
	Car *CreateBENZ()
	{
		return new BENZ;
	}
	Car *CreateHONDA()
	{
		return new HONDA;
	}
};
int main()
{
	Car *c=NULL;
	Factory *f=new Factory;
	c=f->CreateBENZ();
	c->show();
	delete c;
	c=f->CreateHONDA();
	c->show();
	delete c;
	c=f->CreateBMW();
	c->show();
	delete c;
	return 0;
}

工厂模式：

#include<iostream>         //工厂模式
using namespace std;
class Car
{
public:
	virtual void show()=0; 
};
class BENZ : public Car
{
public:
	void show()
	{
		cout << "BENZ" << endl;
	}
};
class HONDA : public Car
{
public:
	void show()
	{
		cout << "HONDA" << endl;
	}
};
class BMW : public Car
{
public:
	void show()
	{
		cout << "BMW" << endl;
	}
};
class Factory                                
{
public:
	virtual Car *Create()=0;
};
class CreateBMW : public Factory
{
	Car *Create()
	{
		return new BMW;

	}
};
class CreateBENZ : public Factory
{
	Car *Create()
	{
		return new BENZ;
	}
};
class CreateHONDA : public Factory
{
	Car *Create()
	{
		return new HONDA;
	}
};
int main()
{
	Car *c=NULL;
	Factory *f=new CreateBENZ;
	c=f->Create();
	c->show();
	delete c;
	delete f;
	f=new CreateHONDA;
	c=f->Create();
	c->show();
	delete c;
	delete f;
	return 0;
}

抽象工厂模式：

#include<iostream>
using namespace std;
class Fruit
{
public:
	virtual void show()=0;
};
class NorthApple : public Fruit
{
public:
	void show()
	{
		cout << "NorthApple" << endl;
 	}
};
class NorthBanana : public Fruit
{
public:
	void show()
	{
		cout << "NorthBanana" << endl;
	}
};
class SouthApple : public Fruit
{
public:
	void show()
	{
		cout << "SouthApple" << endl;
	}
};
class SouthBanana : public Fruit
{
public:
	void show()
	{
		cout << "SouthBanana" << endl;
	}
};
class Factory
{
public:
	virtual Fruit *CreateApple()=0;
	virtual Fruit *CreateBanana()=0;
};
class NorthFactory : public Factory
{
public:
	Fruit *CreateApple()
	{
		return new NorthApple;
	}
	Fruit *CreateBanana()
	{
		return new NorthBanana;
	}
};
class SouthFactory : public Factory
{
public:
	Fruit *CreateApple()
	{
		return new SouthApple;
	}
	Fruit *CreateBanana()
	{
		return new SouthBanana;
	}
};
void Create(Factory *f)
{
	Fruit *fruit=NULL;
	fruit=f->CreateApple();
	fruit->show();
	delete fruit;
	fruit=f->CreateBanana();
	fruit->show();
	delete fruit;
}
int main()
{
	Factory *f=new NorthFactory;
	Create(f);
	delete f;
	f=new SouthFactory;
	Create(f);
	delete f;
	return 0;       //抽象工厂，运用了多态
}