51CTO 【夏CJ13912】C++ 设计模式理论与实战大全-架构师必学视频课程

原创

用户youkeit-xyz

发布于 2025-10-06 16:49:39

2380

C++ 设计模式理论与实战大全 - 架构师必学

一、设计模式概述

1.1 设计模式定义

设计模式是软件设计中常见问题的典型解决方案，是经过验证的、可重用的设计经验总结。它们不是可以直接转换为代码的完整设计，而是解决特定问题的模板或指导方针。

1.2 设计模式分类

根据《设计模式：可复用面向对象软件的基础》(GoF)一书，设计模式分为三大类：

创建型模式：处理对象创建机制
结构型模式：处理类和对象的组合
行为型模式：处理对象间的通信

1.3 学习设计模式的重要性

提高代码复用性
增强系统可维护性
提升团队沟通效率
优化系统架构设计

二、创建型模式

2.1 单例模式 (Singleton)

意图：确保一个类只有一个实例，并提供全局访问点。

C++实现：

Cpp



class Singleton {
public:
    static Singleton& getInstance() {
        static Singleton instance; // 线程安全(C++11起)
        return instance;
    }
    
    // 删除拷贝构造函数和赋值运算符
    Singleton(const Singleton&) = delete;
    Singleton& operator=(const Singleton&) = delete;

private:
    Singleton() {} // 私有构造函数
};

应用场景：

配置管理器
日志系统
数据库连接池

2.2 工厂方法模式 (Factory Method)

意图：定义一个创建对象的接口，但让子类决定实例化哪个类。

C++实现：

Cpp



class Product {
public:
    virtual ~Product() {}
    virtual void operation() = 0;
};

class ConcreteProductA : public Product {
public:
    void operation() override {
        std::cout << "ConcreteProductA operation\n";
    }
};

class Creator {
public:
    virtual ~Creator() {}
    virtual Product* createProduct() = 0;
    
    void someOperation() {
        Product* product = createProduct();
        product->operation();
        delete product;
    }
};

class ConcreteCreatorA : public Creator {
public:
    Product* createProduct() override {
        return new ConcreteProductA();
    }
};

应用场景：

框架设计
跨平台UI组件创建
插件系统

2.3 抽象工厂模式 (Abstract Factory)

意图：提供一个接口，用于创建相关或依赖对象的家族，而不需要指定具体类。

C++实现：

Cpp



class AbstractProductA {
public:
    virtual ~AbstractProductA() {}
    virtual void operationA() = 0;
};

class ProductA1 : public AbstractProductA {
public:
    void operationA() override {
        std::cout << "ProductA1 operation\n";
    }
};

class AbstractProductB {
public:
    virtual ~AbstractProductB() {}
    virtual void operationB() = 0;
};

class ProductB1 : public AbstractProductB {
public:
    void operationB() override {
        std::cout << "ProductB1 operation\n";
    }
};

class AbstractFactory {
public:
    virtual ~AbstractFactory() {}
    virtual AbstractProductA* createProductA() = 0;
    virtual AbstractProductB* createProductB() = 0;
};

class ConcreteFactory1 : public AbstractFactory {
public:
    AbstractProductA* createProductA() override {
        return new ProductA1();
    }
    
    AbstractProductB* createProductB() override {
        return new ProductB1();
    }
};

应用场景：

GUI工具包
跨平台应用
数据库访问层

三、结构型模式

3.1 适配器模式 (Adapter)

意图：将一个类的接口转换成客户希望的另一个接口。

C++实现：

Cpp



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

class Adaptee {
public:
    void specificRequest() {
        std::cout << "Adaptee specific request\n";
    }
};

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

应用场景：

旧系统集成
第三方库适配
接口兼容

3.2 装饰器模式 (Decorator)

意图：动态地给一个对象添加一些额外的职责。

C++实现：

Cpp



class Component {
public:
    virtual ~Component() {}
    virtual void operation() = 0;
};

class ConcreteComponent : public Component {
public:
    void operation() override {
        std::cout << "ConcreteComponent operation\n";
    }
};

class Decorator : public Component {
protected:
    Component* component;
public:
    Decorator(Component* c) : component(c) {}
    
    void operation() override {
        if (component) {
            component->operation();
        }
    }
};

class ConcreteDecoratorA : public Decorator {
public:
    ConcreteDecoratorA(Component* c) : Decorator(c) {}
    
    void operation() override {
        Decorator::operation();
        addedBehavior();
    }
    
    void addedBehavior() {
        std::cout << "Added behavior from ConcreteDecoratorA\n";
    }
};

应用场景：

GUI组件增强
I/O流处理
权限控制

四、行为型模式

4.1 观察者模式 (Observer)

意图：定义对象间的一种一对多的依赖关系，当一个对象状态改变时，所有依赖它的对象都得到通知并自动更新。

