设计模式：工程模式
C++设计模式：工程模式
设计模式是解决软件设计中常见问题的典型解决方案。工程模式（Factory Pattern）是创建型设计模式之一，旨在处理对象创建的复杂性，使代码更具可扩展性和可维护性。本文将介绍工程模式的基本概念、类型以及如何在C++中实现。
什么是工程模式？
工程模式是一种通过工厂方法来创建对象的设计模式，避免了直接使用new关键字来实例化对象。它将对象的创建过程封装在一个工厂类中，使得代码更加灵活和可维护。
工程模式主要分为三种类型：
- 简单工厂模式（Simple Factory Pattern）
- 也称为静态工厂方法模式，使用一个单一的工厂类根据条件创建对象。
- 工厂方法模式（Factory Method Pattern）
- 定义一个创建对象的接口，但让子类决定实例化哪个类。
- 抽象工厂模式（Abstract Factory Pattern）
- 提供一个创建一系列相关或依赖对象的接口，而无需指定它们的具体类。
简单工厂模式
简单工厂模式是工程模式中最简单的一种。它通过一个静态方法根据不同的参数创建不同的对象。
#include <iostream>
#include <memory>
// 产品抽象基类
class Product {
public:
virtual void show() = 0;
virtual ~Product() = default;
};
// 具体产品类A
class ConcreteProductA : public Product {
public:
void show() override {
std::cout << "ConcreteProductA" << std::endl;
}
};
// 具体产品类B
class ConcreteProductB : public Product {
public:
void show() override {
std::cout << "ConcreteProductB" << std::endl;
}
};
// 工厂类
class SimpleFactory {
public:
enum class ProductType { A, B };
static std::unique_ptr<Product> createProduct(ProductType type) {
switch (type) {
case ProductType::A:
return std::make_unique<ConcreteProductA>();
case ProductType::B:
return std::make_unique<ConcreteProductB>();
default:
return nullptr;
}
}
};
int main() {
auto productA = SimpleFactory::createProduct(SimpleFactory::ProductType::A);
productA->show();
auto productB = SimpleFactory::createProduct(SimpleFactory::ProductType::B);
productB->show();
return 0;
}
工厂方法模式
工厂方法模式通过定义一个创建对象的接口，将具体的创建过程延迟到子类中。
#include <iostream>
#include <memory>
// 产品抽象基类
class Product {
public:
virtual void show() = 0;
virtual ~Product() = default;
};
// 具体产品类A
class ConcreteProductA : public Product {
public:
void show() override {
std::cout << "ConcreteProductA" << std::endl;
}
};
// 具体产品类B
class ConcreteProductB : public Product {
public:
void show() override {
std::cout << "ConcreteProductB" << std::endl;
}
};
// 工厂基类
class Factory {
public:
virtual std::unique_ptr<Product> createProduct() = 0;
virtual ~Factory() = default;
};
// 具体工厂类A
class ConcreteFactoryA : public Factory {
public:
std::unique_ptr<Product> createProduct() override {
return std::make_unique<ConcreteProductA>();
}
};
// 具体工厂类B
class ConcreteFactoryB : public Factory {
public:
std::unique_ptr<Product> createProduct() override {
return std::make_unique<ConcreteProductB>();
}
};
int main() {
std::unique_ptr<Factory> factoryA = std::make_unique<ConcreteFactoryA>();
auto productA = factoryA->createProduct();
productA->show();
std::unique_ptr<Factory> factoryB = std::make_unique<ConcreteFactoryB>();
auto productB = factoryB->createProduct();
productB->show();
return 0;
}
抽象工厂模式
抽象工厂模式提供一个创建一系列相关或依赖对象的接口，而无需指定它们的具体类。
#include <iostream>
#include <memory>
// 抽象产品A类
class AbstractProductA {
public:
virtual void show() = 0;
virtual ~AbstractProductA() = default;
};
// 抽象产品B类
class AbstractProductB {
public:
virtual void display() = 0;
virtual ~AbstractProductB() = default;
};
// 具体产品A1
class ConcreteProductA1 : public AbstractProductA {
public:
void show() override {
std::cout << "ConcreteProductA1" << std::endl;
}
};
// 具体产品A2
class ConcreteProductA2 : public AbstractProductA {
public:
void show() override {
std::cout << "ConcreteProductA2" << std::endl;
}
};
// 具体产品B1
class ConcreteProductB1 : public AbstractProductB {
public:
void display() override {
std::cout << "ConcreteProductB1" << std::endl;
}
};
// 具体产品B2
class ConcreteProductB2 : public AbstractProductB {
public:
void display() override {
std::cout << "ConcreteProductB2" << std::endl;
}
};
// 抽象工厂类
class AbstractFactory {
public:
virtual std::unique_ptr<AbstractProductA> createProductA() = 0;
virtual std::unique_ptr<AbstractProductB> createProductB() = 0;
virtual ~AbstractFactory() = default;
};
// 具体工厂类1
class ConcreteFactory1 : public AbstractFactory {
public:
std::unique_ptr<AbstractProductA> createProductA() override {
return std::make_unique<ConcreteProductA1>();
}
std::unique_ptr<AbstractProductB> createProductB() override {
return std::make_unique<ConcreteProductB1>();
}
};
// 具体工厂类2
class ConcreteFactory2 : public AbstractFactory {
public:
std::unique_ptr<AbstractProductA> createProductA() override {
return std::make_unique<ConcreteProductA2>();
}
std::unique_ptr<AbstractProductB> createProductB() override {
return std::make_unique<ConcreteProductB2>();
}
};
int main() {
std::unique_ptr<AbstractFactory> factory1 = std::make_unique<ConcreteFactory1>();
auto productA1 = factory1->createProductA();
auto productB1 = factory1->createProductB();
productA1->show();
productB1->display();
std::unique_ptr<AbstractFactory> factory2 = std::make_unique<ConcreteFactory2>();
auto productA2 = factory2->createProductA();
auto productB2 = factory2->createProductB();
productA2->show();
productB2->display();
return 0;
}
总结
工程模式通过将对象的创建过程封装在工厂类中，使代码更加灵活和易于维护。本文介绍了三种工程模式的实现方法：简单工厂模式、工厂方法模式和抽象工厂模式。每种模式都有其适用场景和优缺点，开发者可以根据具体需求选择合适的模式应用于项目中。通过合理地使用设计模式，可以提高代码的可读性、可维护性和扩展性。
原文地址：https://blog.csdn.net/weixin_44318762/article/details/140314249
免责声明：本站文章内容转载自网络资源，如本站内容侵犯了原著者的合法权益，可联系本站删除。更多内容请关注自学内容网（zxcms.com）！