接口类和抽象类在设计模式中的一些应用

C++设计模式中,有些模式需要使用接口类(Interface Class)和抽象类(Abstract Class)来实现特定的设计目标。以下是一些常见的设计模式及其需要的原因,并附上相应的代码片段。

1. 策略模式(Strategy Pattern

需要接口类:策略模式通过定义一组算法或行为接口,使得算法可以独立于使用它们的客户端而变化。

原因:策略模式需要定义一组通用的行为接口,这些接口可以在运行时动态切换。

代码片段:

cpp 复制代码
// 接口类
class Strategy {
public:
    virtual void execute() = 0;  // 纯虚函数
};

// 具体策略类
class ConcreteStrategyA : public Strategy {
public:
    void execute() override {
        std::cout << "Executing strategy A\n";
    }
};

class ConcreteStrategyB : public Strategy {
public:
    void execute() override {
        std::cout << "Executing strategy B\n";
    }
};

// 上下文类
class Context {
private:
    Strategy* strategy;

public:
    Context(Strategy* s) : strategy(s) {}
    void setStrategy(Strategy* s) {
        strategy = s;
    }

    void executeStrategy() {
        strategy->execute();
    }
};

// 使用策略模式
int main() {
    Context context(new ConcreteStrategyA());
    context.executeStrategy();  // 输出 "Executing strategy A"
    context.setStrategy(new ConcreteStrategyB());
    context.executeStrategy();  // 输出 "Executing strategy B"
    return 0;
}

2. 工厂方法模式(Factory Method Pattern

需要抽象类:工厂方法模式通过定义一个创建对象的接口,但将具体类的实例化延迟到子类中。

原因:工厂方法模式需要定义一个抽象类,用于定义创建对象的接口,并让子类实现具体的产品创建逻辑。

代码片段:

cpp 复制代码
// 抽象产品类
class Product {
public:
    virtual void use() = 0;  // 纯虚函数
};

// 具体产品类
class ConcreteProductA : public Product {
public:
    void use() override {
        std::cout << "Using product A\n";
    }
};

class ConcreteProductB : public Product {
public:
    void use() override {
        std::cout << "Using product B\n";
    }
};

// 抽象工厂类
class Creator {
public:
    virtual Product* factoryMethod() = 0;  // 纯虚函数
};

// 具体工厂类
class ConcreteCreatorA : public Creator {
public:
    Product* factoryMethod() override {
        return new ConcreteProductA();
    }
};

class ConcreteCreatorB : public Creator {
public:
    Product* factoryMethod() override {
        return new ConcreteProductB();
    }
};

// 使用工厂方法模式
int main() {
    Creator* creator = new ConcreteCreatorA();
    Product* product = creator->factoryMethod();
    product->use();  // 输出 "Using product A"

    creator = new ConcreteCreatorB();
    product = creator->factoryMethod();
    product->use();  // 输出 "Using product B"
    return 0;
}

3. 观察者模式(Observer Pattern

需要接口类:观察者模式通过定义观察者和主题的接口,使得主题状态发生变化时,所有观察者都能得到通知。

原因:观察者模式需要定义通用的观察者和主题接口,以便在运行时动态添加和移除观察者。

代码片段:

cpp 复制代码
// 接口类:观察者
class Observer {
public:
    virtual void update(int value) = 0;  // 纯虚函数
};

// 具体观察者类
class ConcreteObserverA : public Observer {
public:
    void update(int value) override {
        std::cout << "Observer A received update: " << value << "\n";
    }
};

class ConcreteObserverB : public Observer {
public:
    void update(int value) override {
        std::cout << "Observer B received update: " << value << "\n";
    }
};

// 主题类
class Subject {
private:
    std::vector<Observer*> observers;
    int state;

public:
    void attach(Observer* observer) {
        observers.push_back(observer);
    }

    void setState(int value) {
        state = value;
        notifyObservers();
    }

    void notifyObservers() {
        for (Observer* observer : observers) {
            observer->update(state);
        }
    }
};

// 使用观察者模式
int main() {
    Subject subject;
    ConcreteObserverA observerA;
    ConcreteObserverB observerB;

    subject.attach(&observerA);
    subject.attach(&observerB);
    subject.setState(10);  // 输出 "Observer A received update: 10" 和 "Observer B received update: 10"

    return 0;
}

4. 模板方法模式(Template Method Pattern

需要抽象类:模板方法模式通过定义一个算法的骨架,将某些步骤延迟到子类中实现。

原因:模板方法模式需要定义一个抽象类,用于定义算法的骨架,并让子类实现具体的步骤。

代码片段:

cpp 复制代码
// 抽象类
class AbstractClass {
public:
    void templateMethod() {
        step1();
        step2();
        step3();
    }

    virtual void step1() = 0;  // 纯虚函数
    virtual void step2() = 0;  // 纯虚函数
    void step3() {
        std::cout << "Step 3 in AbstractClass\n";
    }
};


// 具体子类
class ConcreteClassA : public AbstractClass {
public:
    void step1() override {
        std::cout << "Step 1 in ConcreteClassA\n";
    }

    void step2() override {
        std::cout << "Step 2 in ConcreteClassA\n";
    }
};

class ConcreteClassB : public AbstractClass {
public:
    void step1() override {
        std::cout << "Step 1 in ConcreteClassB\n";
    }

    void step2() override {
        std::cout << "Step 2 in ConcreteClassB\n";
    }
};

// 使用模板方法模式
int main() {
    AbstractClass* obj1 = new ConcreteClassA();
    AbstractClass* obj2 = new ConcreteClassB();

    obj1->templateMethod();
    // 输出 "Step 1 in ConcreteClassA"
    // 输出 "Step 2 in ConcreteClassA"
    // 输出 "Step 3 in AbstractClass"

    obj2->templateMethod();
    // 输出 "Step 1 in ConcreteClassB"
    // 输出 "Step 2 in ConcreteClassB"
    // 输出 "Step 3 in AbstractClass"

    delete obj1;
    delete obj2;
    return 0;
}

在C++设计模式中,命令模式(Command Pattern)、状态模式(State Pattern)、职责链模式(Chain of Responsibility Pattern)和组合模式(Composite Pattern)也都涉及使用接口类和抽象类来实现特定的设计目标。以下是对这些模式的详细说明,并附上相应的代码片段。

1. 命令模式(Command Pattern

需要接口类:命令模式通过定义命令的接口,将请求封装为对象,使得可以参数化客户端对象、记录请求队列、支持撤销操作等。

原因:命令模式需要定义一个通用的命令接口,使得不同的命令对象可以被统一处理。

代码片段:

cpp 复制代码
// 接口类:命令
class Command {
public:
    virtual void execute() = 0;  // 纯虚函数
};

// 具体命令类
class ConcreteCommandA : public Command {
private:
    std::string recipient;

public:
    ConcreteCommandA(const std::string& r) : recipient(r) {}
    void execute() override {
        std::cout << "Command A executed by " << recipient << "\n";
    }
};

class ConcreteCommandB : public Command {
private:
    std::string recipient;

public:
    ConcreteCommandB(const std::string& r) : recipient(r) {}
    void execute() override {
        std::cout << "Command B executed by " << recipient << "\n";
    }
};

// 调用者类
class Invoker {
private:
    Command* command;

public:
    void setCommand(Command* c) {
        command = c;
    }

    void executeCommand() {
        command->execute();
    }
};

// 使用命令模式
int main() {
    Invoker invoker;
    ConcreteCommandA commandA("Client A");
    ConcreteCommandB commandB("Client B");

    invoker.setCommand(&commandA);
    invoker.executeCommand();  // 输出 "Command A executed by Client A"
    invoker.setCommand(&commandB);
    invoker.executeCommand();  // 输出 "Command B executed by Client B"

    return 0;
}

2. 状态模式(State Pattern

需要接口类:状态模式通过定义状态的接口,使得对象的行为可以根据其内部状态的改变而改变。

原因:状态模式需要定义一个通用的状态接口,使得不同的状态对象可以被统一处理。

代码片段:

cpp 复制代码
// 接口类:状态
class State {
public:
    virtual void handle() = 0;  // 纯虚函数
};

// 具体状态类
class ConcreteStateA : public State {
public:
    void handle() override {
        std::cout << "Handling state A\n";
    }
};

class ConcreteStateB : public State {
public:
    void handle() override {
        std::cout << "Handling state B\n";
    }
};

// 上下文类
class Context {
private:
    State* state;

public:
    void setState(State* s) {
        state = s;
    }

    void request() {
        state->handle();
    }
};

// 使用状态模式
int main() {
    Context context;
    ConcreteStateA stateA;
    ConcreteStateB stateB;

    context.setState(&stateA);
    context.request();  // 输出 "Handling state A"

    context.setState(&stateB);
    context.request();  // 输出 "Handling state B"
    return 0;
}

3. 职责链模式(Chain of Responsibility Pattern

需要接口类:职责链模式通过定义处理请求的接口,将多个处理者链接在一起,使得请求可以沿着链进行传递,直到被处理为止。

原因:职责链模式需要定义一个通用的处理者接口,使得不同的处理者可以被统一处理。

代码片段:

cpp 复制代码
// 接口类:处理者
class Handler {
protected:
    Handler* next;

public:
    void setNext(Handler* n) {
        next = n;
    }

    virtual void handleRequest(int request) = 0;  // 纯虚函数
};

// 具体处理者类
class ConcreteHandlerA : public Handler {
public:
    void handleRequest(int request) override {
        if (request < 10) {
            std::cout << "ConcreteHandlerA handled request " << request << "\n";
        } else if (next != nullptr) {
            next->handleRequest(request);
        }
    }
};

class ConcreteHandlerB : public Handler {
public:
    void handleRequest(int request) override {
        if (request >= 10 && request < 20) {
            std::cout << "ConcreteHandlerB handled request " << request << "\n";
        } else if (next != nullptr) {
            next->handleRequest(request);
        }
    }
};

// 使用职责链模式
int main() {
    ConcreteHandlerA handlerA;
    ConcreteHandlerB handlerB;

    handlerA.setNext(&handlerB);
    handlerA.handleRequest(5);   // 输出 "ConcreteHandlerA handled request 5"
    handlerA.handleRequest(15);  // 输出 "ConcreteHandlerB handled request 15"
    handlerA.handleRequest(25);  // 没有处理者处理该请求
    return 0;
}

4. 组合模式(Composite Pattern

需要抽象类:组合模式通过定义组合对象和叶子对象的接口,使得客户端可以统一处理单个对象和组合对象。

原因:组合模式需要定义一个通用的组件接口,使得叶子节点和组合节点可以被统一处理。

代码片段:

cpp 复制代码
// 抽象类:组件
class Component {
public:
    virtual void operation() = 0;  // 纯虚函数
    virtual void add(Component* component) {}
    virtual void remove(Component* component) {}
    virtual Component* getChild(int index) { return nullptr; }
};

// 叶子类
class Leaf : public Component {
public:
    void operation() override {
        std::cout << "Leaf operation\n";
    }
};

// 组合类
class Composite : public Component {
private:
    std::vector<Component*> children;

public:
    void operation() override {
        std::cout << "Composite operation\n";
        for (Component* child : children) {
            child->operation();
        }
    }

    void add(Component* component) override {
        children.push_back(component);
    }

    void remove(Component* component) override {
        children.erase(std::remove(children.begin(), children.end(), component), children.end());
    }

    Component* getChild(int index) override {
        return children[index];
    }
};

// 使用组合模式
int main() {
    Composite root;
    Leaf leaf1;
    Leaf leaf2;
    Composite branch;

    branch.add(&leaf1);
    branch.add(&leaf2);
    root.add(&branch);

    root.operation();

    // 输出 "Composite operation"
    // 输出 "Leaf operation"
    // 输出 "Leaf operation"

    return 0;
}

总结

  • 策略模式:需要接口类来定义一组通用的行为接口。
  • 工厂方法模式:需要抽象类来定义创建对象的接口,并让子类实现具体的产品创建逻辑。
  • 观察者模式:需要接口类来定义观察者和主题的接口,以便在运行时动态添加和移除观察者。
  • 模板方法模式:需要抽象类来定义算法的骨架,并让子类实现具体的步骤。
  • 命令模式:需要接口类来定义命令的接口,使得可以参数化客户端对象、记录请求队列、支持撤销操作等。
  • 状态模式:需要接口类来定义状态的接口,使得对象的行为可以根据其内部状态的改变而改变。
  • 职责链模式:需要接口类来定义处理请求的接口,使得请求可以沿着链进行传递,直到被处理为止。
  • 组合模式:需要抽象类来定义组合对象和叶子对象的接口,使得客户端可以统一处理单个对象和组合对象。

这些设计模式通过接口类和抽象类,提供了灵活的、可扩展的解决方案,有效地解决了软件设计中的常见问题。

相关推荐
Ni-Guvara22 分钟前
对象优化及右值引用优化(四)
开发语言·c++
树不懒1 小时前
【设计模式】关联关系与依赖关系
设计模式
随心............1 小时前
python设计模式
java·开发语言·设计模式
Ddddddd_1582 小时前
C++ | Leetcode C++题解之第560题和为K的子数组
c++·leetcode·题解
夏天匆匆2过3 小时前
linux性能提升之sendmmsg和recvmmsg
linux·c++·单片机·网络协议·udp·tcp
Jack黄从零学c++3 小时前
设计模式——策略模式(c++)
c++·设计模式·策略模式
编程修仙3 小时前
java的单例设计模式
java·单例模式·设计模式
Light603 小时前
低代码集成多方API的简单实现
低代码·设计模式
MinBadGuy3 小时前
【GeekBand】C++设计模式笔记10_Prototype_原型模式
c++·设计模式·原型模式
吾与谁归in4 小时前
【C#设计模式(5)——原型模式(Prototype Pattern)】
设计模式·c#·原型模式