C++ 设计模式——观察者模式

于 2024-08-20 00:23:27 发布
阅读量1.6k 收藏 35
点赞数 26
分类专栏： # C++ 设计模式 文章标签： c++ 设计模式 观察者模式
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_68194402/article/details/141329916
版权

观察者模式

观察者模式

观察者模式（Observer Pattern）是一种常用的设计模式，属于行为型模式。它定义了一种一对多的依赖关系，使得当一个对象（主题）状态发生变化时，所有依赖于它的对象（观察者）都会得到通知并自动更新。

引入“观察者”设计模式的定义（实现意图）：定义对象间的一种一对多的依赖关系，当一个对象的状态发生改变时，所有依赖于它的对象都会自动得到通知。

主要组成部分

  1. 主题（Subject）：

    • 也叫观察目标，指被观察的对象。
    • 维护观察者列表，提供添加、删除观察者的方法。
    • 当状态变化时，通知所有的观察者。

  2. 观察者（Observer）：

    • 定义一个更新接口，以便主题在状态变化时调用。
    • 每个观察者都可以根据主题的变化更新自身状态。

  3. 具体主题（ConcreteSubject）：

    • 实现主题的接口，维护具体的状态。
    • 在状态变化时，调用通知方法来更新所有观察者。

  4. 具体观察者（ConcreteObserver）：

    • 实现观察者接口，更新自身状态以反映主题的变化。
    • 每个观察者可以根据主题的状态执行特定的操作。

例一：工作流程

  1. 观察者注册到主题：在主函数中，使用 attach 方法将观察者注册到主题。
  2. 主题的状态发生变化：调用 setState 方法改变主题的状态。
  3. 主题调用通知方法：在 setState 方法中，调用 notify 方法通知所有注册的观察者。
  4. 观察者接收到通知后，更新自身状态：每个观察者实现 update 方法，接收到通知后更新自身状态并输出。
第一步：定义观察者接口

首先，定义一个观察者接口，所有观察者都需要实现这个接口。

// 观察者接口
class Observer {
public:
    virtual void update(int state) = 0; // 更新接口
};
第二步：定义主题接口

接下来，定义一个主题接口，主题需要维护观察者列表，并提供添加、删除观察者的方法。

// 主题接口
class Subject {
public:
    virtual void attach(Observer* observer) = 0; // 添加观察者
    virtual void detach(Observer* observer) = 0; // 移除观察者
    virtual void notify() = 0; // 通知观察者
};
第三步：实现具体主题

实现一个具体主题类，维护观察者列表和状态，并在状态变化时通知观察者。

#include <iostream>
#include <vector>
#include <algorithm> // 用于 std::remove

// 具体主题
class ConcreteSubject : public Subject {
private:
    std::vector<Observer*> observers; // 观察者列表
    int state; // 主题的状态

public:
    void attach(Observer* observer) override {
        observers.push_back(observer); // 添加观察者
    }

    void detach(Observer* observer) override {
        observers.erase(std::remove(observers.begin(), observers.end(), observer), observers.end()); // 移除观察者
    }

    void notify() override {
        for (Observer* observer : observers) {
            observer->update(state); // 通知所有观察者
        }
    }

    void setState(int newState) {
        state = newState; // 更新状态
        notify(); // 状态变化时通知观察者
    }

    int getState() const {
        return state; // 获取当前状态
    }
};
第四步：实现具体观察者

实现观察者类，更新自身状态以反映主题的变化。

// 具体观察者
class ConcreteObserver : public Observer {
private:
    std::string name; // 观察者名称
    int observedState; // 观察者的状态

public:
    ConcreteObserver(const std::string& name) : name(name) {}

    void update(int state) override {
        observedState = state; // 更新观察者的状态
        std::cout << "Observer " << name << " updated with state: " << observedState << std::endl;
    }
};
第五步：主函数

在主函数中，创建主题和观察者对象，注册观察者，并演示状态变化。

// 主函数
int main() {
    ConcreteSubject subject; // 创建具体主题

    ConcreteObserver observer1("Observer 1"); // 创建观察者1
    ConcreteObserver observer2("Observer 2"); // 创建观察者2

    subject.attach(&observer1); // 注册观察者1
    subject.attach(&observer2); // 注册观察者2

    subject.setState(1);  // 状态变化，通知所有观察者
    subject.setState(2);  // 状态变化，通知所有观察者

    return 0;
}
UML 图

