设计模式-工厂模式 C++实现

版权声明：本文为博主原创文章，未经博主允许不得转载。 https://blog.csdn.net/zhao5502169/article/details/89290529

工厂模式

定义:一个创建产品对象的工厂接口，将产品对象的实际创建工作推迟到具体子类工厂类中。

特点：（1）用户只要知道具体工厂的名称就可以得到所需要的产品，无需知道产品创建的过程。（2）增加新产品时只需要添加具体产品类和对应的具体工厂，无需修改源代码，满足开闭原则。

C++实现如下

Product.h

#pragma once
class AbstractProduct {
public:
	AbstractProduct();
	virtual ~AbstractProduct();
	virtual void operation() = 0;
};

class ProductA :public AbstractProduct {
public:
	ProductA();
	~ProductA();
	void operation();
};
class ProductB :public AbstractProduct {
public:
	ProductB();
	~ProductB();
	void operation();
};

Product.cpp

#include"Product.h"
#include<iostream>

using namespace std;

AbstractProduct::AbstractProduct() {
	cout << "AbstractProduct" << endl;
}
AbstractProduct::~AbstractProduct() {
	cout << "~AbstractProduct" << endl;
}
ProductA::ProductA() {
	cout << "ProductA" << endl;
}
ProductA::~ProductA() {
	cout << "~ProductA" << endl;
}
void ProductA::operation() {
	cout << "A operation" << endl;
}
ProductB::ProductB() {
	cout << "ProductB" << endl;
}
ProductB::~ProductB() {
	cout << "~ProductB" << endl;
}
void ProductB::operation() {
	cout << "B operation" << endl;
}

Factory.h

#pragma once
#include"Product.h"
class AbstractFactory {
public:
	AbstractFactory();
	virtual ~AbstractFactory();
	virtual AbstractProduct* createProduct() = 0;
};
class FactoryA :public AbstractFactory {
public:
	FactoryA();
	~FactoryA();
	AbstractProduct* createProduct();
};
class FactoryB :public AbstractFactory {
public:
	FactoryB();
	~FactoryB();
	AbstractProduct* createProduct();
};

Factory.cpp

#include"Factory.h"
#include"Product.h"
#include<iostream>
using namespace std;
AbstractFactory::AbstractFactory() {
	cout << "AbstractFactory" << endl;
}
AbstractFactory::~AbstractFactory() {
	cout << "~AbstractFactory" << endl;
}
FactoryA::FactoryA() {
	cout << "FactoryA" << endl;
}
FactoryA::~FactoryA() {
	cout << "~FactoryA" << endl;
}
AbstractProduct* FactoryA::createProduct() {
	return new ProductA();
}
FactoryB::FactoryB() {
	cout << "FactoryB" << endl;
}
FactoryB::~FactoryB() {
	cout << "~FactoryB" << endl;
}
AbstractProduct* FactoryB::createProduct() {
	return new ProductB();
}

main.cpp

#include"Factory.h"

int main(void) {
	AbstractFactory* factortyA = new FactoryA();
	AbstractProduct* productA = factortyA->createProduct();

	AbstractFactory* factortyB = new FactoryB();
	AbstractProduct* productB = factortyB->createProduct();
	productA->operation();
	productB->operation();

	
	return 0;
}