C++ 设计模式如何实现 - 面试题

C++ 设计模式

设计模式是软件设计中常见问题的可重用解决方案，C++ 作为一门强大的面向对象语言，非常适合实现各种设计模式。

创建型模式

单例模式（Singleton）：

cpp
class Singleton {
private:
    static Singleton* instance;
    Singleton() = default;
    ~Singleton() = default;
    
public:
    Singleton(const Singleton&) = delete;
    Singleton& operator=(const Singleton&) = delete;
    
    static Singleton& getInstance() {
        static Singleton instance;
        return instance;
    }
    
    void doSomething() {
        std::cout << "Singleton doing something" << std::endl;
    }
};

// 使用
Singleton& singleton = Singleton::getInstance();
singleton.doSomething();

工厂模式（Factory）：

cpp
// 抽象产品
class Product {
public:
    virtual ~Product() = default;
    virtual void operation() = 0;
};

// 具体产品
class ConcreteProductA : public Product {
public:
    void operation() override {
        std::cout << "Product A operation" << std::endl;
    }
};

class ConcreteProductB : public Product {
public:
    void operation() override {
        std::cout << "Product B operation" << std::endl;
    }
};

// 抽象工厂
class Factory {
public:
    virtual ~Factory() = default;
    virtual std::unique_ptr<Product> createProduct() = 0;
};

// 具体工厂
class FactoryA : public Factory {
public:
    std::unique_ptr<Product> createProduct() override {
        return std::make_unique<ConcreteProductA>();
    }
};

class FactoryB : public Factory {
public:
    std::unique_ptr<Product> createProduct() override {
        return std::make_unique<ConcreteProductB>();
    }
};

// 使用
std::unique_ptr<Factory> factory = std::make_unique<FactoryA>();
auto product = factory->createProduct();
product->operation();

建造者模式（Builder）：

cpp
class Computer {
private:
    std::string cpu;
    std::string gpu;
    int ram;
    
public:
    void setCPU(const std::string& cpu) { this->cpu = cpu; }
    void setGPU(const std::string& gpu) { this->gpu = gpu; }
    void setRAM(int ram) { this->ram = ram; }
    
    void show() {
        std::cout << "CPU: " << cpu << ", GPU: " << gpu 
                  << ", RAM: " << ram << "GB" << std::endl;
    }
};

class ComputerBuilder {
private:
    Computer computer;
    
public:
    ComputerBuilder& setCPU(const std::string& cpu) {
        computer.setCPU(cpu);
        return *this;
    }
    
    ComputerBuilder& setGPU(const std::string& gpu) {
        computer.setGPU(gpu);
        return *this;
    }
    
    ComputerBuilder& setRAM(int ram) {
        computer.setRAM(ram);
        return *this;
    }
    
    Computer build() {
        return computer;
    }
};

// 使用
Computer computer = ComputerBuilder()
    .setCPU("Intel i9")
    .setGPU("NVIDIA RTX 4090")
    .setRAM(32)
    .build();
computer.show();

结构型模式

适配器模式（Adapter）：

cpp
// 目标接口
class Target {
public:
    virtual ~Target() = default;
    virtual void request() = 0;
};

// 被适配者
class Adaptee {
public:
    void specificRequest() {
        std::cout << "Adaptee specific request" << std::endl;
    }
};

// 适配器
class Adapter : public Target {
private:
    std::unique_ptr<Adaptee> adaptee;
    
public:
    Adapter() : adaptee(std::make_unique<Adaptee>()) {}
    
    void request() override {
        adaptee->specificRequest();
    }
};

// 使用
std::unique_ptr<Target> target = std::make_unique<Adapter>();
target->request();

装饰器模式（Decorator）：

cpp
// 组件接口
class Component {
public:
    virtual ~Component() = default;
    virtual void operation() = 0;
};

// 具体组件
class ConcreteComponent : public Component {
public:
    void operation() override {
        std::cout << "ConcreteComponent operation" << std::endl;
    }
};

// 装饰器基类
class Decorator : public Component {
private:
    std::unique_ptr<Component> component;
    
public:
    Decorator(std::unique_ptr<Component> comp) : component(std::move(comp)) {}
    
    void operation() override {
        component->operation();
    }
};

// 具体装饰器
class ConcreteDecoratorA : public Decorator {
public:
    ConcreteDecoratorA(std::unique_ptr<Component> comp) : Decorator(std::move(comp)) {}
    
    void operation() override {
        Decorator::operation();
        addedBehavior();
    }
    
    void addedBehavior() {
        std::cout << "Added behavior A" << std::endl;
    }
};

// 使用
std::unique_ptr<Component> component = std::make_unique<ConcreteComponent>();
component = std::make_unique<ConcreteDecoratorA>(std::move(component));
component->operation();