观察者模式 UML 图一描述

UML 图解析

Subject（主题）：也叫作观察目标，指被观察的对象。这里指 Subject 类。提供增加和删除观察者对象的接口，如 attach 和 detach。

ConcreteSubject（具体主题）：维护一个观察者列表，当状态发生改变时，调用 notify 向各个观察者发出通知。这里指 ConcreteSubject 类。

Observer（观察者）：定义了观察者的接口，所有具体观察者都需要实现这个接口。当被观察的对象状态发生变化时，观察者自身会收到通知。这里指 Observer 类。

ConcreteObserver（具体观察者）：实现了观察者接口，并注册到主题。当具体目标状态发生变化时，自身会接到通知。这里指 ConcreteObserver 类。

例二：工作流程

下面是逐步实现游戏聊天系统，使用观察者模式来管理玩家之间的聊天信息，每个玩家可以选择加入或退出家族聊天，系统会自动处理通知。将按照设计思路，逐步构建代码。

  1. 观察者注册到被观察者：在主函数中，使用 addToList 方法将玩家注册到聊天通知器。
  2. 被观察者的状态发生变化：调用 SayWords 方法改变聊天内容。
  3. 被观察者调用通知方法：在 SayWords 方法中，调用 notify 方法通知所有注册的玩家。
  4. 观察者接收到通知后，更新自身状态：每个玩家实现 NotifyWords 方法，接收到通知后输出聊天信息。
第一步：定义观察者接口

首先，定义一个观察者接口，所有玩家都需要实现这个接口，以接收聊天信息的更新通知。

// 观察者接口
class Notifier {
public:
    virtual void addToList(Fighter* player) = 0; // 添加玩家
    virtual void removeFromList(Fighter* player) = 0; // 移除玩家
    virtual void notify(Fighter* talker, const std::string& message) = 0; // 通知玩家
    virtual ~Notifier() {}
};
第二步：定义主题接口

接下来，定义一个定义主题接口，玩家需要维护聊天通知器，并提供添加、删除玩家的方法。

// 被观察者接口
class Fighter {
public:
    virtual void NotifyWords(Fighter* talker, const std::string& message) = 0; // 更新接口
    virtual void SetFamilyID(int id) = 0; // 设置家族ID
    virtual int GetFamilyID() const = 0; // 获取家族ID
    virtual ~Fighter() {}
};
第三步：实现具体主题（玩家类）

实现一个具体玩家类，维护玩家名称和家族ID，并在收到聊天信息时更新状态。

#include <iostream>
#include <string>
#include <list>
#include <map>
#include <algorithm> // 用于 std::remove

// 具体主题：玩家
class ConcreteFighter : public Fighter {
private:
    std::string name; // 玩家名称
    int familyID; // 家族ID

public:
    ConcreteFighter(const std::string& playerName) : name(playerName), familyID(-1) {}

    void SetFamilyID(int id) override {
        familyID = id;
    }

    int GetFamilyID() const override {
        return familyID;
    }

    void NotifyWords(Fighter* talker, const std::string& message) override {
        std::cout << "玩家 " << name << " 收到了来自 " << talker->GetFamilyID() << " 的消息: " << message << std::endl;
    }
};
第四步：实现具体观察者（聊天通知器）

实现聊天通知器类，维护玩家列表，并在聊天内容变化时通知玩家。

// 具体观察者：聊天通知器
class TalkNotifier : public Notifier {
private:
    std::map<int, std::list<Fighter*>> familyList; // 家族ID与玩家列表的映射

public:
    void addToList(Fighter* player) override {
        int familyID = player->GetFamilyID();
        if (familyID != -1) {
            familyList[familyID].push_back(player); // 添加玩家到对应家族
        }
    }

    void removeFromList(Fighter* player) override {
        int familyID = player->GetFamilyID();
        if (familyID != -1) {
            familyList[familyID].remove(player); // 移除玩家
        }
    }

    void notify(Fighter* talker, const std::string& message) override {
        int familyID = talker->GetFamilyID();
        if (familyID != -1) {
            for (Fighter* player : familyList[familyID]) {
                player->NotifyWords(talker, message); // 通知所有玩家
            }
        }
    }
};
第五步：主函数

