Factory 模式

Factory 模式的两个最重要的功能：

1）定义创建对象的接口，封装了对象的创建；

2）使得具体化类的工作延迟到了子类中。

                                          图1：Factory 模式结构示意图 1

//Product.h

#pragma once

class Product
{
public:
	virtual ~Product() = 0;

protected:
	Product();
private:
};

class ConcreteProduct :public Product
{
public:
	~ConcreteProduct();
	ConcreteProduct();

protected:
private:
};

//Product.cpp

#include "Product.h" 
#include <iostream> 
using namespace std;

Product::Product()
{
	cout << "Product...." << endl;
}

Product::~Product()
{
	cout << "~Product...." << endl;
}

ConcreteProduct::ConcreteProduct()
{
	cout << "ConcreteProduct...." << endl;
}

ConcreteProduct::~ConcreteProduct()
{
	cout << "~ConcreteProduct...." << endl;
}

//Factory.h
#pragma once

class Product;

class Factory
{
public:
	virtual ~Factory() = 0;
	virtual Product* CreateProduct() = 0;
	virtual void DestroyProduct(Product* pProduct) = 0;
protected:
	Factory();
private:
};

class ConcreteFactory :public Factory
{
public:
	~ConcreteFactory();
	ConcreteFactory();
	Product* CreateProduct();
	void DestroyProduct(Product* pProduct);
protected:
private:
};

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

#include "Product.h"
#include "Factory.h" 
#include <iostream> 
using namespace std;

Factory::Factory()
{
	cout << "Factory....." << endl;
}

Factory::~Factory()
{
	cout << "~Factory....." << endl;
}


ConcreteFactory::ConcreteFactory()
{
	cout << "ConcreteFactory....." << endl;
}

ConcreteFactory::~ConcreteFactory()
{
	cout << "~ConcreteFactory....." << endl;
}

Product* ConcreteFactory::CreateProduct()
{
	return new ConcreteProduct();
}

void ConcreteFactory::DestroyProduct(Product* pProduct)
{
	delete pProduct;
}

//main.cpp
#include "Factory.h" 
#include "Product.h" 

#include <iostream> 
using namespace std;

int main(int argc, char* argv[])
{
	Factory* fac = new ConcreteFactory();

	Product* p = fac->CreateProduct();
	fac->DestroyProduct(p);

	delete fac;

	return 0;
}

运行结果如下图：