设计模式 on 奕晨's blog

奇异模板

Mon, 10 Mar 2025 00:00:00 +0000

引言

奇异递归模板模式（Curiously Recurring Template Pattern，简称 CRTP），也被称为奇异模板，是 C++ 中的一种模板编程技术。它允许基类使用派生类的类型信息，实现了一种编译时多态。

奇异递归模板模式

奇异递归模板是一种利用模板技术实现的编译时多态，允许一个类在调用函数的时候实现不同的方法。

实现方法：

基类使用模板类，模板参数代表了派生类类型
函数里将基类指针(this)转为派生类指针并调用派生类的实现方法，达到对于传入的不同派生类实现不同的方法。
派生类要继承基类，并将自己的类型传入到模板参数当中

代码实现

// 基类模板
template <typename Derived>
class Shape {
public:
    void draw() {
        std::cout << "所有类型draw的公用代码" << std::endl;		//进行复用，不用每个类型都写一份
        static_cast<Derived*>(this)->drawImpl();
    }
};

// 派生类：Circle
class Circle : public Shape<Circle> {
public:
    void drawImpl() {
        std::cout << "Drawing a circle." << std::endl;
    }
};

// 派生类：Square
class Square : public Shape<Square> {
public:
    void drawImpl() {
        std::cout << "Drawing a square." << std::endl;
    }
};

int main() {
    Circle circle;
    Square square;

    circle.draw();
    square.draw();
}

奇异模板特性

特点

动态多态实现

class Shape {
public:
    void draw() {
        std::cout << "所有类型draw的公用代码" << std::endl;
        drawImp();
    }
    virtual void drawImp() = 0;
};

class Circle : public Shape {
public:
    void drawImp() {
        std::cout << "Drawing a circle." << std::endl;
    }
};

class Square : public Shape {
public:
    void drawImp() {
        std::cout << "Drawing a square." << std::endl;
    }
};

int main() {
    Shape* circle = new Circle;
    Shape* square = new Square;

    circle->draw();
    square->draw();
}

奇异模板相较于动态多态，它在编译时确定，避免了运行时虚函数表的查询。
不需要虚函数表，内存占用较小

通过函数调用实现多态

template <typename Derived>
class Shape {
public:
    void draw() {
        std::cout << "shared draw" << std::endl;
        static_cast<Derived*>(this)->drawImpl();
    }
};

// 派生类：Circle
class Circle : public Shape<Circle> {
public:
    void drawImpl() {
        std::cout << "Drawing a circle." << std::endl;
    }
};

// 派生类：Square
class Square : public Shape<Square> {
public:
    void drawImpl() {
        std::cout << "Drawing a square." << std::endl;
    }
};

template<typename Shape>
void Draw(Shape& shape) {
    shape.draw();
}

int main() {
    Circle circle;
    Square square;

    Draw(circle);
    Draw(square);
}

其对应的动态多态形式

class Shape {
public:
    void draw() {
        std::cout << "所有类型draw的公用代码" << std::endl;
        drawImp();
    }
    virtual void drawImp() = 0;
};

class Circle : public Shape {
public:
    void drawImp() {
        std::cout << "Drawing a circle." << std::endl;
    }
};

class Square : public Shape {
public:
    void drawImp() {
        std::cout << "Drawing a square." << std::endl;
    }
};

void Draw(Shape* shape) {
    shape->draw();
}

int main() {
    Shape* circle = new Circle;
    Shape* square = new Square;

    Draw(circle);
    Draw(square);
}

观察者模式

Sat, 08 Mar 2025 00:00:00 +0000

引言

观察者模式（Observer Pattern）是一种行为设计模式，它定义了对象之间的一对多依赖关系，使得当一个对象的状态发生改变时，所有依赖于它的对象都会自动收到通知并更新。这种模式通常用于实现事件处理系统、发布-订阅模型等。

观察者模式