在主函数中，创建玩家和聊天通知器对象，注册玩家，并演示聊天信息的通知过程。

// 主函数
int main() {
    // 创建聊天通知器
    TalkNotifier notifier;

    // 创建玩家
    ConcreteFighter player1("张三");
    player1.SetFamilyID(100);
    ConcreteFighter player2("李四");
    player2.SetFamilyID(100);
    ConcreteFighter player3("王五");
    player3.SetFamilyID(200);

    // 注册玩家到通知器
    notifier.addToList(&player1);
    notifier.addToList(&player2);
    notifier.addToList(&player3);

    // 玩家发送消息
    player1.SayWords("大家集合，准备进攻！", &notifier); // 张三发送消息
    player2.SayWords("听从指挥，前往目标！", &notifier); // 李四发送消息

    // 移除玩家
    notifier.removeFromList(&player2); // 移除李四

    // 再次发送消息
    player1.SayWords("李四已经不在了，继续行动！", &notifier); // 张三发送消息

    return 0;
}
UML 图

观察者模式 UML 图2

UML 图解析

Subject（主题）：也叫作观察目标，指被观察的对象。这里指 Notifier 类。提供增加和删除观察者对象的接口，如 addToList 和 removeFromList。

ConcreteSubject（具体主题）：维护一个观察者列表，当状态发生改变时，调用 notify 向各个观察者发出通知。这里指 TalkNotifier 子类。

Observer（观察者）：当被观察的对象状态发生变化时，观察者自身会收到通知。这里指 Fighter 类。

ConcreteObserver（具体观察者）：调用观察目标的 addToList 成员函数将自身加入到观察者列表中，当具体目标状态发生变化时，自身会接到通知（NotifyWords 成员函数会被调用）。这里指 F_Warrior 和 F_Mage 子类。

优缺点

优点：

  • 松耦合：观察者和主题之间的关系是松散的，降低了模块间的耦合度。
  • 动态添加观察者：可以在运行时增加或减少观察者。
  • 多对一的通知：一个主题可以通知多个观察者，适合事件驱动的场景。

缺点：

  • 通知开销：如果观察者数量较多，通知开销可能较大。
  • 循环依赖：若观察者和主题相互依赖，可能导致循环更新。

适用场景

  • 事件处理系统：GUI框架中，用户操作（如点击按钮）会触发事件，多个组件需要对这些事件做出反应。

  • 数据绑定：在MVC（模型-视图-控制器）架构中，当模型数据变化时，视图需要自动更新以反映最新的数据。

  • 发布-订阅系统：在消息传递系统中，多个订阅者会对特定主题的消息做出反应，发布者只需发布消息而不需要关心订阅者的具体实现。

  • 状态监控：在监控系统中，多个观察者需要监控同一状态（如温度传感器的读数），当状态变化时，所有观察者都能及时获取更新。

  • 社交媒体通知：当用户发布新内容时，所有关注该用户的粉丝会收到更新通知。

例一：完整代码

将以上步骤组合在一起，完整代码如下：

#include <iostream>
#include <vector>
#include <algorithm> // 用于 std::remove

// 观察者接口
class Observer {
public:
    virtual void update(int state) = 0; // 更新接口
};

// 主题接口
class Subject {
public:
    virtual void attach(Observer* observer) = 0; // 添加观察者
    virtual void detach(Observer* observer) = 0; // 移除观察者
    virtual void notify() = 0; // 通知观察者
};

// 具体主题
class ConcreteSubject : public Subject {
private:
    std::vector<Observer*> observers; // 观察者列表
    int state; // 主题的状态

public:
    void attach(Observer* observer) override {
        observers.push_back(observer); // 添加观察者
    }

    void detach(Observer* observer) override {
        observers.erase(std::remove(observers.begin(), observers.end(), observer), observers.end()); // 移除观察者
    }

    void notify() override {
        for (Observer* observer : observers) {
            observer->update(state); // 通知所有观察者
        }
    }

    void setState(int newState) {
        state = newState; // 更新状态
        notify(); // 状态变化时通知观察者
    }

    int getState() const {
        return state; // 获取当前状态
    }
};

// 具体观察者
class ConcreteObserver : public Observer {
private:
    std::string name; // 观察者名称
    int observedState; // 观察者的状态

public:
    ConcreteObserver(const std::string& name) : name(name) {}

