在软件工程中，设计模式是一种通用的解决方案，用于解决常见的设计问题。工厂模式和抽象工厂模式是创建型设计模式中的两个重要成员，它们帮助我们创建对象而不需要暴露创建逻辑，同时使系统在不修改现有代码的情况下可以扩展。
工厂模式
工厂模式的核心思想是定义一个创建产品对象的接口，但是让子类决定实例化哪一个类。这样，工厂方法使一个类的实例化延迟到其子类。
常见问题与易错点
- 过度使用：在不需要的地方使用工厂模式会导致代码复杂度增加，维护成本上升。
- 违反开闭原则：当需要添加新产品时，可能需要修改现有的工厂类，这违反了“对扩展开放，对修改关闭”的原则。
如何避免
- 仅在需要动态选择具体实现或需要解耦创建过程时使用工厂模式。
- 使用抽象工厂模式来进一步封装创建过程，减少对工厂类的修改。
代码示例
#include <iostream>
// 抽象产品
class Product {
public:
virtual void Operation() const = 0;
};
// 具体产品A
class ConcreteProductA : public Product {
public:
void Operation() const override {
std::cout << "ConcreteProductA operation." << std::endl;
}
};
// 具体产品B
class ConcreteProductB : public Product {
public:
void Operation() const override {
std::cout << "ConcreteProductB operation." << std::endl;
}
};
// 工厂
class Factory {
public:
virtual Product* CreateProduct() = 0;
};
// 具体工厂A
class ConcreteFactoryA : public Factory {
public:
Product* CreateProduct() override {
return new ConcreteProductA();
}
};
// 具体工厂B
class ConcreteFactoryB : public Factory {
public:
Product* CreateProduct() override {
return new ConcreteProductB();
}
};
int main() {
Factory* factory = new ConcreteFactoryA();
Product* product = factory->CreateProduct();
product->Operation();
delete product;
delete factory;
return 0;
}
抽象工厂模式
抽象工厂模式提供了一个接口，用于创建一系列相关或相互依赖的对象，而无需指定它们具体的类。它比工厂模式更进一步，允许创建整个产品族。
常见问题与易错点
- 过度抽象：如果产品族之间的关系并不紧密，过度使用抽象工厂可能导致不必要的复杂性。
- 缺乏灵活性：一旦定义了产品族，很难在运行时更改或扩展。
如何避免
- 在产品族之间有明确的关系，并且需要一起创建时使用抽象工厂。
- 确保设计足够灵活，以便在不影响其他部分的情况下添加新的产品族。
代码示例
#include <iostream>
// 抽象产品A
class AbstractProductA {
public:
virtual void InterfaceA() const = 0;
};
// 具体产品A1
class ConcreteProductA1 : public AbstractProductA {
public:
void InterfaceA() const override {
std::cout << "ConcreteProductA1 interface." << std::endl;
}
};
// 具体产品A2
class ConcreteProductA2 : public AbstractProductA {
public:
void InterfaceA() const override {
std::cout << "ConcreteProductA2 interface." << std::endl;
}
};
// 抽象产品B
class AbstractProductB {
public:
virtual void InterfaceB() const = 0;
};
// 具体产品B1
class ConcreteProductB1 : public AbstractProductB {
public:
void InterfaceB() const override {
std::cout << "ConcreteProductB1 interface." << std::endl;
}
};
// 具体产品B2
class ConcreteProductB2 : public AbstractProductB {
public:
void InterfaceB() const override {
std::cout << "ConcreteProductB2 interface." << std::endl;
}
};
// 抽象工厂
class AbstractFactory {
public:
virtual AbstractProductA* CreateProductA() = 0;
virtual AbstractProductB* CreateProductB() = 0;
};
// 具体工厂1
class ConcreteFactory1 : public AbstractFactory {
public:
AbstractProductA* CreateProductA() override {
return new ConcreteProductA1();
}
AbstractProductB* CreateProductB() override {
return new ConcreteProductB1();
}
};
// 具体工厂2
class ConcreteFactory2 : public AbstractFactory {
public:
AbstractProductA* CreateProductA() override {
return new ConcreteProductA2();
}
AbstractProductB* CreateProductB() override {
return new ConcreteProductB2();
}
};
int main() {
AbstractFactory* factory = new ConcreteFactory1();
AbstractProductA* productA = factory->CreateProductA();
AbstractProductB* productB = factory->CreateProductB();
productA->InterfaceA();
productB->InterfaceB();
delete productA;
delete productB;
delete factory;
return 0;
}
通过以上示例，我们可以看到工厂模式和抽象工厂模式如何帮助我们在C++中更好地管理对象的创建过程，同时保持代码的清晰和可维护性。