试想这样一个场景，有一个超市，里面有很多员工，他们需要共同管理这个超市
- 当员工入职的时候，员工就会与超市产生联系，订阅超市信息
- 这个时候，一个员工提出超市售卖商品进行折扣售卖，被超市采纳了。此时超市的相关信息被更改了，这时候超市就要通知所有的员工，不再按照原来价格进行售卖，而是用折扣价进行售卖。
- 过了几天后，又有个员工提出了另一种营销策略，被超市采纳，超市也要通知所有员工新的售卖策略

上述的情景就用到了观察者模式，超市是被观察的对象，员工就是观察者，当被观察的对象信息发生改变，就要告诉所有的观察者信息改变，观察者也能根据信息改变进行自己的处理。

源码实现

//有一个抽象的观察者，观察某一个行为，并针对这一行为有一个抽象的处理
//具体的观察者继承继承抽象的观察者，同时实现自己的具体的处理
//对于被观察的行为，行为的发起者有一个观察者列表，发起行为时，调用所有观察者的具体处理

#include <iostream>
#include <vector>

using namespace std;

class AbstractObserver {
public:
    virtual void DoProcess(int num) = 0;        //通知观察者对象，需要进行重写
    virtual void ChangeSubject(int data) = 0;
    virtual ~AbstractObserver() = default;
};

class AbstractSubject {
public:
    virtual ~AbstractSubject() = default;
    virtual void ChangeData(int) = 0;
    virtual void NotifyObservers() = 0;

    void AddObserver(AbstractObserver* observer) {observers.push_back(observer);}

    void RemoveObserver(const AbstractObserver* observer) {
        for (auto it = observers.begin(); it != observers.end(); ++it) {
            if (*it == observer) {
                observers.erase(it);
            }
        }
    }

protected:
    vector<AbstractObserver*> observers;
};

class Observer1 final : public AbstractObserver {
public:
    explicit Observer1(AbstractSubject* subject) : subject_(subject) {
        subject_->AddObserver(this);
    }
    void DoProcess(const int num) override {cout << "Observer1 : " << num << endl;}
    void ChangeSubject(const int data) override {subject_->ChangeData(data);}
private:
    AbstractSubject* subject_;
};

class Observer2 final : public AbstractObserver {
public:
    explicit Observer2(AbstractSubject* subject) : subject_(subject) {
        subject_->AddObserver(this);
    }
    void DoProcess(const int num) override {cout << "Observer2 : " << num << endl;}
    void ChangeSubject(const int data) override {subject_->ChangeData(data);}
private:
    AbstractSubject* subject_;
};

class Observer3 final : public AbstractObserver {
public:
    explicit Observer3(AbstractSubject* subject) : subject_(subject) {
        subject_->AddObserver(this);
    }
    void DoProcess(const int num) override {cout << "Observer3 : " << num << endl;}
    void ChangeSubject(const int data) override {subject_->ChangeData(data);}
private:
    AbstractSubject* subject_;
};

class Subject final : public AbstractSubject {
public:
    explicit Subject(const int data = 0) : data_(data){}
    void ChangeData(const int data) override {
        data_ = data;
        NotifyObservers();
    }

    void NotifyObservers() override {
        for (const auto & observer : observers) {
            observer -> DoProcess(data_);
        }
    }

private:
    int data_;
};

int main() {
    AbstractSubject* subject = new Subject();

    AbstractObserver* observer1 = new Observer1(subject);
    AbstractObserver* observer2 = new Observer2(subject);
    AbstractObserver* observer3 = new Observer3(subject);

    observer1 -> ChangeSubject(2);  //观察者1更改目标，所有观察者都应该显示更改后的目标

    cout << "-------------------------------" << endl;

    observer2 -> ChangeSubject(612);  //观察者2更改目标，所有观察者都应该显示更改后的目标

    subject -> RemoveObserver(observer1);   //删除1号观察者

    cout << "-------------------------------" << endl;

    observer3 -> ChangeSubject(100);  //观察者3更改目标，所有观察者都应该显示更改后的目标

    delete subject;
    delete observer1;
    delete observer2;
    delete observer3;
}