外观模式（Facade）：

cpp
class SubsystemA {
public:
    void operationA() { std::cout << "Subsystem A operation" << std::endl; }
};

class SubsystemB {
public:
    void operationB() { std::cout << "Subsystem B operation" << std::endl; }
};

class SubsystemC {
public:
    void operationC() { std::cout << "Subsystem C operation" << std::endl; }
};

// 外观
class Facade {
private:
    std::unique_ptr<SubsystemA> subsystemA;
    std::unique_ptr<SubsystemB> subsystemB;
    std::unique_ptr<SubsystemC> subsystemC;
    
public:
    Facade() : subsystemA(std::make_unique<SubsystemA>()),
               subsystemB(std::make_unique<SubsystemB>()),
               subsystemC(std::make_unique<SubsystemC>()) {}
    
    void operation() {
        subsystemA->operationA();
        subsystemB->operationB();
        subsystemC->operationC();
    }
};

// 使用
Facade facade;
facade.operation();

行为型模式

观察者模式（Observer）：

cpp
#include <vector>
#include <functional>

// 观察者接口
class Observer {
public:
    virtual ~Observer() = default;
    virtual void update(const std::string& message) = 0;
};

// 主题
class Subject {
private:
    std::vector<std::reference_wrapper<Observer>> observers;
    
public:
    void attach(Observer& observer) {
        observers.push_back(observer);
    }
    
    void detach(Observer& observer) {
        observers.erase(
            std::remove_if(observers.begin(), observers.end(),
                          [&observer](auto& obs) { return &obs.get() == &observer; }),
            observers.end());
    }
    
    void notify(const std::string& message) {
        for (auto& observer : observers) {
            observer.get().update(message);
        }
    }
};

// 具体观察者
class ConcreteObserver : public Observer {
private:
    std::string name;
    
public:
    ConcreteObserver(const std::string& n) : name(n) {}
    
    void update(const std::string& message) override {
        std::cout << name << " received: " << message << std::endl;
    }
};

// 使用
Subject subject;
ConcreteObserver observer1("Observer 1");
ConcreteObserver observer2("Observer 2");

subject.attach(observer1);
subject.attach(observer2);
subject.notify("Hello observers!");

策略模式（Strategy）：

cpp
// 策略接口
class Strategy {
public:
    virtual ~Strategy() = default;
    virtual int execute(int a, int b) = 0;
};

// 具体策略
class AddStrategy : public Strategy {
public:
    int execute(int a, int b) override {
        return a + b;
    }
};

class MultiplyStrategy : public Strategy {
public:
    int execute(int a, int b) override {
        return a * b;
    }
};

// 上下文
class Context {
private:
    std::unique_ptr<Strategy> strategy;
    
public:
    void setStrategy(std::unique_ptr<Strategy> s) {
        strategy = std::move(s);
    }
    
    int executeStrategy(int a, int b) {
        return strategy->execute(a, b);
    }
};

// 使用
Context context;
context.setStrategy(std::make_unique<AddStrategy>());
std::cout << context.executeStrategy(10, 20) << std::endl;

context.setStrategy(std::make_unique<MultiplyStrategy>());
std::cout << context.executeStrategy(10, 20) << std::endl;

命令模式（Command）：

cpp
// 命令接口
class Command {
public:
    virtual ~Command() = default;
    virtual void execute() = 0;
    virtual void undo() = 0;
};

// 接收者
class Receiver {
public:
    void action() {
        std::cout << "Receiver action" << std::endl;
    }
    
    void reverseAction() {
        std::cout << "Receiver reverse action" << std::endl;
    }
};

// 具体命令
class ConcreteCommand : public Command {
private:
    Receiver& receiver;
    
public:
    ConcreteCommand(Receiver& r) : receiver(r) {}
    
    void execute() override {
        receiver.action();
    }
    
    void undo() override {
        receiver.reverseAction();
    }
};

// 调用者
class Invoker {
private:
    std::vector<std::unique_ptr<Command>> commands;
    
public:
    void setCommand(std::unique_ptr<Command> command) {
        commands.push_back(std::move(command));
    }
    
    void executeCommands() {
        for (auto& command : commands) {
            command->execute();
        }
    }
    
    void undoCommands() {
        for (auto it = commands.rbegin(); it != commands.rend(); ++it) {
            (*it)->undo();
        }
    }
};

// 使用
Receiver receiver;
Invoker invoker;

invoker.setCommand(std::make_unique<ConcreteCommand>(receiver));
invoker.setCommand(std::make_unique<ConcreteCommand>(receiver));

invoker.executeCommands();
invoker.undoCommands();