C++实现：

Cpp



#include <vector>
#include <algorithm>

class Observer {
public:
    virtual ~Observer() {}
    virtual void update(int value) = 0;
};

class Subject {
private:
    std::vector<Observer*> observers;
    int state;
public:
    void attach(Observer* observer) {
        observers.push_back(observer);
    }
    
    void detach(Observer* observer) {
        observers.erase(std::remove(observers.begin(), observers.end(), observer), observers.end());
    }
    
    void notify() {
        for (Observer* observer : observers) {
            observer->update(state);
        }
    }
    
    void setState(int value) {
        state = value;
        notify();
    }
};

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

应用场景：

事件处理系统
数据监控
MVC架构

4.2 策略模式 (Strategy)

意图：定义一系列算法，将每个算法封装起来，并使它们可以互相替换。

C++实现：

Cpp



class Strategy {
public:
    virtual ~Strategy() {}
    virtual void execute() = 0;
};

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

class Context {
private:
    Strategy* strategy;
public:
    Context(Strategy* s) : strategy(s) {}
    
    void setStrategy(Strategy* s) {
        strategy = s;
    }
    
    void executeStrategy() {
        strategy->execute();
    }
};

应用场景：

排序算法选择
支付方式选择
压缩算法选择

五、现代C++设计模式实现技巧

5.1 使用智能指针

Cpp



#include <memory>

class ModernSingleton {
public:
    static ModernSingleton& getInstance() {
        static ModernSingleton instance;
        return instance;
    }
    
    ModernSingleton(const ModernSingleton&) = delete;
    ModernSingleton& operator=(const ModernSingleton&) = delete;

private:
    ModernSingleton() = default;
};

class ModernProduct {
public:
    virtual ~ModernProduct() = default;
    virtual void operation() = 0;
};

using ProductPtr = std::unique_ptr<ModernProduct>;

5.2 使用lambda表达式

Cpp



class ModernStrategy {
public:
    using StrategyFunc = std::function<void()>;
    
    void setStrategy(StrategyFunc func) {
        strategyFunc = func;
    }
    
    void execute() {
        if (strategyFunc) {
            strategyFunc();
        }
    }

private:
    StrategyFunc strategyFunc;
};

5.3 使用模板元编程

Cpp



template <typename T>
class GenericSingleton {
public:
    static T& getInstance() {
        static T instance;
        return instance;
    }
    
    GenericSingleton(const GenericSingleton&) = delete;
    GenericSingleton& operator=(const GenericSingleton&) = delete;

protected:
    GenericSingleton() = default;
};

六、设计模式实战案例分析

6.1 游戏开发中的设计模式应用

案例：游戏角色创建系统

使用工厂方法创建不同角色类型
使用装饰器模式添加角色装备和能力
使用观察者模式处理角色状态变化

6.2 金融系统中的设计模式应用

案例：交易处理系统

使用策略模式实现不同交易算法
使用命令模式实现交易撤销/重做
使用责任链模式实现交易审批流程

七、设计模式选择与组合原则

单一职责原则：一个类应该只有一个引起变化的原因
开闭原则：对扩展开放，对修改关闭
里氏替换原则：子类必须能够替换它们的基类
接口隔离原则：客户端不应该被迫依赖它们不使用的接口
依赖倒置原则：高层模块不应该依赖低层模块，两者都应该依赖抽象

八、常见设计模式误用与陷阱

过度设计：在不必要时使用设计模式
模式滥用：强行套用模式导致代码复杂化
忽视语言特性：现代C++特性可以简化某些模式的实现
性能忽视：某些模式可能带来性能开销

九、设计模式与软件架构

分层架构中的模式应用
微服务架构中的模式选择
事件驱动架构与观察者、中介者模式
领域驱动设计与工厂、仓储模式

十、设计模式面试精要

10.1 高频面试问题

单例模式的线程安全问题
工厂方法与抽象工厂的区别
装饰器与代理模式的区别
观察者与发布-订阅模式的区别

10.2 设计模式代码题

实现线程安全的懒汉式单例
使用策略模式实现排序算法选择
使用观察者模式实现简单的事件系统

结语

设计模式是软件架构师的必备工具，但切记它们是手段而非目的。在C++开发中，结合现代C++特性，可以更优雅地实现各种设计模式。掌握设计模式的本质思想比记住具体实现更为重要，灵活运用才能设计出高质量、可维护的软件系统。

原创声明：本文系作者授权腾讯云开发者社区发表，未经许可，不得转载。

如有侵权，请联系 cloudcommunity@tencent.com 删除。

c++

原创声明：本文系作者授权腾讯云开发者社区发表，未经许可，不得转载。

如有侵权，请联系 cloudcommunity@tencent.com 删除。

c++

登录后参与评论

0 条评论

热度