下面就来说明上面代码中每一个类的作用

AbstractObserver：抽象观察者类，
- 提供了修改被观察对象的纯虚函数
- 提供了对被观察对象信息变化后进行处理的纯虚函数
Observer1，2，3：具体观察者类，继承了抽象观察者类
- 具有抽象被观察对象的指针，构造函数可以传入不同的具体被观察对象
- 实现了基类的纯虚函数，实现更改被观察对象的信息，以及观察对象信息改变后自己要做的事情（DoProcess）。
AbstractSubject：抽象被观察对象类
- 提供了观察者集合
- 提供了增加观察者和删除观察者的函数（已经实现）
- 提供了更改数据和通知观察者的纯虚函数
Subject：具体的被观察对象类，继承了抽象的被观察对象类
- 重写更改数据的纯虚函数，并在调用通知函数
- 重新通知函数，调用每一个观察者的DoProcess函数，并将被修改的数据传入进去

使用的时候，用抽象被观察对象类型指针接受一个具体的被观察对象指针，新建具体观察者的时候，传入这个指针（将被观察对象和观察者联系起来）。当一个观察者调用ChangeSubject时，其被观察对象会调用ChangeData函数更改信息，ChangeData函数里面还会调用NotifyObservers函数，在NotifyObservers函数里面，所有观察者会调用DoProcess应对被观察对象的数据变化。

模板方法和策略模式

Thu, 06 Mar 2025 00:00:00 +0000

引言

模板方法模式和策略模式都是行为设计模式，它们的目标都是通过封装算法来提高代码的灵活性和可维护性。然而，它们的实现方式和适用场景有所不同。下面就会介绍这两种设计模式

模板方法模式

模板方法的核心思想就是，将操作步骤固定(相当于给你了一个模板)，而实现这些步骤的方法是可以替换的。

举个例子，班主任想要对班级同学的成绩进行统计并进行排序，学校规定使用了一种软件，这种软件需要人为完成一些步骤才能实现统计。
- 将成绩登记到电脑上
- 对数据进行排序
- 公布成绩（不要这样做！！！不要打击学生的自尊心）
我们必须严格按照学校的要求来做，但是我们可以通过不同的方法来完成学校的要求
- 对于登记到电脑上
  - 这好像只能将成绩一个一个登记到电脑上，没有其他办法了。
- 对数据进行排序
  - 我们可以使用冒泡排序
  - 也可以使用快速排序
- 最后公布成绩
  - 我们可以只公布分数而不公布姓名
  - 我们也可以将分数和姓名一起公布（要被学生骂死了）

言归正传，这种情况下学校使用的软件相当于一个模板方法，但是有些步骤我们可以选择不同的操作方式。这就是模板方法的思想。

代码展现

class Base {
public:
    Base() = default;
    virtual ~Base() = default;
    void DoWork() {
        Step1();Step2();Step3();
        Step4();        //钩子操作，空操作，由子类选择是否可以扩展这个操作
    }

private:
    static void Step1() {std::cout << "step1" << std::endl;}
    static void Step3() {std::cout << "step3" << std::endl;}
protected:
    virtual void Step2() = 0;
    virtual void Step4() {}
};

//用户来决定使用哪些方法。
class Derived1 : public Base {
    ~Derived1() override = default;
    void Step2() override {std::cout << "derived1's step2" << std::endl;}
};

class Derived2 : public Base {
    ~Derived2() override = default;
    void Step2() override {std::cout << "derived2's step2" << std::endl;}
    void Step4() override {std::cout << "extend the hook operator" << std::endl;}
};

int main() {
    Base* p1 = new Derived1();
    Base* p2 = new Derived2();
    
    p1->DoWork();
    std::cout << "------------------" << std::endl;
    p2->DoWork();
    
    delete p1;
    delete p2;
    return 0;
}

