Tsai笔记：C++设计模式学习（5）—— 抽象工厂模式（Abstract Factory）

Tsai笔记：C++设计模式学习（5）—— 抽象工厂模式（Abstract Factory）

设计模式的系列笔记链接如下：

Tsai笔记：C++设计模式学习（1）—— 设计模式介绍及分类

Tsai笔记：C++设计模式学习（2）—— 单例模式（Singleton）

Tsai笔记：C++设计模式学习（3）—— 享元模式（Flyweight）

Tsai笔记：C++设计模式学习（4）—— 工厂模式方法（Factory Method）

Tsai笔记：C++设计模式学习（5）—— 抽象工厂模式（Abstract Factory）

Tsai笔记：C++设计模式学习（6）—— 原型模式（ProtoType）

Tsai笔记：C++设计模式学习（7）—— 构建器（Builder）

一、模式定义

抽象工厂模式：提供一个接口，让该接口负责创建一系列“相关或者相互依赖的对象”，无需指定它们具体的类。                                                                                                                                                                                ——《设计模式》Gof

二、要点总结 

• 如果没有应对“多系列对象构建”的需求变化，则没有必要使用Abstract Factory模式，这时候使用简单的工厂完全可以。
• “系列对象”指的是在某一特定系列下的对象之间有相互依赖、或作用的关系。不同系列的对象之间不能相互依赖。
• Abstract Factory模式主要在于应对“新系列”的需求变动。其缺点在于难以应对“新对象”的需求变动。

三、C++ 代码呈现

#include<iostream>

//抽象类(接口)
class ISplitter {
public:
	virtual ~ISplitter() {}
	virtual void split() = 0;
};

class IJointer {
public:
	virtual ~IJointer() {}
	virtual void joint() = 0;
};

//具体类实现
class BinarySplitter : public ISplitter {
public:
	void split() override {
		std::cout << " --- BinarySplitter Work !" << std::endl;
	}
};

class TxtSplitter : public ISplitter {
public:
	void split() override {
		std::cout << " --- TxtSplitter Work !" << std::endl;
	}
};

class PictureSplitter : public ISplitter {
public:
	void split() override {
		std::cout << " --- PictureSplitter Work !" << std::endl;
	}
};

class VideoSplitter : public ISplitter {
public:
	void split() override {
		std::cout << " --- VideoSplitter Work !" << std::endl;
	}
};

class BinaryJointer : public IJointer {
public:
	void joint() override  {
		std::cout << " --- BinaryJointer Work !" << std::endl;
	}
};

class TxtJointer : public IJointer {
public:
	void joint() override {
		std::cout << " --- TxtJointer Work !" << std::endl;
	}
};

class PictureJointer : public IJointer {
public:
	void joint() override {
		std::cout << " --- PictureJointer Work !" << std::endl;
	}
};

class VideoJointer : public IJointer {
public:
	void joint() override {
		std::cout << " --- VideoJointer Work !" << std::endl;
	}
};

//工厂基类
class BaseFactory {
public:
	virtual ~BaseFactory() {}
	virtual ISplitter* CreateSplitter() = 0;
	virtual IJointer* CreateJointer() = 0;
};

class BinaryFactory : public BaseFactory {
public:
	ISplitter* CreateSplitter() {
		return new BinarySplitter;
	}
	IJointer* CreateJointer() {
		return new BinaryJointer;
	}
};

class TxtFactory : public BaseFactory {
public:
	ISplitter* CreateSplitter() {
		return new TxtSplitter();
	}
	IJointer* CreateJointer() {
		return new TxtJointer();
	}
};

class PictureFactory : public BaseFactory {
public:
	ISplitter* CreateSplitter() {
		return new PictureSplitter();
	}
	IJointer* CreateJointer() {
		return new PictureJointer();
	}
};

class VideoFactory : public BaseFactory {
public:
	ISplitter* CreateSplitter() {
		return new VideoSplitter();
	}
	IJointer* CreateJointer() {
		return new VideoJointer();
	}
};

class MainForm {
	BaseFactory* factory;//工厂
public:
	MainForm(BaseFactory* factory) {
		this->factory = factory;
	}

	void Work() {
		ISplitter* splitter = factory->CreateSplitter(); //多态new
		IJointer* jointer = factory->CreateJointer();
		splitter->split();
		jointer->joint();
	}
};

测试函数：

#include <AbstractFactory.h>
int main()
{
	BinarySplitterFactory binary;
	TxtSplitterFactory txt;
	PictureSplitterFactory picture;
	VideoSplitterFactory video;

	MainForm Splitter_b(&binary);
	Splitter_b.Work();

	MainForm Splitter_t(&txt);
	Splitter_t.Work();

	MainForm Splitter_p(&picture);
	Splitter_p.Work();

	MainForm Splitter_v(&video);
	Splitter_v.Work();

	return 0;
}

输出结果为：

 --- BinarySplitter Work !
 --- BinaryJointer Work !
 --- TxtSplitter Work !
 --- TxtJointer Work !
 --- PictureSplitter Work !
 --- PictureJointer Work !
 --- VideoSplitter Work !
 --- VideoJointer Work !