设计模式学习笔记-----工厂模式

工厂模式一般分为三种：简单工厂模式、工厂方法模式、抽象工厂模式。

• 简单工厂模式

简单工厂模式，工厂类是创建产品的，它决定创建哪一种产品。

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

#pragma once
#include <iostream>
using namespace std;
class MyObject
{
public:
	virtual void createObj(void) = 0;
};

class MyObj1 :public MyObject
{
public:
	MyObj1();
	virtual ~MyObj1();
public:
	virtual void createObj(void);
};


class MyObj2 :public MyObject
{
public:
	MyObj2();
	virtual ~MyObj2();
public:
	virtual void createObj(void);
};


class SimpleFactory
{
public:
	SimpleFactory();
	~SimpleFactory();
public:
	MyObject* CreateObj(int objType);
public:
	MyObject *obj;
};
----------------------------------------------------------------------
#include "SimpleFactory.h"

SimpleFactory::SimpleFactory()
{
	cout << __func__ << endl;
}


SimpleFactory::~SimpleFactory()
{
	cout << __func__ << endl;
}

MyObject* SimpleFactory::CreateObj(int objType) 
{
	cout << __func__ << endl;
	switch (objType)
	{
	case 0:break;
	case 1:
		obj = new MyObj1();
		break;
	case 2:
		obj = new MyObj2();
		break;				
	default:
		break;
	}
	return obj;
}


MyObj1::MyObj1()
{
	cout << __func__ << endl;
}
MyObj1::~MyObj1()
{
	cout << __func__ << endl;
}
void MyObj1::createObj(void)
{
	cout << __func__ << endl;
}

MyObj2::MyObj2()
{
	cout << __func__ << endl;
}
MyObj2::~MyObj2()
{
	cout << __func__ << endl;
}
void MyObj2::createObj(void)
{
	cout << __func__ << endl;
}
-----------------------------------------------------------
int main()
{

	SimpleFactory m_fac;
	MyObject* obj11 = m_fac.CreateObj(1);
	MyObject* obj22 = m_fac.CreateObj(2);
	system("pause");
	delete obj11;    /*网上说需要释放*/
	delete obj22;
	return 0;
}

总结：简单工厂主要用于创建对象。新添加类时，不会影响以前的系统代码。核心思想是用一个工厂来根据输入的条件产生不同的类，然后根据不同类的virtual函数得到不同的结果。

优点：适用于不同情况创建不同的类时

缺点：客户端必须要知道基类和工厂类，耦合性差

• 工厂方法模式

工厂方法模式不再只由一个工厂类决定那一个产品类应当被实例化,这个决定权被交给子类去做。当有新的对象产生时，只要按照抽象产品角色、抽象工厂角色提供的方法来生成即可，那么就可以被用户使用，而不必去修改任何已有的代 码。是符合开闭原则。

工厂方法模式与简单工厂模式在结构上的不同不是很明显：工厂方法类的核心是一个抽象工厂类，而简单工厂模式把核心放在一个具体类上。 工厂方法模式之所以有一个别名叫多态性工厂模式是因为具体工厂类都有共同的接口，或者有共同的抽象父类。当系统扩展需要添加新的产品对象时，仅仅需要添加一个具体对象以及一个具体工厂对象，原有工厂对象不需要进行任何修改，也不需要修改客户端，很好的符合了“开放－封闭”原则。而简单工厂模式在添加新产品对象后不得不修改工厂方法，扩展性不好。工厂方法模式退化后可以演变成简单工厂模式。

.h文件
#pragma once
#include <iostream>
using namespace std;

class MyObject1
{
public:
	MyObject1();
	virtual ~MyObject1();
public:
	virtual void createObj(void) ;
};

class MyObj11 :public MyObject1
{
public:
	MyObj11();
	virtual ~MyObj11();
public:
	virtual void createObj(void);
};


class MyObj22 :public MyObject1
{
public:
	MyObj22();
	virtual ~MyObj22();
public:
	virtual void createObj(void);
};


class FactoryFunction
{
public:
	FactoryFunction();
	virtual ~FactoryFunction();
public:
	virtual MyObject1* getObj();
};