上面的模板函数给出了四个step，其中step2已经被模板方法写死了，你只能这么做（非虚函数），但是有些step方法没有实现（纯虚函数），给了你自由度选择自己的操作方式。
我们可以看到有一个step4钩子操作，这个构造操作在基类里面通常是个空操作，用来说明在这个地方你可以选择进行一些操作来进行优化，但是如果你优化也ok，这取决与你自己的意愿。
这样用户就可以定义派生类来继承基类，重写方法来决定一要用什么具体的步骤，你也可以重写上面step4操作进行操作上的一些扩展。

策略模式

策略模式提供了一种切换算法的思想，对于一个功能，我们可以切换里面的算法来实现不同的功能。对于策略模式，程序员可以先实现不同的策略，等到需要切换策略的时候，换一种策略即可。

场景：电商平台的折扣策略
假设你在一家电商公司工作，负责实现一个购物车的结算功能。购物车需要支持多种折扣策略，例如：
1. 无折扣：原价结算。
2. 固定折扣：比如满100减10。
3. 百分比折扣：比如打8折。
4. 会员专属折扣：根据会员等级提供不同的折扣。
产品经理可能会随时调整折扣策略，或者根据促销活动动态切换折扣方式。如果每次需求变更都修改结算逻辑，代码会变得难以维护。这时，策略模式就可以派上用场了！

策略模式的核心思想
策略模式的核心是：
- 将不同的算法（或行为）封装成独立的类，并使它们可以互相替换。
- 通过组合而不是继承来实现算法的动态切换。
用策略模式实现折扣功能
- 首先我们实现一个打折的接口，再商品进行结算的时候，直接调用这些接口
- 我们可以实现不同的打折方案，在不同的时候，切换打折方案
- 这就是策略模式的思想

代码展现

// strategy
class CalcStrategy {
public:
    virtual ~CalcStrategy() = default;
    virtual int calc(int a, int b) = 0;
};

//用户拓展
class AddStrategy final : public CalcStrategy {
    int calc(const int a, const int b) override { return a + b;}
};

class SubStrategy final : public CalcStrategy {
    int calc(const int a, const int b) override { return a - b;}
};

class MulStrategy final : public CalcStrategy {
    int calc(const int a, const int b) override { return a * b;}
};

class DivStrategy final : public CalcStrategy {
    int calc(const int a, const int b) override { return a / b;}
};

//factory
class Factory {
public:
    virtual ~Factory() = default;
    virtual CalcStrategy* NewStrategy() =0;
};

//用户拓展工厂方法
class AddFactory final : public Factory {
    CalcStrategy* NewStrategy() override {return new AddStrategy;}
};

class SubFactory final : public Factory {
    CalcStrategy* NewStrategy() override {return new SubStrategy;}
};

class MulFactory final : public Factory {
    CalcStrategy* NewStrategy() override {return new MulStrategy;}
};

class DivFactory final : public Factory {
    CalcStrategy* NewStrategy() override {return new DivStrategy;}
}; //end of factory

class Calculator {
public:
    explicit Calculator(Factory* strategy_factory) {strategy_ = strategy_factory->NewStrategy();}

    int doCalc(const int a, const int b) const { return strategy_->calc(a, b);}
    ~Calculator() { delete strategy_;}

private:
    //对于策略，采用的是组合的方式来进行，可以切换不通的策略
    CalcStrategy* strategy_;
};      //end of strategy

int main() {
    Factory* add = new AddFactory();
    Factory* sub = new SubFactory();
    Factory* mul = new MulFactory();
    Factory* div = new DivFactory();

    const Calculator calculator1(add);
    std::cout << calculator1.doCalc(1,1) << std::endl;;

    const Calculator calculator2(sub);
    std::cout << calculator2.doCalc(1,1) << std::endl;;

    const Calculator calculator3(mul);
    std::cout << calculator3.doCalc(1,1) << std::endl;;

    const Calculator calculator4(div);
    std::cout << calculator4.doCalc(1,1) << std::endl;;

    delete factory1;
    delete factory2;
    delete factory3;
    delete factory4;
}