    void update(int state) override {
        observedState = state; // 更新观察者的状态
        std::cout << "Observer " << name << " updated with state: " << observedState << std::endl;
    }
};

// 主函数
int main() {
    ConcreteSubject subject; // 创建具体主题

    ConcreteObserver observer1("Observer 1"); // 创建观察者1
    ConcreteObserver observer2("Observer 2"); // 创建观察者2

    subject.attach(&observer1); // 注册观察者1
    subject.attach(&observer2); // 注册观察者2

    subject.setState(1);  // 状态变化，通知所有观察者
    subject.setState(2);  // 状态变化，通知所有观察者

    return 0;
}

例二：完整代码

#include <iostream>
#include <list>
#include <map>

using namespace std;

class Fighter; //类前向声明
class Notifier //通知器父类
{
public:
    virtual void addToList(Fighter* player) = 0; //把要被通知的玩家加到列表中
    virtual void removeFromList(Fighter* player) = 0; //把不想被通知的玩家从列表中去除
    virtual void notify(Fighter* talker, string tmpContent) = 0; //通知的一些细节信息
    virtual ~Notifier() {}
};
class Fighter
{
public:
    Fighter(int tmpID, string tmpName) :m_iPlayerID(tmpID), m_sPlayerName(tmpName)//构造函数
    {
        m_iFamilyID = -1; //-1表示没加入任何家族
    }
    virtual ~Fighter() {} //析构函数

public:
    void SetFamilyID(int tmpID)  //加入家族时设置家族ID
    {
        m_iFamilyID = tmpID;
    }
    int GetFamilyID() //获取家族ID
    {
        return m_iFamilyID;
    }

    void SayWords(string tmpContent, Notifier* notifier) //玩家说了某句话
    {
        notifier->notify(this, tmpContent);
    }

    //通知该玩家接收到其他玩家发送来的聊天信息，虚函数，子类可以覆盖以实现不同的动作
    virtual void NotifyWords(Fighter* talker, string tmpContent)
    {
        //显示信息
        cout << "玩家：" << m_sPlayerName << " 收到了玩家：" << talker->m_sPlayerName << " 发送的聊天信息：" << tmpContent << endl;
    }
private:
    int m_iPlayerID; //玩家ID，全局唯一
    string m_sPlayerName;  //玩家名字

    int m_iFamilyID;   //家族ID
};
//“战士”类玩家，父类为Fighter
class F_Warrior :public Fighter
{
public:
    F_Warrior(int tmpID, string tmpName) :Fighter(tmpID, tmpName) {} //构造函数
};

//“法师”类玩家，父类为Fighter
class F_Mage :public Fighter
{
public:
    F_Mage(int tmpID, string tmpName) :Fighter(tmpID, tmpName) {} //构造函数
};

//----------------------------------
class TalkNotifier :public Notifier  //聊天信息通知器
{
public:
    //将玩家增加到家族列表中来
    virtual void addToList(Fighter* player)
    {
        int tmpfamilyid = player->GetFamilyID();
        if (tmpfamilyid != -1) //加入了某个家族
        {
            auto iter = m_familyList.find(tmpfamilyid);
            if (iter != m_familyList.end())
            {
                //该家族id在map中已经存在
                iter->second.push_back(player); //直接把该玩家加入到该家族
            }
            else
            {
                //该家族id在map中不存在
                list<Fighter*> tmpplayerlist;
                m_familyList.insert(make_pair(tmpfamilyid, tmpplayerlist));//以该家族id为key，增加条目到map中
                m_familyList[tmpfamilyid].push_back(player); //向该家族中增加第一个玩家
            }
        }
    }
    //将玩家从家族列表中删除
    virtual void removeFromList(Fighter* player)
    {
        int tmpfamilyid = player->GetFamilyID();
        if (tmpfamilyid != -1) //加入了某个家族
        {
            auto iter = m_familyList.find(tmpfamilyid);
            if (iter != m_familyList.end())
            {
                m_familyList[tmpfamilyid].remove(player);
            }
        }
    }