class MyObj1Factory :public FactoryFunction
{
public:
	MyObj1Factory();
	virtual ~MyObj1Factory();
public:
	virtual MyObject1* getObj(void);
};

class MyObj2Factory :public FactoryFunction
{
public:
	MyObj2Factory();
	virtual ~MyObj2Factory();
public:
	virtual MyObject1* getObj(void);
};
-----------------------------------------------------------------------------
.cpp文件
#include "FactoryFunction.h"

MyObject1::MyObject1()
{
	cout << "MyObject1::" << __func__ << endl;
}

MyObject1::~MyObject1() 
{
	cout << "MyObject1::" << __func__ << endl;
}

void MyObject1::createObj(void)
{
	cout << "MyObject1::" << __func__ << endl;
}
MyObj11::MyObj11()
{
	cout << "MyObj11::"<<__func__ << endl;
}
MyObj11::~MyObj11()
{
	cout << "MyObj11::" << __func__ << endl;
}
void MyObj11::createObj(void)
{
	cout << "MyObj11::" << __func__ << endl;
}

MyObj22::MyObj22()
{
	cout << "MyObj22::" << __func__ << endl;
}
MyObj22::~MyObj22()
{
	cout << "MyObj22::" << __func__ << endl;
}
void MyObj22::createObj(void)
{
	cout << "MyObj22::" << __func__ << endl;
}


FactoryFunction::FactoryFunction()
{
	cout << "FactoryFunction::"<<__func__ << endl;
}

FactoryFunction::~FactoryFunction()
{
	cout << "FactoryFunction::" << __func__ << endl;
}
MyObject1*  FactoryFunction::getObj()
{
	cout << "FactoryFunction::" << __func__ << endl;
	return new MyObject1();
}

MyObj1Factory::MyObj1Factory()
{
	cout << "MyObj1Factory::" << __func__ << endl;
}

MyObj1Factory::~MyObj1Factory() 
{
	cout << "MyObj1Factory::" << __func__ << endl;
}

MyObject1* MyObj1Factory::getObj(void) 
{
	cout << "MyObj1Factory::" << __func__ << endl;
	return new MyObj11();
}

MyObj2Factory::MyObj2Factory()
{
	cout << "MyObj2Factory::" << __func__ << endl;
}

MyObj2Factory::~MyObj2Factory()
{
	cout << "MyObj2Factory::" << __func__ << endl;
}

MyObject1* MyObj2Factory::getObj(void)
{
	cout << "MyObj2Factory::" << __func__ << endl;
	return new MyObj22();
}
main文件
int main()
{
	FactoryFunction* ffuc=new MyObj1Factory();
	MyObject1* obj = ffuc->getObj();
	
	FactoryFunction* ffuc1 = new MyObj2Factory();
	MyObject1* obj1 = ffuc->getObj();

	//system("pause");
	delete ffuc;
	delete obj;
	delete ffuc1;
	delete obj1;
	return 0;
}

注：当存在继承关系时，必要的将基类析构函数生命为虚函数。

• 抽象工厂

在工厂方法的基础上，再将工厂类抽象派生出来一个具体的类。

.h头文件
#pragma once
#include <iostream>
using namespace std;


class AbsMyObject1
{
public:
	AbsMyObject1();
	virtual ~AbsMyObject1();
public:
	virtual void createObj(void);
};

class AbsMyObj11 :public AbsMyObject1
{
public:
	AbsMyObj11();
	virtual ~AbsMyObj11();
public:
	virtual void createObj(void);
};


class AbsMyObj22 :public AbsMyObject1
{
public:
	AbsMyObj22();
	virtual ~AbsMyObj22();
public:
	virtual void createObj(void);
};


class AbsFactoryFunction
{
public:
	AbsFactoryFunction();
	virtual ~AbsFactoryFunction();
public:	
	virtual AbsMyObject1* getObj1();
	virtual AbsMyObject1* getObj2();
};


class AbsMyObj1Factory :public AbsFactoryFunction
{
public:
	AbsMyObj1Factory();
	virtual ~AbsMyObj1Factory();
public:
	virtual AbsMyObject1* getObj1();
	virtual AbsMyObject1* getObj2();
};

