模式动机
-
在工厂方法模式中具体工厂负责生产具体的产品，每一个具体工厂对应一种具体产品，工厂方法也具有唯一性，一般情况下，一个具体工厂中只有一个工厂方法或者一组重载的工厂方法。但是有时候我们需要一个工厂可以提供多个产品对象，而不是单一的产品对象。
为了更清晰地理解工厂方法模式，需要先引入两个概念：
- 产品等级结构 ：产品等级结构即产品的继承结构，如一个抽象类是电视机，其子类有海尔电视机、海信电视机、TCL电视机，则抽象电视机与具体品牌的电视机之间构成了一个产品等级结构，抽象电视机是父类，而具体品牌的电视机是其子类。
- 产品族 ：在抽象工厂模式中，产品族是指由同一个工厂生产的，位于不同产品等级结构中的一组产品，如海尔电器工厂生产的海尔电视机、海尔电冰箱，海尔电视机位于电视机产品等级结构中，海尔电冰箱位于电冰箱产品等级结构中。
-
当系统所提供的工厂所需生产的具体产品并不是一个简单的对象，而是多个位于不同产品等级结构中属于不同类型的具体产品时需要使用抽象工厂模式。
-
抽象工厂模式是所有形式的工厂模式中最为抽象和最具一般性的一种形态。
-
抽象工厂模式与工厂方法模式最大的区别在于，工厂方法模式针对的是一个产品等级结构，而抽象工厂模式则需要面对多个产品等级结构，一个工厂等级结构可以负责多个不同产品等级结构中的产品对象的创建 。当一个工厂等级结构可以创建出分属于不同产品等级结构的一个产品族中的所有对象时，抽象工厂模式比工厂方法模式更为简单、有效率。
模式定义
抽象工厂模式(Abstract Factory Pattern)：提供一个创建一系列相关或相互依赖对象的接口，而无须指定它们具体的类。抽象工厂模式又称为Kit模式，属于对象创建型模式。
模式结构
抽象工厂模式包含如下角色：
- AbstractFactory：抽象工厂
- ConcreteFactory：具体工厂
- AbstractProduct：抽象产品
- Product：具体产品
时序图
代码-裸指针版本
// AbstractFactoryPattern.h
//
// Created by zhaoyf on 2022/4/30.
//
#ifndef CPPDESIGNPATTERN_ABSTRACTFACTORYPATTERN_H
#define CPPDESIGNPATTERN_ABSTRACTFACTORYPATTERN_H
#include <string>
namespace AbstractFactoryPattern {
// A类产品基类
// ProductA
class ProductA {
public:
virtual ~ProductA() {}
virtual std::string GetName() = 0;
// ...
};
// A类产品实际类型
// ConcreteProductAX
class ConcreteProductAX : public ProductA {
public:
~ConcreteProductAX() {}
virtual std::string GetName() override;
// ...
};
// ConcreteProductAY
class ConcreteProductAY : public ProductA {
public:
~ConcreteProductAY() {}
virtual std::string GetName() override;
// ...
};
// B类产品基类
// ProductB
class ProductB {
public:
virtual ~ProductB() {}
virtual std::string GetName() = 0;
// ...
};
// ConcreteProductBX
class ConcreteProductBX : public ProductB {
public:
~ConcreteProductBX() {}
virtual std::string GetName() override;
// ...
};
// ConcreteProductBY
class ConcreteProductBY : public ProductB {
public:
~ConcreteProductBY() {}
virtual std::string GetName() override;
// ...
};
// 抽象工厂基类
// AbstractFactory
class AbstractFactory {
public:
virtual ~AbstractFactory() {}
virtual ProductA *createProductA() = 0;
virtual ProductB *createProductB() = 0;
};
// ConcreteFactoryX
class ConcreteFactoryX : public AbstractFactory {
public:
~ConcreteFactoryX() {}
virtual ProductA *createProductA() override;
virtual ProductB *createProductB() override;
// ...
};
// ConcreteFactoryY
class ConcreteFactoryY : public AbstractFactory {
public:
~ConcreteFactoryY() {}
virtual ProductA *createProductA() override;
virtual ProductB *createProductB() override;
// ...
};
}
#endif //CPPDESIGNPATTERN_ABSTRACTFACTORYPATTERN_H
// AbstractFactoryPattern.cpp
//
// Created by zhaoyf on 2022/4/30.
//
#include "AbstractFactoryPattern.h"
#include <iostream>
#include <memory>
namespace AbstractFactoryPattern {
// ConcreteProductAY
std::string ConcreteProductAX::GetName() {
return "A-X";
}
std::string ConcreteProductAY::GetName() {
return "A-Y";
}
// ConcreteProductBX
std::string ConcreteProductBX::GetName() {
return "B-X";
}
std::string ConcreteProductBY::GetName() {
return "B-Y";
}
// ConcreteFactoryX
ProductA *ConcreteFactoryX::createProductA() {
return new ConcreteProductAX();
}
ProductB *ConcreteFactoryX::createProductB() {
return new ConcreteProductBX();
}
// ConcreteFactoryY
ProductA *ConcreteFactoryY::createProductA() {
return new ConcreteProductAY();
}
ProductB *ConcreteFactoryY::createProductB() {
return new ConcreteProductBY();
}
}
// main.cpp 测试代码
int main() {
// 如下代码存在内存泄露，但是为了方便测试忽略处理，改进请见智能指针版本
AbstractFactory *pFactory = new ConcreteFactoryX();
std::cout << "start create X factory series product:" << std::endl;
std::cout << pFactory->createProductA()->GetName() << std::endl;
std::cout << pFactory->createProductB()->GetName() << std::endl;
delete pFactory;
pFactory = nullptr;
pFactory = new ConcreteFactoryY();
std::cout << "start create Y factory series product:" << std::endl;
std::cout << pFactory->createProductA()->GetName() << std::endl;
std::cout << pFactory->createProductB()->GetName() << std::endl;
delete pFactory;
pFactory = nullptr;
return 0;
}
output:
start create X factory series product:
A-X
B-X
start create Y factory series product:
A-Y
B-Y代码-智能指针版本
// AbstractFactoryPattern_SharedPtr.h
//
// Created by zhaoyf on 2022/4/30.
//
#ifndef CPPDESIGNPATTERN_ABSTRACTFACTORYPATTERN_SHAREDPTR_H
#define CPPDESIGNPATTERN_ABSTRACTFACTORYPATTERN_SHAREDPTR_H
#include <string>
#include <memory>
namespace AbstractFactoryPattern_SharedPtr {
// A类产品基类
// ProductA
class ProductA {
public:
virtual ~ProductA() {}
virtual std::string GetName() = 0;
// ...
};
// A类产品实际类型
// ConcreteProductAX
class ConcreteProductAX : public ProductA {
public:
~ConcreteProductAX() {}
virtual std::string GetName() override;
// ...
};
// ConcreteProductAY
class ConcreteProductAY : public ProductA {
public:
~ConcreteProductAY() {}
virtual std::string GetName() override;
// ...
};
// B类产品基类
// ProductB
class ProductB {
public:
virtual ~ProductB() {}
virtual std::string GetName() = 0;
// ...
};
// ConcreteProductBX
class ConcreteProductBX : public ProductB {
public:
~ConcreteProductBX() {}
virtual std::string GetName() override;
// ...
};
// ConcreteProductBY
class ConcreteProductBY : public ProductB {
public:
~ConcreteProductBY() {}
virtual std::string GetName() override;
// ...
};
// 抽象工厂基类
// AbstractFactory
class AbstractFactory {
public:
virtual ~AbstractFactory() {}
virtual std::unique_ptr<ProductA> createProductA() = 0;
virtual std::unique_ptr<ProductB> createProductB() = 0;
};
// ConcreteFactoryX
class ConcreteFactoryX : public AbstractFactory {
public:
~ConcreteFactoryX() {}
virtual std::unique_ptr<ProductA> createProductA() override;
virtual std::unique_ptr<ProductB> createProductB() override;
// ...
};
// ConcreteFactoryY
class ConcreteFactoryY : public AbstractFactory {
public:
~ConcreteFactoryY() {}
virtual std::unique_ptr<ProductA> createProductA() override;
virtual std::unique_ptr<ProductB> createProductB() override;
// ...
};
}
#endif //CPPDESIGNPATTERN_ABSTRACTFACTORYPATTERN_SHAREDPTR_H
// AbstractFactoryPattern_SharedPtr.cpp
//
// Created by zhaoyf on 2022/4/30.
//
#include "AbstractFactoryPattern_SharedPtr.h"
#include <iostream>
namespace AbstractFactoryPattern_SharedPtr {
// ConcreteProductAY
std::string ConcreteProductAX::GetName() {
return "A-X";
}
std::string ConcreteProductAY::GetName() {
return "A-Y";
}
// ConcreteProductBX
std::string ConcreteProductBX::GetName() {
return "B-X";
}
std::string ConcreteProductBY::GetName() {
return "B-Y";
}
// ConcreteFactoryX
std::unique_ptr<ProductA> ConcreteFactoryX::createProductA() {
return std::make_unique<ConcreteProductAX>();
}
std::unique_ptr<ProductB> ConcreteFactoryX::createProductB() {
return std::make_unique<ConcreteProductBX>();
}
// ConcreteFactoryY
std::unique_ptr<ProductA> ConcreteFactoryY::createProductA() {
return std::make_unique<ConcreteProductAY>();
}
std::unique_ptr<ProductB> ConcreteFactoryY::createProductB() {
return std::make_unique<ConcreteProductBY>();
}
}
// 测试代码 main.cpp
int main() {
// 智能指针， 无内存泄露
auto upFactoryX = std::make_unique<ConcreteFactoryX>();
std::cout << "start create X factory series product:" << std::endl;
std::cout << upFactoryX->createProductA()->GetName() << std::endl;
std::cout << upFactoryX->createProductB()->GetName() << std::endl;
auto upFactoryY = std::make_unique<ConcreteFactoryY>();
std::cout << "start create Y factory series product:" << std::endl;
std::cout << upFactoryY->createProductA()->GetName() << std::endl;
std::cout << upFactoryY->createProductB()->GetName() << std::endl;
return 0;
}
output:
start create X factory series product:
A-X
B-X
start create Y factory series product:
A-Y
B-Y注
站在别人的肩膀上，感谢，参考文章如下
3. 抽象工厂模式(Abstract Factory) — Graphic Design Patterns
design-patterns-cpp/abstract-factory at master · JakubVojvoda/design-patterns-cpp · GitHub
个人代码仓库
2038
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
