【揭秘面向对象设计模式】解锁高效编程的层次奥秘

引言

面向东西编程（OOP）是现代软件开辟的基本之一。它供给了一种构造代码的富强方法，经由过程封装、持续跟多态等特点，进步了代码的可重用性、可保护性跟可扩大年夜性。计划形式，作为面向东西编程的高等现实，是顺序员在临时开辟过程中积聚的宝贵经验总结。本文将深刻探究面向东西计划形式，提醒其在高效编程中的档次奥秘。

计划形式概述

计划形式是一套被反复利用、少数人知晓、经过分类编目标、代码计划经验的总结。利用计划形式的目标如下：

1. 可重用代码：经由过程计划形式，可能创建可重用的代码库，进步开辟效力。
2. 易于懂得：计划形式供给了代码实现的通用模板，有助于他人懂得代码。
3. 保证代码坚固性：遵守计划形式可能降落错误产生的概率，进步代码的坚固性。

计划形式平日根据其目标分为以下三类：

• 创建型形式：处理东西的创建过程，包含工厂形式、单例形式跟制作者形式等。
• 构外型形式：处理类跟东西的组合，包含适配器形式、装潢器形式跟代办形式等。
• 行动型形式：侧重于东西间的通信跟交互，包含战略形式、察看者形式跟命令形式等。

创建型形式

工厂形式（Factory Pattern）

工厂形式用于创建东西，并暗藏创建逻辑，解耦客户端代码与具体类。它包含工厂类跟产品类。

class Product {
public:
    virtual ~Product() {}
};

class ConcreteProductA : public Product {
public:
    // 实现具体产品A
};

class ConcreteProductB : public Product {
public:
    // 实现具体产品B
};

class Factory {
public:
    static Product* CreateProduct(std::string type) {
        if (type == "A") {
            return new ConcreteProductA();
        } else if (type == "B") {
            return new ConcreteProductB();
        }
        return nullptr;
    }
};

单例形式（Singleton Pattern）

单例形式确保一个类只有一个实例，并供给全局拜访点。

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;
    }
};

制作者形式（Builder Pattern）

制作者形式分步构建复杂东西，支撑可选设置。

class Builder {
public:
    virtual void BuildPartA() = 0;
    virtual void BuildPartB() = 0;
    virtual Product* GetResult() = 0;
};

class ConcreteBuilder : public Builder {
private:
    Product* product;
public:
    ConcreteBuilder() : product(new Product()) {}
    void BuildPartA() override {
        product->AddPartA();
    }
    void BuildPartB() override {
        product->AddPartB();
    }
    Product* GetResult() override {
        return product;
    }
};

class Director {
public:
    Builder* builder;
    Director(Builder* b) : builder(b) {}
    void Construct() {
        builder->BuildPartA();
        builder->BuildPartB();
    }
};

构外型形式

适配器形式（Adapter Pattern）

适配器形式让不兼容接口的类协同任务，经由过程转换接口。

class Target {
public:
    virtual void Request() = 0;
};

class Adaptee {
public:
    void SpecificRequest() {
        // 实现特定的恳求
    }
};

class Adapter : public Target {
private:
    Adaptee* adaptee;
public:
    Adapter(Adaptee* a) : adaptee(a) {}
    void Request() override {
        adaptee->SpecificRequest();
    }
};

装潢器形式（Decorator Pattern）

装潢器形式在不改变原有东西构造的情况下，静态增加新行动。

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* c) : component(c) {}
    void Operation() override {
        component->Operation();
        // 增加新行动
    }
};

代办形式（Proxy Pattern）

代办形式作为一个占位符，用于拜访另一个东西。

class Subject {
public:
    virtual void Request() = 0;
};

class RealSubject : public Subject {
public:
    void Request() override {
        // 实现具体恳求
    }
};

class Proxy : public Subject {
private:
    RealSubject* realSubject;
public:
    Proxy(RealSubject* rs) : realSubject(rs) {}
    void Request() override {
        realSubject->Request();
    }
};

行动型形式

战略形式（Strategy Pattern）

战略形式在运转时从一组可调换的战略中抉择算法或行动。

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* s) : strategy(s) {}
    void SetStrategy(Strategy* s) {
        strategy = s;
    }
    void ContextInterface() {
        strategy->AlgorithmInterface();
    }
};

察看者形式（Observer Pattern）

察看者形式树破一对多的依附关联，当一个东西状况改变时，全部它的依附东西都会收到告诉。

class Subject {
private:
    std::list<Observer*> observers;
public:
    void Attach(Observer* o) {
        observers.push_back(o);
    }
    void Notify() {
        for (Observer* o : observers) {
            o->Update();
        }
    }
};

class Observer {
public:
    virtual void Update() = 0;
};

class ConcreteObserverA : public Observer {
public:
    void Update() override {
        // 实现具体更新
    }
};

命令形式（Command Pattern）

命令形式用一个东西封装执举举措或触发变乱所需的全部信息。

class Command {
public:
    virtual void Execute() = 0;
};

class ConcreteCommandA : public Command {
private:
    Receiver* receiver;
public:
    ConcreteCommandA(Receiver* r) : receiver(r) {}
    void Execute() override {
        receiver->Action();
    }
};

class Receiver {
public:
    void Action() {
        // 实现具体举措
    }
};

总结

面向东西计划形式是顺序员宝贵的经验总结，它有助于进步代码的可重用性、可保护性跟可扩大年夜性。经由过程本文的介绍，你应当曾经迎面向东西计划形式有了更深刻的懂得。在现实编程中，根据具体须要抉择合适的计划形式，将有助于你构建高品质、可保护的软件体系。