設計模式學習筆記-----工廠模式

工廠模式一般分爲三種：簡單工廠模式、工廠方法模式、抽象工廠模式。

• 簡單工廠模式

簡單工廠模式，工廠類是創建產品的，它決定創建哪一種產品。

簡單工廠模式的核心，它負責實現創建所有實例的內部邏輯。工廠類可以被外界直接調用，創建所需的產品對象。

#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;
}