C++设计模式之工厂模式

设计模式之工厂模式

一. 简单工厂模式：定义一个用于创建对象的接口。

纯虚函数和抽象类
1、纯虚函数： 在函数原型后面加上符号 “=0”
1）纯虚函数是一个在基类中只有声明的虚函数,在基类中无定义。要求在任何派生类中都定义自己的版本;
2）纯虚函数为各派生类提供一个公共界面(接口的封装和设计,软件的模块功能划分);
2、抽象类：包含纯虚函数的类成为抽象类，用于为派生类提供一个基本框架和一个公共的对外接口，派生类(或派生类的派生类…)，应对抽象基类的所有纯虚成员函数进行实现。
a)抽象类对象不能做函数参数,不能创建对象,不能作为函数返回类型;
b)可以声明抽象类指针,可以声明抽象类的引用;
c)子类必须继承父类的纯虚函数才能创建对象。

1 C++没有接口的概念,可以使用纯虚函数实现接口,接口类中只有函数原型的定义,没有任何数据的定义。
2 实际表明: 多继承接口不会带来二义性和复杂性等问题;多重继承可以通过设计好的单继承和接口代替;接口类只是一个功能说明,不是功能实现;子类需要根据功能说明定义功能的实现。
3 多继承—->单继承+继承多个接口

#pragma once
#include <iostream>

enum class PRODUCT{A,B,C};

class AbstractProduct
{
public:
	virtual ~AbstractProduct(){}
	virtual void concreteProduct() = 0;
};

class ConcreteProductA : public AbstractProduct
{
public:
	virtual void concreteProduct() { std::cout << "a" << std::endl; }
};

class ConcreteProductB : public AbstractProduct
{
public:
	virtual void concreteProduct() { std::cout << "b" << std::endl; }
};

class ConcreteProductC : public AbstractProduct
{
public:
	virtual void concreteProduct() { std::cout << "c" << std::endl; }
};

class Factory
{
public:
	AbstractProduct* createProduct(PRODUCT type)
	{
		switch (type)
		{
		case A:
			return new ConcreteProductA();
			break;
		case B:
			return new ConcreteProductB();
			break;
		case C:
			return new ConcreteProductC();
			break;
		default:
			break;
		}
	}
};
int main()
{
	Factory fac;
	AbstractProduct* a = fac.createProduct(A);
	a->concreteProduct();
	AbstractProduct* b = fac.createProduct(B);
	b->concreteProduct();
	AbstractProduct* c = fac.createProduct(C);
	c->concreteProduct();
	delete a; delete b; delete c;
	return 0;
}

二.工厂模式

#pragma once

#include <iostream>

class AbstractProduct
{
public:
	virtual ~AbstractProduct() = 0;
	virtual void concreteProduct() = 0;
};

class ConcreteProductA : public AbstractProduct
{
public:
	virtual void concreteProduct() { std::cout << "a" << std::endl; }
};

class ConcreteProductB : public AbstractProduct
{
public:
	virtual void concreteProduct() { std::cout << "b" << std::endl; }
};

class ConcreteProductC : public AbstractProduct
{
public:
	virtual void concreteProduct() { std::cout << "c" << std::endl; }
};

class AbstractFactory
{
public:
	virtual ~AbstractFactory() = 0;
	virtual AbstractProduct* CreateProduct() = 0;
};

class ConcreteFactoryA : public AbstractFactory
{
public:
	AbstractProduct* CreateProduct() { return new ConcreteProductA(); }
};
class ConcreteFactoryB : public AbstractFactory
{
public:
	AbstractProduct* CreateProduct() { return new ConcreteProductB(); }
};
class ConcreteFactoryC : public AbstractFactory
{
public:
	AbstractProduct* CreateProduct() { return new ConcreteProductC(); }
};
int main()
{
	ConcreteFactoryA faca;
	AbstractProduct* a = faca.CreateProduct();
	a->concreteProduct();
	ConcreteFactoryB facb;
	AbstractProduct* b = facb.CreateProduct();
	b->concreteProduct();
	ConcreteFactoryC facc;
	AbstractProduct* c = facc.CreateProduct();
	c->concreteProduct();
	delete a; delete b; delete c;
	return 0;
}

三.抽象工厂模式

#pragma once
#include <iostream>

class AbstractProduct1
{
public:
	virtual void concreteProduct() = 0;
};

class ConcreteProductA : public AbstractProduct1
{
public:
	void concreteProduct() { std::cout << "a" << std::endl; }
};

class ConcreteProductB : public AbstractProduct1
{
public:
	void concreteProduct() { std::cout << "b" << std::endl; }
};

class AbstractProduct2
{
public:
	virtual void concreteProduct2() = 0;
};

class ConcreteProductC : public AbstractProduct2
{
public:
	void concreteProduct2() { std::cout << "c" << std::endl; }
};

class ConcreteProductD : public AbstractProduct2
{
public:
	void concreteProduct2() { std::cout << "d" << std::endl; }
};

class AbstractFactory
{
public:
	virtual AbstractProduct1* createFactory1() = 0;
	virtual AbstractProduct2* createFactory2() = 0;
};

class ConcreteFactory1 : public AbstractFactory
{
public:
	AbstractProduct1* createFactory1() { return new ConcreteProductA(); }
	AbstractProduct2* createFactory2() { return new ConcreteProductC(); }
};
class ConcreteFactory2 :public AbstractFactory
{
public:
	AbstractProduct1* createFactory1() { return new ConcreteProductB(); }
	AbstractProduct2* createFactory2() { return new ConcreteProductD(); }
};

int main()
{
	ConcreteFactory1 f1;
	ConcreteFactory2 f2;

	AbstractProduct1* p1 = f1.createFactory1();
	p1->concreteProduct();
	AbstractProduct2* p2 = f1.createFactory2();
	p2->concreteProduct2();

	AbstractProduct1* p3 = f2.createFactory1();
	p3->concreteProduct();
	AbstractProduct2* p4 = f2.createFactory2();
	p4->concreteProduct2();
	delete p1; delete p2; delete p3; delete p4;
	system("pause");
	return 0;
}