c++简单工厂模式_C++ 工厂模式

什么是简单工厂模式？

简单工厂模式属于类的创建型模式，又叫做静态工厂方法模式，通过专门定义一个人来负责创建其他类的实例,被创建的实例通常都具有共同的复位.

模式中包含着角色及其职责

工程角色

简单工厂模式的核心。他负责实现创建所有实例的内部逻辑,工厂也可以被外界直接调用创建所需的产品对象.

抽象角色

简单工厂模式所创建的所有对象的父类。他负责描述所有实例所共有的公共接口

具体产品角色

简单工厂模式所创建的具体实例对象

简单工厂模式的优缺点

在这个模式中，工厂类是整个模式的关键所在，它包含必要的判断逻辑，能够根据外界给定的信息决定究竟应该创建哪个具体类的对象。用户在使用时可以直接根据工厂类去创建所需的实力，而无需了解这些对象是如何创建以及如何组织。有利于整个软件体系结构的优化。不难发现，简单工厂模式的缺点也正体现在其工厂类上。由于工厂里集中了所有实例的创建逻辑，所以高内聚方面做得并不好。另外，当系统中的具体产品可以不断增多时，可能会出现要求工厂里也做相应的修改，拓展性并不是很好.

#include<iostream>
using namespace std;
class Fruit
{
public:
	virtual void getFruit()
	{
		cout << "Fruit:getFruit" << endl;
	}
};
class Pear:public Fruit
{
public:
	virtual void getFruit()
	{
		cout << "Pear:getFruit" << endl;
	}
};

class Bnana :public Fruit
{
public:
	virtual void getFruit()
	{
		cout << "Bnana:getFruit" << endl;
	}
};
class Factory//依赖   简单工厂的创建工作 业务逻辑在这里
{
public:
	Fruit*Create(char *name)
	{
		if (strcmp(name, "pear") == 0)
		{
			return new Pear;
		}
		else if (strcmp(name, "Bnana") == 0)
		{
			return new Bnana;
		}
		return NULL;
	}

private:

};


void main()
{
	Factory*ff = NULL;
	Fruit*fruit = NULL;
	ff= new Factory;
	ff->Create("Pear");
	fruit->getFruit();//多态成立的三个条件
	delete fruit;

	ff->Create("Bnana");
	fruit->getFruit();
	delete fruit;
	cout << "hello..." << endl;
	system("pause");
	return;
}

代码100分

工厂模式

工厂方法模式同样属于类的创建型模式，又被称为多态工厂模式。工厂方法模式的意义是定义一个创建产品对象的工厂接口，将实际创建工作推迟到此类当中。核心工程类不再负责产品的创建，这样核心为成为一个抽象工厂角色，仅负责具体工厂此类必须实现的接口。这样进一步抽象化的好处是使得工厂方法模式可以使系统在不修改具体工厂角色的情况下，引进新的产品.

模式中包含着角色及其职责

抽象工厂角色

工厂方法模式的核心，任何工厂类都必须实现这个接口.

具体工厂角色

具体工程类是抽象工程的一个实现，负责实例化产品对象

抽象角色

工厂方法模式所创建的所有对象的富贵。他负责描述所有实例所共有的公共接口

具体产品角色

工厂方法模式所创建的具体实例对象

代码100分#include<iostream>
using namespace std;
class Fruit
{
public:
	virtual void sayName()
	{
		cout << "Fruit" << endl;
	}
};
class  FruitFactory
{
public:
	virtual  Fruit*getFruit()
	{
		cout << " FruitFactory:getFruit" << endl;
	}



};
class Pear :public Fruit
{
public:
	virtual void sayName()
	{
		cout << "我是梨" << endl;
	}
};

class Bnana :public Fruit
{
public:
	virtual void sayName()
	{
		cout << "我是香蕉" << endl;
	}
};
class BnanaFactory :public FruitFactory
{
public:
	virtual  Fruit*getFruit()
	{
		return new Bnana;
	}

};
class PearFactory : public FruitFactory
{
public:
	virtual  Fruit*getFruit()
	{
		return new Pear;
	}

};

void main()
{
	
	FruitFactory *ff = NULL;
	Fruit*fruit = NULL;

	ff = new BnanaFactory;
	fruit = ff->getFruit();
	fruit->sayName();
	delete fruit;
	delete ff;

	ff = new PearFactory;
	fruit = ff->getFruit();
	fruit->sayName();
	delete fruit;
	delete ff;
	cout << "hello..." << endl;
	system("pause");
	return;
}

抽象工厂模式是所有形态的工程模式中最为抽象和最其一般性的 .抽象工厂模式可以向客户端提供一个接口，使得客户端在不必指定产品的具体类型的情况下能够创建多个产品族的产品对象

简单一点说呢，具体工厂在开闭原则下能够生产香蕉苹果梨，抽象工厂在开闭原则下能生产南方的香蕉苹果梨，北方的香蕉苹果梨工厂方法模式针对的是一个产品等级结构，而抽象工厂模式针对的是多个产品等级结构.