可以看出，我们有一个Calculator类用来实现一个计算的功能。
- Calculater 里面组合了一个Strategy类（可以认为功能和实现功能的策略是紧密联系的），我们可以传入不同的策略类来切换策略实现不同的功能
在本例中，我们可以通过工厂方法创建不同的策略，在创建Strategy对象的时候，传入不同的策略从而达到实现不同的功能的目的。

两种模式的对比

最后，我们再来看一下这两种模式的对比

对比维度	模板方法模式	策略模式
定义	定义算法的框架，子类可以重写部分步骤，但不改变算法结构。	定义一系列算法，封装每个算法，使它们可以互换。
核心思想	将算法的通用部分放在父类中，具体实现延迟到子类。	将算法的选择与使用分离，客户端可以动态选择不同的策略。
实现方式	基于继承，父类定义算法框架，子类实现具体步骤。	基于组合，通过接口或抽象类定义策略，具体策略由不同类实现。
灵活性	较低，算法的结构在父类中固定，子类只能改变部分步骤。	较高，客户端可以动态切换策略，算法可以完全替换。

单例模式

Sat, 01 Mar 2025 00:00:00 +0000

引言

单例设计模式（Singleton Design Pattern）是一种创建型设计模式，它确保一个类只有一个实例，并提供一个全局访问点来获取该实例。这种模式常用于需要控制资源访问、配置管理或共享资源等场景。

本文主要介绍单例设计模式的两种实现方式及其特点。

懒汉模式

懒汉模式创建单例对象，是在需要用到该对象的时候才会去创建单例对象

class Singleton {
public:
    static Singleton* getInstance(){		//需要用到的时候，调用getInstance创建单例对象
        if (nullptr == m_pSingleton) {
            m_pSingleton = new Singleton();
        }
        return m_pSingleton;
    }
private:
    static Singleton* m_pSingleton;

    Singleton() {std::cout << "create instance" << std::endl;}
    ~Singleton() {std::cout << "destroy instance" << std::endl;}

    // 删除拷贝构造函数和赋值运算符，确保单例唯一性
    Singleton(const Singleton&) = delete;
    Singleton& operator=(const Singleton&) = delete;
};

Singleton* Singleton::m_pSingleton = nullptr;

懒汉模式在多线程环境下，存在线程不安全性，当多个线程都同时调用getInstance时，如果此时并没有创建单例对象出来，那么多个线程可能同时走到nullptr == m_pSingleton当中去，这时候多个线程同时new单例对象，导致了不安全行为。

解决线程安全可以通过加锁来解决

class Singleton {
public:
    static Singleton* getInstance() {
        std::lock_guard<std::mutex> lock(mutex); // 加锁
        if (instance == nullptr) {
            instance = new Singleton();
        }
        return instance;
    }
    // 删除拷贝构造函数和赋值运算符
    Singleton(const Singleton&) = delete;
    Singleton& operator=(const Singleton&) = delete;
private:
    Singleton() {std::cout << "create instance" << std::endl;}
    ~Singleton() {std::cout << "destroy instance" << std::endl;}

    static Singleton* instance;
    static std::mutex mutex;
};

// 初始化静态成员变量
Singleton* Singleton::instance = nullptr;
std::mutex Singleton::mutex;

下面还有一种双重检查的方式，这种方式看似更加麻烦，但是也有设计巧妙的地方，读者可以好好思考一下为什么。

class Singleton {
public:
    static Singleton* getInstance() {
        if (instance == nullptr) { // 第一次检查
            std::lock_guard<std::mutex> lock(mutex); // 加锁
            if (instance == nullptr) { // 第二次检查
                instance = new Singleton();
            }
        }
        return instance;
    }

