面向东西计划形式是软件工程范畴中一套经过验证的处理打算，旨在处理罕见的计划成绩。经由过程进修跟利用这些形式，开辟者可能晋升编程头脑，进步代码的可读性、可保护性跟可扩大年夜性。本文将揭秘经典的计划形式，并探究如何在实战中利用它们。
创建型形式关注东西的创建过程，重要目标是将东西的创建与利用解耦。以下是多少种罕见的创建型形式：
工厂形式定义了一个接口，让子类决定实例化哪一个具体类。这种形式让客户端代码跟具体类解耦，增加了体系的机动性。
class Product {
public:
virtual void operation() = 0;
};
class ConcreteProductA : public Product {
public:
void operation() override {
// 实现具体操纵
}
};
class ConcreteProductB : public Product {
public:
void operation() override {
// 实现具体操纵
}
};
class Factory {
public:
static Product* createProduct(int type) {
switch (type) {
case 1:
return new ConcreteProductA();
case 2:
return new ConcreteProductB();
default:
return nullptr;
}
}
};
单例形式确保一个类只有一个实例，并供给全局拜访点。这种形式在须要全局拜访某个特定东西时非常有效。
class Singleton {
private:
static Singleton* instance;
Singleton() {}
Singleton(const Singleton&) = delete;
Singleton& operator=(const Singleton&) = delete;
public:
static Singleton* getInstance() {
if (instance == nullptr) {
instance = new Singleton();
}
return instance;
}
};
Singleton* Singleton::instance = nullptr;
制作者形式将构造过程与它的表示分别，使得同样的构建过程可能有差其余表示。这种形式实用于构建复杂东西，并支撑可选设置。
class Builder {
public:
virtual void buildPartA() = 0;
virtual void buildPartB() = 0;
virtual Product* getResult() = 0;
};
class ConcreteBuilder : public Builder {
public:
void buildPartA() override {
// 构建部分A
}
void buildPartB() override {
// 构建部分B
}
Product* getResult() override {
return new Product();
}
};
class Director {
public:
void construct(Builder* builder) {
builder->buildPartA();
builder->buildPartB();
}
};
构外型形式重要关注东西组合跟合作，将类跟东西组剖析更大年夜的构造。以下是多少种罕见的构外型形式：
适配器形式使一个接口婚配另一个接口，以便于挪用者无需晓得细节。
class Target {
public:
virtual void request() = 0;
};
class Adaptee {
public:
void specificRequest() {
// 实现特定恳求
}
};
class Adapter : public Target {
private:
Adaptee* adaptee;
public:
Adapter(Adaptee* adaptee) : adaptee(adaptee) {}
void request() override {
adaptee->specificRequest();
}
};
装潢者形式静态地给东西增加职责，可能独破增加功能，而不影响其他东西。
class Component {
public:
virtual void operation() = 0;
};
class ConcreteComponent : public Component {
public:
void operation() override {
// 实现具体操纵
}
};
class Decorator : public Component {
protected:
Component* component;
public:
Decorator(Component* component) : component(component) {}
void operation() override {
component->operation();
}
};
class ConcreteDecoratorA : public Decorator {
public:
void operation() override {
// 实现装潢者A的具体操纵
Component::operation();
// 增加新的操纵
}
};
行动形式关注东西之间的交互方法，重要目标是应对须要变更为多个交互的类带来的袭击。以下是多少种罕见的行动形式：
战略形式定义一系列算法，并将每个算法封装起来，使它们可能相互调换。
class Strategy {
public:
virtual void algorithmInterface() = 0;
};
class ConcreteStrategyA : public Strategy {
public:
void algorithmInterface() override {
// 实现战略A的具体算法
}
};
class ConcreteStrategyB : public Strategy {
public:
void algorithmInterface() override {
// 实现战略B的具体算法
}
};
class Context {
private:
Strategy* strategy;
public:
Context(Strategy* strategy) : strategy(strategy) {}
void setStrategy(Strategy* strategy) {
this->strategy = strategy;
}
void executeAlgorithm() {
strategy->algorithmInterface();
}
};
察看者形式定义东西间的一对多依附关联，当一个东西的状况产生改变时，全部依附于它的东西都会掉掉落告诉并主动更新。
class Observer {
public:
virtual void update() = 0;
};
class ConcreteObserverA : public Observer {
public:
void update() override {
// 实现察看者A的更新操纵
}
};
class ConcreteObserverB : public Observer {
public:
void update() override {
// 实现察看者B的更新操纵
}
};
class Subject {
private:
std::vector<Observer*> observers;
public:
void attach(Observer* observer) {
observers.push_back(observer);
}
void notify() {
for (Observer* observer : observers) {
observer->update();
}
}
};
经由过程进修跟利用面向东西计划形式，开辟者可能晋升编程头脑，进步代码的品质。本文介绍了经典的计划形式，包含创建型、构外型跟行动形式，并经由过程示例代码展示了如何在实战中利用它们。盼望这些内容能帮助读者更好地懂得跟控制面向东西计划形式。