状态模式（State）：

cpp
// 状态接口
class State {
public:
    virtual ~State() = default;
    virtual void handle() = 0;
};

// 上下文
class Context {
private:
    std::unique_ptr<State> state;
    
public:
    void setState(std::unique_ptr<State> s) {
        state = std::move(s);
    }
    
    void request() {
        state->handle();
    }
};

// 具体状态
class ConcreteStateA : public State {
private:
    Context& context;
    
public:
    ConcreteStateA(Context& ctx) : context(ctx) {}
    
    void handle() override {
        std::cout << "State A handling" << std::endl;
        context.setState(std::make_unique<ConcreteStateB>(context));
    }
};

class ConcreteStateB : public State {
private:
    Context& context;
    
public:
    ConcreteStateB(Context& ctx) : context(ctx) {}
    
    void handle() override {
        std::cout << "State B handling" << std::endl;
        context.setState(std::make_unique<ConcreteStateA>(context));
    }
};

// 使用
Context context;
context.setState(std::make_unique<ConcreteStateA>(context));

context.request();  // State A
context.request();  // State B
context.request();  // State A

模板方法模式（Template Method）

cpp
// 抽象类
class AbstractClass {
public:
    virtual ~AbstractClass() = default;
    
    void templateMethod() {
        primitiveOperation1();
        primitiveOperation2();
        hook();
    }
    
protected:
    virtual void primitiveOperation1() = 0;
    virtual void primitiveOperation2() = 0;
    virtual void hook() {}  // 钩子方法，可选实现
};

// 具体类
class ConcreteClass : public AbstractClass {
protected:
    void primitiveOperation1() override {
        std::cout << "Primitive operation 1" << std::endl;
    }
    
    void primitiveOperation2() override {
        std::cout << "Primitive operation 2" << std::endl;
    }
    
    void hook() override {
        std::cout << "Hook called" << std::endl;
    }
};

// 使用
std::unique_ptr<AbstractClass> obj = std::make_unique<ConcreteClass>();
obj->templateMethod();

责任链模式（Chain of Responsibility）

cpp
// 处理者接口
class Handler {
protected:
    std::unique_ptr<Handler> next;
    
public:
    virtual ~Handler() = default;
    
    void setNext(std::unique_ptr<Handler> h) {
        next = std::move(h);
    }
    
    virtual void handleRequest(int request) {
        if (next) {
            next->handleRequest(request);
        }
    }
};

// 具体处理者
class ConcreteHandlerA : public Handler {
public:
    void handleRequest(int request) override {
        if (request >= 0 && request < 10) {
            std::cout << "Handler A handles request " << request << std::endl;
        } else {
            Handler::handleRequest(request);
        }
    }
};

class ConcreteHandlerB : public Handler {
public:
    void handleRequest(int request) override {
        if (request >= 10 && request < 20) {
            std::cout << "Handler B handles request " << request << std::endl;
        } else {
            Handler::handleRequest(request);
        }
    }
};

// 使用
auto handlerA = std::make_unique<ConcreteHandlerA>();
auto handlerB = std::make_unique<ConcreteHandlerB>();
handlerA->setNext(std::move(handlerB));

handlerA->handleRequest(5);   // Handler A
handlerA->handleRequest(15);  // Handler B

最佳实践

1. 优先使用组合而非继承

cpp
// 推荐：组合
class Engine {
public:
    void start() { std::cout << "Engine started" << std::endl; }
};

class Car {
private:
    Engine engine;
public:
    void start() { engine.start(); }
};

// 不推荐：过度继承
class Vehicle {
public:
    virtual void start() = 0;
};

class Car : public Vehicle {
public:
    void start() override { std::cout << "Car started" << std::endl; }
};

2. 使用智能指针管理对象生命周期

cpp
// 推荐
std::unique_ptr<Factory> factory = std::make_unique<FactoryA>();
auto product = factory->createProduct();

// 不推荐
Factory* factory = new FactoryA();
auto product = factory->createProduct();
delete factory;

3. 遵循 SOLID 原则

单一职责原则（SRP）
开闭原则（OCP）
里氏替换原则（LSP）
接口隔离原则（ISP）
依赖倒置原则（DIP）

4. 使用 RAII 确保资源管理

cpp
class ResourceManager {
private:
    std::unique_ptr<Resource> resource;
    
public:
    ResourceManager() : resource(std::make_unique<Resource>()) {}
    // 析构函数自动释放资源
};

5. 避免过度设计

cpp
// 简单场景不需要复杂模式
int add(int a, int b) {
    return a + b;
}

// 复杂场景才使用设计模式
class Calculator {
public:
    virtual int calculate(int a, int b) = 0;
};