    // 删除拷贝构造函数和赋值运算符
    Singleton(const Singleton&) = delete;
    Singleton& operator=(const Singleton&) = delete;

private:
    Singleton() {std::cout << "create instance" << std::endl;}
    ~Singleton() {std::cout << "destroy instance" << std::endl;}

    static Singleton* instance;
    static std::mutex mutex;
};

// 初始化静态成员变量
Singleton* Singleton::instance = nullptr;
std::mutex Singleton::mutex;

上面这种模式为什么要检查两次呢，这不是更加麻烦吗？其实里面也有巧妙的设计。
- 如果按照只检查一次的代码，那么无论什么时候去调用getInstance()都会发生加锁动作。
- 但是双重检查版本只有在单例对象没有创建的时候才会发生加锁，当对象已经被创建之后，第一次检查nullptr == instance就会跳过加锁过程，直接返回对象。这样会大大减少加锁的开销。
2025-4-13更新

上面那种模式还会涉及一些内存顺序的问题，instance = new Singleton(); 会被分为三个步骤，分配内存，构造，将地址传给instance。但是有时候指令重排会将三个步骤重排为分配内存，将地址传给instance，构造，这时候当两个线程按下面流程进行getInstance()就会发生问题。

线程A	线程B
if (instance == nullptr)
std::lock_guard<std::mutex> lock(mutex); // 加锁
if (instance == nullptr) { // 第二次检查
分配内存
将地址给instance	(instance不再是nullptr了)
	if (instance == nullptr)
	return instance
	开始使用instance（？？？instance好像还没有构造）
构造instance

解决办法就是使用c++当中的原子操作(atomic的操作可以指定一些内存顺序，内存顺序和atomic的内容以后再更新，这里主要强调单例模式的实现)

#include <atomic>

class Singleton {
public:
    static Singleton* getInstance() {
        if (instance.load() == nullptr) {
            std::lock_guard<std::mutex> lock(mutex);
            if (instance.load() == nullptr) {
                instance.store(new Singleton()); 
            }
        }
        return tmp;
    }

    // 删除拷贝构造函数和赋值运算符
    Singleton(const Singleton&) = delete;
    Singleton& operator=(const Singleton&) = delete;

private:
    Singleton() { std::cout << "create instance" << std::endl; }
    ~Singleton() { std::cout << "destroy instance" << std::endl; }

    static std::atomic<Singleton*> instance;  // 改为 atomic
    static std::mutex mutex;
};

// 初始化
std::atomic<Singleton*> Singleton::instance(nullptr);
std::mutex Singleton::mutex;

饿汉模式

在定义对象的时候，就会创建单例对象出来，这个对象会存在程序的整个作用域。

class Singleton {
public:
    static Singleton* getInstance(){
        if (nullptr == m_pSingleton) {
            m_pSingleton = new Singleton();
        }
        return m_pSingleton;
    }
private:
    int data = 0;
    static Singleton* m_pSingleton;

    Singleton() {std::cout << "create instance" << std::endl;}
    ~Singleton() {std::cout << "destroy instance" << std::endl;}

    // 删除拷贝构造函数和赋值运算符，确保单例唯一性
    Singleton(const Singleton&) = delete;
    Singleton& operator=(const Singleton&) = delete;
};

Singleton* Singleton::m_pSingleton = getInstance();

单例对象在程序启动后就进行了创建，多线程模式下，并不会出现线程安全问题，每个线程都是直接使用已经创建的单例对象。

设计模式 on 奕晨's blog

奇异模板

引言

奇异递归模板模式

代码实现

奇异模板特性

特点

通过函数调用实现多态

观察者模式

引言

观察者模式

源码实现

模板方法和策略模式

引言

模板方法模式

代码展现

策略模式

场景：电商平台的折扣策略

策略模式的核心思想

用策略模式实现折扣功能

代码展现

两种模式的对比

单例模式

引言

懒汉模式

饿汉模式