class AbsMyObj2Factory :public AbsFactoryFunction
{
public:
	AbsMyObj2Factory();
	virtual ~AbsMyObj2Factory();
public:
	virtual AbsMyObject1* getObj1();
	virtual AbsMyObject1* getObj2();
};
----------------------------------------------------------------------
.cpp文件
#include "AbstractFactory.h"

AbsMyObject1::AbsMyObject1()
{
	cout << "AbsMyObject1::" << __func__ << endl;
}
AbsMyObject1::~AbsMyObject1()
{
	cout << "AbsMyObject1::" << __func__ << endl;
}

void AbsMyObject1::createObj(void)
{
	cout << "AbsMyObject1::" << __func__ << endl;
}



AbsMyObj11::AbsMyObj11()
{
	cout << "AbsMyObj11::" << __func__ << endl;
}
AbsMyObj11::~AbsMyObj11()
{
	cout << "AbsMyObj11::" << __func__ << endl;
}
void AbsMyObj11::createObj(void)
{
	cout << "AbsMyObj11::" << __func__ << endl;
}



AbsMyObj22::AbsMyObj22()
{
	cout << "AbsMyObj22::" << __func__ << endl;
}
AbsMyObj22::~AbsMyObj22()
{
	cout << "AbsMyObj22::" << __func__ << endl;
}
void AbsMyObj22::createObj(void)
{
	cout << "AbsMyObj22::" << __func__ << endl;
}




AbsFactoryFunction::AbsFactoryFunction()
{
	cout << "AbsFactoryFunction::" << __func__ << endl;
}

AbsFactoryFunction::~AbsFactoryFunction()
{
	cout << "AbsFactoryFunction::" << __func__ << endl;
}
AbsMyObject1* AbsFactoryFunction::getObj1()
{
	cout << "AbsFactoryFunction::" << __func__ << endl;
	return new AbsMyObj11();
}
 AbsMyObject1* AbsFactoryFunction::getObj2()
{
	 cout << "AbsFactoryFunction::" << __func__ << endl;
	return new AbsMyObj22();
}



AbsMyObj1Factory::AbsMyObj1Factory()
{
	cout << "AbsMyObj1Factory::" << __func__ << endl;
}
AbsMyObj1Factory::~AbsMyObj1Factory()
{
	cout << "AbsMyObj1Factory::" << __func__ << endl;
}
AbsMyObject1* AbsMyObj1Factory::getObj1()
{
	cout << "AbsMyObj1Factory::" << __func__ << endl;
	return new AbsMyObj11();
}
AbsMyObject1* AbsMyObj1Factory::getObj2()
{
	cout << "AbsMyObj1Factory::" << __func__ << endl;
	return new AbsMyObj22();
}



AbsMyObj2Factory::AbsMyObj2Factory() 
{
	cout << "AbsMyObj2Factory::" << __func__ << endl;
}

AbsMyObj2Factory::~AbsMyObj2Factory() 
{
	cout << "AbsMyObj2Factory::" << __func__ << endl;
}

AbsMyObject1* AbsMyObj2Factory::getObj1()
{
	cout << "AbsMyObj2Factory::" << __func__ << endl;
	return new AbsMyObj11();
}
AbsMyObject1* AbsMyObj2Factory::getObj2()
{
	cout << "AbsMyObj2Factory::" << __func__ << endl;
	return new AbsMyObj22();
}

main文件
int main()
{
	AbsFactoryFunction * ff = NULL;
	AbsMyObject1 *fruit = NULL;

	ff = new AbsMyObj1Factory();
	fruit = ff->getObj1();
	fruit->createObj();
	fruit = ff->getObj2();
	fruit->createObj();

	delete fruit;
	fruit = NULL;
	delete ff;
	ff = NULL;

	ff = new AbsMyObj2Factory();
	fruit = ff->getObj1();
	fruit->createObj();
	fruit = ff->getObj2();
	fruit->createObj();

	delete fruit;
	delete ff;

	return 0;
}