抽象工厂和一般的工厂模式相比较的话，是产品的细化

#include<iostream>
using namespace std;
class Fruit
{
public:
	virtual void sayName()
	{
		cout << "Fruit" << endl;
	}
};
class  FruitFactory
{
public:
	virtual  Fruit*getBnana()
	{
		cout << " FruitFactory:getFruit" << endl;
		return NULL;
	}
	virtual  Fruit*getApple()
	{
		cout << " FruitFactory:getFruit" << endl;
		return NULL;
	}
	virtual  Fruit*getMg()
	{
		cout << " FruitFactory:getFruit" << endl;
		return NULL;
	}


};
//南方水果 南方香蕉
class SouthBanan:public Fruit
{
public:
	virtual void sayName()
	{
		cout << "SouthBanan" << endl;
	}

};
class NorthBanan :public Fruit
{
public:
	virtual void sayName()
	{
		cout << "NouthBanan" << endl;
	}

};
class SouthAplee :public Fruit
{
public:
	virtual void sayName()
	{
		cout << "SouthAplee" << endl;
	}

};
class NorthAplee :public Fruit
{
public:
	virtual void sayName()
	{
		cout << "NorthAplee" << endl;
	}

};
class NorthFactory:public Fruit
{
public:
	virtual  Fruit*getBnana()
	{
		return new  NorthBanan;
	}
	virtual  Fruit*getApple()
	{
	return new NorthAplee;
	}
	virtual  Fruit*getMg()
	{
			return NULL;
	}
};

class SouthFactory :public Fruit
{
public:
	virtual  Fruit*getBnana()
	{

		return new  SouthBanan;
	}
	virtual  Fruit*getApple()
	{

		return new SouthAplee;
	}
	virtual  Fruit*getMg()
	{

		return NULL;
	}
};
void main()
{
	FruitFactory *ff = NULL;
	Fruit*fruit1 = NULL;
	Fruit*fruit2= NULL;

	ff = new SouthFactory;
	fruit1= ff->getApple();
	fruit1->sayName();
	fruit2 = ff->getBnana();
	fruit2->sayName();
	delete fruit1;
	delete fruit2;


	ff = new NorthFactory;
	fruit1 = ff->getApple();
	fruit1->sayName();
	fruit2 = ff->getBnana();
	fruit2->sayName();
	delete fruit1;
	delete fruit2;
	cout << "hello..." << endl;
	system("pause");
	return;
}

代理模式可以为其他对象提供一种代理，以控制对这个对象的访问。所谓代理是指具有代理员，具有相同的接口，给客户端必须通过代理与被代理的目标为交互。而大概一般在交互的过程中进行某些特别的处理

代理模式的角色和职责。

抽象主题角色

真实主题与代理主题的共同接口。

真实主题角色

定义了代理角色所代表的真实对象

代理主题角色

还有对真实主题角色的引用，那个感觉通常在将客户端调用传递给真实主题角色对象之前或者之后执行某些操作，而不是单纯返回真实的对象.

关联关系

两个相对独立的对象。当一个对象的实例与另一个对象的一些特定实例存在固定的对应关系，这两个对象之间成为关联关系

聚合关系

当对象a被加入到对象B中，成为对象B的组成部分。对象、闭合对象a之间为聚集关系，聚合是关联关系的一种，是较强的关联关系，强调的是整体与部分之间的关系

具体表现与关联关系一样，聚合关系也是通过实例变量来实现，这样关系的关联关系和聚合关系，在语法上是没办法区分的，从语义上才能更好地区分两者的区别

关联关系所涉及的两个对象是处在同一层次上的，比如人和自行车就是一种关联关系，而不是聚合关系，因为人不是由自行车组成的。聚合关系涉及的两个对象处于不平等的层次上，一个代表整体，一个代表部分，比如电脑和他的显示器、键盘、主板以及内存就是聚集关系，因为主板是电脑的组成部分。对于具有聚集关系的两个对象，整体对象会制约他的组成对象的生命周期,部分类的对象不能单独存在，它的生命周期依赖于整体为对象的生命周期，当整体消失，部分也随之消失。比如张三的电脑被偷了，那么电脑的组件也就不存在了，除非张三事先把一些电脑的组件拆了下来.

代码100分#include<iostream>
using namespace std;
class BookStore
{
public:
	virtual void salebook()
	{
		cout << "BookStore salebook " << endl;
	}

};

class RealStore
{
public:
	virtual void salebook()
	{
		cout << "RealStore salebook " << endl;
	}
	

};
class DDStore :public BookStore
{
public:
	virtual void salebook()
	{
		RealStore realstore;
		doubleEleven();

		realstore.salebook();
		cout << "DDStore salebook " << endl;
	}
	void doubleEleven()
	{
		cout << "打折促销" << endl;
	}
};
void main()
{
	DDStore*ddstore = new DDStore;
	ddstore->salebook();
	cout << "hello..." << endl;
	system("pause");
	return;

}