    //家族中某玩家说了句话，调用该函数来通知家族中所有人
    virtual void notify(Fighter* talker, string tmpContent) //talker是讲话的玩家
    {
        int tmpfamilyid = talker->GetFamilyID();
        if (tmpfamilyid != -1)
        {
            auto itermap = m_familyList.find(tmpfamilyid);
            if (itermap != m_familyList.end())
            {
                //遍历该玩家所属家族的所有成员
                for (auto iterlist = itermap->second.begin(); iterlist != itermap->second.end(); ++iterlist)
                {
                    (*iterlist)->NotifyWords(talker, tmpContent);
                }
            }
        }
    }
private:
    //map中的key表示家族id，value代表该家族中所有玩家列表
    map<int, list<Fighter*> > m_familyList; //增加#include <map>
};


int main()
{
    //创建游戏玩家
    Fighter* pplayerobj1 = new F_Warrior(10, "张三");
    pplayerobj1->SetFamilyID(100);

    Fighter* pplayerobj2 = new F_Warrior(20, "李四");
    pplayerobj2->SetFamilyID(100);

    Fighter* pplayerobj3 = new F_Mage(30, "王五");
    pplayerobj3->SetFamilyID(100);

    Fighter* pplayerobj4 = new F_Mage(50, "赵六");
    pplayerobj4->SetFamilyID(200);

    //创建通知器
    Notifier* ptalknotify = new TalkNotifier();

    //玩家增加到家族列表中来，这样才能收到家族聊天信息
    ptalknotify->addToList(pplayerobj1);
    ptalknotify->addToList(pplayerobj2);
    ptalknotify->addToList(pplayerobj3);
    ptalknotify->addToList(pplayerobj4);

    //某游戏玩家聊天，同族人都应该收到该信息
    pplayerobj1->SayWords("全族人立即到沼泽地集结，准备进攻！", ptalknotify);

    cout << "王五不想再收到家族其他成员的聊天信息了---" << endl;
    ptalknotify->removeFromList(pplayerobj3); //将王五从家族列表中删除

    pplayerobj2->SayWords("请大家听从族长的调遣，前往沼泽地！", ptalknotify);

    //释放资源
    delete pplayerobj1;
    delete pplayerobj2;
    delete pplayerobj3;
    delete pplayerobj4;
    delete ptalknotify;

    return 0;
}
不是仙人的闲人
关注
专栏目录
C++设计模式——观察者模式
WWX2LN的博客
08-21 541
一、观察者模式引入 观察者模式（Observer 模式）应该可以说是应用多、影响广的模式之一，因为 Observer 的一个实例 Model/View/Control（MVC）结构在系统开发架构设计中有着很重要的地位和意义，MVC实现了业务逻辑和表示层的解耦。Observer 模式也是软件开发过程中必须要掌和使用的模式之一。 Observer 模式要解决的问题为：建立一个一（Subject）...
设计模式之观察者模式实例（c++）
Sincky的博客
06-12 1951
观察者模式 定义对象间的一种一对多依赖关系，使得每当一个对象状态发生改变时，其相关依赖对象皆可得到通知并被自动更新。 观察者模式又叫做发布-订阅(Publish-Subscribe)模式、模型-视图(Model-View)模式、源-监听器(Source-Listener)模式。 观察者模式实例之猫、狗与老鼠 从类图可知， MySubject需要保存（关联）MyObserver的对象，当...
C/C++设计模式之观察者模式
Lion_Long的博客
10-09 1320
勾勒观察者模式时，可以利用报纸订阅服务，以及出版者和订阅者比拟这一切。观察者模式定义了对象之间一对多依赖，这样一来，当一个对象改变状态时，它的所有依赖者都会收到通知并自动更新。fill:#333;color:#333;color:#333;fill:none;}主题有了新数据，所有观察者都收到通知依赖者对象自动更新或通知自动更新或通知自动更新或通知自动更新或通知主题对象1号2号3号...主题和观察者定义了一对多的关系。观察者依赖主题，只要主题状态一有变化，观察者就会被通知。
C++设计模式-观察者模式
最新发布
hzdxyh的博客
08-12 1031
Observer（观察者）：它是一个抽象类或接口，为所有的具体观察者定义一个更新接口，使得在得到主题的通知时更新自己。Subject（主题）：它维护了一系列依赖于它的Observer对象，并提供一个接口来允许Observer对象注册自己、注销自己以及通知它们。ConcreteObserver（具体观察者）：它实现了Observer接口，存储与Subject的状态自洽的状态。具体观察者根据需要实现Subject的更新接口，以使得自身状态与主题的状态保持一致。
C++实现观察者(Observer)模式
weixin_30955617的博客
04-24 131
观察者(Observer)模式，是常见的模式之一。比如一份报纸，有很多订户。订阅者并不知道报纸何时会送来，他只知道自己订了这份报纸。订阅者在这里担任着观察者的角色，而报社则是被观察者。 报纸一旦印刷完毕，就应该及时送到订户手中，如果将报社看作一个对象，则报纸便是观察者（订户）和被观察者（报社）之间的纽带。观察者需要维护一个与报纸相关的变量或函数，在这个具体问题中，这个变量就是订户...
【C++】—— 观察者模式
m0_56069910的博客
03-12 1013
观察者模式详解
C++观察者模式
zion--6135的博客
10-03 210
现在假设一种情形：一个人(person)要去看公告(Note)的内容，需要Note去setNews(string);设置发布的内容，那么写下来就是一个Note类和person类，两个类根据需求写一些代码，写下来就是下面这样。。 #include <stdlib.h> #include <iostream> #include <string> using namespace std; class Note { public: void setNews(str
C++设计模式——观察者模式（observer pattern）
净无邪博客
03-22 885
一、原理讲解 1.1意图 定义一种“一对多”的关系。当一个对象（被观察者/发布者）的状态发生改变时，所有依赖它的对象都将得到通知并更新。又有别名为发布-订阅（publish-subscribe）。 1.2应用场景 一个抽象模型有两个方面，其中一个方面依赖于另一方面。将这二者封装在独立的对象中，以使它们可以独立的改变和复用 当一个对象改变，连带其它对象也跟着改变，但是不需要知道具体改变对象...
设计模式实现——观察者模式
09-04
在《设计模式实现——观察者模式》这篇博客中，作者可能详细解释了观察者模式的概念、结构以及其在实际编程中的应用。以下是对观察者模式的详细阐述： 1. **模式定义**：观察者模式是一种对象行为型模式，它允许...
C++设计模式——中介者模式（mediator pattern）
净无邪博客
10-05 1230
一、原理讲解 1.1意图 用一个中介对象来封装一系列的对象。中介者使各对象不需要显示地相互引用，从而使其耦合松散，而且可以独立地改变它们之间的交互。 1.2应用场景 一组对象以定义良好但复杂的方式进行通信，产生的相互依赖关系结构混乱且难以理解； 一个对象引用其他很多对象并且直接与这些对象通信，导致难以复用该对象； 想定制一个分布在多个类中的行为，而又不想生成太多的子类； 1.3结构图（UML图） 1.4代码实现步骤 a1 定义一个中介者接口类IMediator，定义两个接口函数send()和add()
C++ 观察者模式
CodeHouse的博客
11-10 427
#include <iostream> #include <list> using namespace std; //观察者抽象类 class Observer { public: Observer(){;} virtual void doSometing(void* parg)=0; }; class User1:public Observer { public: virtual void doSometing(void* parg) { cout<<
c++ 观察者模式
weixin_33834910的博客
06-21 327
观察者模式之比喻： 有家公司，老板经常不按时上班，于是员工就可以在老板来之前的那段时间娱乐一下，但是又过的是心惊胆战，怕 老板随时出现；这是观察者模式就起作用了；公司有个前台，她总是第一个看到老板进门并且有时间通知大家的人， 于是员工都可以在前台那里登记一下，是否需要得到通知，其他事情也可以通过前台通知，比如说来了一个快递等； 实现代码如下： 1 /** 2 * Def...
C++：观察者设计模式
weixin_57535837的博客
08-03 208
本文章对观察者设计模式做了简单介绍、该模式能解决什么问题、它的编程套路以及代码的简单演示。对该方面感兴趣的可以参考下 。
[C++]观察者模式
就是那个党伟
04-12 299
当对象间存在一对多关系时，则使用观察者模式（Observer Pattern）。比如，当一个对象被修改时，则会自动通知它的依赖对象。观察者模式属于行为型模式。 C++代码如下： // 此文件包含 "main" 函数。程序执行将在此处开始并结束。 // // 参考大话设计模式 #include <iostream> #include <vector> using...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值