C++设计模式

已于 2023-08-14 19:24:34 修改
阅读量165 收藏
点赞数
分类专栏： C++ 文章标签： c++ 设计模式
于 2023-08-02 00:30:47 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_44949092/article/details/132053315
版权

这里摘录的不是很全，主要记录了个人认为需要记录的模式

文章目录

创建型模式

建造者模式

Builder设计模式是一种创建型的设计模式，它允许您创建不同类型的对象，而无需暴露对象的创建逻辑。在C++中，Builder设计模式通常由一个抽象Builder类和多个具体Builder类组成，以及一个Director类来协调Builder类的使用。

具体地说，抽象Builder类定义了必须由所有具体Builder类实现的创建对象的接口。具体Builder类实现了这些接口，并提供了构建特定类型对象所需的逻辑。Director类使用Builder类来构建对象，并定义了构建对象的顺序和逻辑。

Builder 模式强调的是一步步创建对象，并通过相同的创建过程可以获得不同的结果对象

Builder设计模式优点：

  1. 隐藏对象的创建细节：Builder模式将对象的创建过程封装在一个单独的类中，使客户端代码无需了解对象的创建细节。
  2. 支持创建不同类型的对象：Builder模式允许您创建不同类型的对象，而无需更改客户端代码。这是因为客户端代码仅与抽象Builder类和Director类交互，而不需要了解具体的Builder实现。
  3. 支持更好的控制对象的创建过程：Builder模式允许您更好地控制对象的创建过程。通过使用Director类来协调Builder类的使用，您可以确保对象按照正确的顺序创建，并且每个对象都被正确地初始化。
  4. 简化对象的构建：Builder模式使得构建复杂对象变得更加简单。通过将对象的构建过程分解为多个步骤，并由不同的Builder类来执行这些步骤，您可以更容易地构建复杂的对象。

总之，Builder设计模式提供了一种灵活、可扩展和可维护的方式来构建不同类型的对象。它允许您隐藏对象的创建细节，并支持更好地控制对象的创建过程。

class Car {
public:
    void setBrand(const std::string& brand) {
        m_brand = brand;
    }
    void setModel(const std::string& model) {
        m_model = model;
    }
    void setYear(int year) {
        m_year = year;
    }
private:
    std::string m_brand;
    std::string m_model;
    int m_year;
};

class CarBuilder {
public:
    virtual ~CarBuilder() {}
    virtual void buildBrand() = 0;
    virtual void buildModel() = 0;
    virtual void buildYear() = 0;
    virtual Car* getCar() = 0;
};

class SportsCarBuilder : public CarBuilder {
public:
    SportsCarBuilder() {
        m_car = new Car();
    }
    void buildBrand() override {
        m_car->setBrand("Ferrari");
    }
    void buildModel() override {
        m_car->setModel("458 Italia");
    }
    void buildYear() override {
        m_car->setYear(2015);
    }
    Car* getCar() override {
        return m_car;
    }
private:
    Car* m_car;
};

class SUVBuilder : public CarBuilder {
public:
    SUVBuilder() {
        m_car = new Car();
    }
    void buildBrand() override {
        m_car->setBrand("Jeep");
    }
    void buildModel() override {
        m_car->setModel("Grand Cherokee");
    }
    void buildYear() override {
        m_car->setYear(2020);
    }
    Car* getCar() override {
        return m_car;
    }
private:
    Car* m_car;
};

class Director {
public:
    Director(CarBuilder* builder) : m_builder(builder) {}
    Car* construct() {
        m_builder->buildBrand();
        m_builder->buildModel();
        m_builder->buildYear();
        return m_builder->getCar();
    }
private:
    CarBuilder* m_builder;
};

int main() {
    SportsCarBuilder sportsCarBuilder;
    Director director(&sportsCarBuilder);
    Car* sportsCar = director.construct();

    SUVBuilder suvBuilder;
    director = Director(&suvBuilder);
    Car* suv = director.construct();

    // use sportsCar and suv
}

结构型模式

Adapter模式

Adapter设计模式是一种结构型设计模式，它允许将一个类的接口转换成客户端所期望的另一个接口。在C++中，Adapter通常以类的形式实现，它包装了一个已有的类并将其接口转换成目标接口。

Adapter设计模式通常包含以下几个组件：

  • 目标接口：客户端所期望的接口，Adapter将已有类的接口转换成目标接口。
  • 已有类：需要被适配的类。
  • Adapter：将已有类的接口转换成目标接口的类。
// 目标接口
class TargetInterface {
public:
    virtual void request() = 0;
};

// 已有类
class ExistingClass {
public:
    void specificRequest() {
        // 原有的实现
    }
};

// Adapter
class Adapter : public TargetInterface {
private:
    ExistingClass* existing;

public:
    Adapter(ExistingClass* existing) {
        this->existing = existing;
    }

    void request() {
        existing->specificRequest();
    }
};

装饰者(decorator)模式

动态地给一个对象添加一些额外的职责。就增加功能来说，Decorator模式相比生成子类更为灵活。不改变接口的前提下，增强所考虑的类的性能

何时使用

  • 需要扩展一个类的功能，或给一个类增加附加责任。
  • 需要动态的给一个对象增加功能，这些功能可以再动态地撤销。
  • 需要增加一些基本功能的排列组合而产生的非常大量的功能。

他的特点是

  • 被拓展功能的类和装饰者类是继承同一接口的，也就是处于同一级，使装饰者可以完整得到被拓展功能类的原先功能
  • 装饰者中又包裹了一个被拓展功能类的指针，这样就可以在装饰者自身的动作函数中还原被拓展功能类原先的功能的同时，增加新的功能。
  • 在实际运用中实例化装饰者类，实现增加了功能的对象

往往不同的场合会生成不同格式的日志内容，比如有json的，xml的，表格的各种形式，如果用继承的方式就需要在打印日志的类下不停的派生各种子类，然后重载日志输出接口，这样类的复杂度越来越高。此时如果用装饰者，可以需要什么模式的时候就装饰什么。

#include<iostream>
using namespace std;
 
class log {          //整个日志类
    public:
        virtual void log_out(string filename, string  value) {
            cout<<"输出日志"<<value<<"到"<<filename<<"文件"<<endl;
        }
};
 
class errlog:public log {    //错误日志输出类
    public:
    void log_out(string filename, string  value) {
            cout<<"输出错误日志"<<value<<"到"<<filename<<"文件"<<endl;
        }
};
 
class debuglog:public log {  //debug日志输出类
    public:
    void log_out(string filename, string  value) {
            cout<<"输出debug日志"<<value<<"到"<<filename<<"文件"<<endl;
        }
}; 
 
class decoratorlog:public log {//日志输出装饰器
    public:
        log *m_logout;
        decoratorlog() {}
        decoratorlog(log *logout) {
            this->m_logout = logout;
        }
        void log_out(string filename, string  value) {
                cout<<"输出debug日志"<<value<<"到"<<filename<<"文件"<<endl;
        }
};
 
class jsondecorator:public decoratorlog {//json日志输出装饰器
    public:
        jsondecorator(log *logout) {
            this->m_logout = logout;
        }
        void log_out(string filename, string  value) {
            cout<<"value进行了json转换"<<endl;     //装饰器的作用，也就是需要扩充的新功能需求
            m_logout->log_out(filename,value);    //调用到原先的接口
        }
};
 
class xmldecorator:public decoratorlog {//json日志输出装饰器
    public:
        xmldecorator(log *logout) {
            this->m_logout = logout;
        }
        void log_out(string filename, string  value) {
            cout<<"value进行了xml转换"<<endl;      //装饰器的作用，也就是需要扩充的新功能需求
            m_logout->log_out(filename,value);    //调用到原先的接口
        }
};
int main() {
    log *log1 = new jsondecorator( new debuglog());
    log1->log_out("1.json","hello");
    log *log2 = new xmldecorator( new errlog());
    log2->log_out("1.xml","world");
    return 0;
}
 
/*
value进行了json转换
输出debug日志hello到1.json文件
value进行了xml转换
输出错误日志world到1.xml文件
*/

在这里插入图片描述

组合实体(Composite)模式

在 Composite 模式中，有两种类型的对象：叶节点和容器节点。叶节点代表树结构中的最终对象，而容器节点则代表包含其他节点的对象。容器节点可以包含叶节点和其他容器节点，这样就形成了树状结构。

优点如下：

  1. 简化客户端代码：客户端代码可以像处理单个对象一样处理复杂的树形结构，而不必关心对象是叶节点还是容器节点。
  2. 易于扩展：可以很容易地向树形结构中添加新的叶节点和容器节点。
  3. 可以统一处理叶节点和容器节点：在 Composite 模式中，叶节点和容器节点都实现了相同的接口，因此可以统一处理它们。
  4. 使得设计更加抽象化：通过使用 Composite 模式，可以将复杂的树形结构抽象化，使得设计更加灵活和可维护。

实现

#include <iostream>
#include <vector>

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

class Leaf : public Component {
public:
    void operation() override {
        std::cout << "Leaf operation" << std::endl;
    }
};

class Composite : public Component {
public:
    void operation() override {
        std::cout << "Composite operation" << std::endl;
        for (auto& component : components_) {
            component->operation();
        }
    }

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

private:
    std::vector<Component*> components_;
};

int main() {
    Leaf leaf;
    Composite composite1, composite2;

    composite1.add(&leaf);
    composite2.add(&composite1);

    composite2.operation();

    return 0;
}

享元(Flyweight)模式

Flyweight 模式是一种结构型设计模式，它通过共享对象来最小化内存使用和提高性能。在 C++ 中，Flyweight 模式通常使用工厂模式来实现。

使用案例：

  1. 文字处理器中的字符：在文本编辑器中，每个字符都可以看作是一个对象，但是对于相同的字符，我们并不需要为每个字符都创建一个新的对象。相反，我们可以使用 Flyweight 模式来共享相同的字符对象，从而减少内存使用和提高性能。
  2. 游戏中的粒子效果：在游戏中，粒子效果通常需要大量的粒子对象。使用 Flyweight 模式，我们可以共享相同的粒子对象，从而减少内存使用和提高性能。
  3. 电子商务网站中的商品：在电子商务网站中，有很多商品具有相同的属性（如名称、价格等）。使用 Flyweight 模式，我们可以共享相同的商品对象，从而减少内存使用和提高性能。
//Flyweight.h
#ifndef FLYWEIGHT_H 
#define FLYWEIGHT_H 
#include <string> 
#include <list> 
typedef std::string STATE; 
class Flyweight 
{ 
public: 
     virtual ~Flyweight(){} 
     STATE GetIntrinsicState(); 
     virtual void Operation(STATE& ExtrinsicState) = 0; 
protected: 
 Flyweight(const STATE& state) 
 :m_State(state) 
 { 
 } 
private: 
 STATE m_State; 
}; 
class FlyweightFactory 
{ 
public: 
 FlyweightFactory(){} 
 ~FlyweightFactory(); 
 Flyweight* GetFlyweight(const STATE& key); 
private: 
 std::list<Flyweight*> m_listFlyweight; 
}; 
class ConcreateFlyweight 
 : public Flyweight 
{ 
public: 
 ConcreateFlyweight(const STATE& state) 
 : Flyweight(state) 
 { 
 } 
 virtual ~ConcreateFlyweight(){} 
 virtual void Operation(STATE& ExtrinsicState); 
}; 
#endif

//Flyweight.cpp
#include "FlyWeight.h" 
#include <iostream> 
inline STATE Flyweight::GetIntrinsicState() 
{ 
 return m_State; 
} 
FlyweightFactory::~FlyweightFactory() 
{ 
 std::list<Flyweight*>::iterator iter1, iter2, temp; 
 for (iter1 = m_listFlyweight.begin(), iter2 = m_listFlyweight.end(); 
 iter1 != iter2; 
 ) 
 { 
 temp = iter1; 
 ++iter1; 
 delete (*temp); 
 } 
 m_listFlyweight.clear(); 
} 
Flyweight* FlyweightFactory::GetFlyweight(const STATE& key) 
{ 
 std::list<Flyweight*>::iterator iter1, iter2; 
 for (iter1 = m_listFlyweight.begin(), iter2 = m_listFlyweight.end(); 
 iter1 != iter2; 
 ++iter1) 
 { 
 if ((*iter1)->GetIntrinsicState() == key) 
 { 
 std::cout << "The Flyweight:" << key << " already exits"<< std::endl; 
 return (*iter1); 
 } 
 } 
 std::cout << "Creating a new Flyweight:" << key << std::endl; 
 Flyweight* flyweight = new ConcreateFlyweight(key); 
 m_listFlyweight.push_back(flyweight); 
 return flyweight;
} 
void ConcreateFlyweight::Operation(STATE& ExtrinsicState) 
{ 
}

#include "FlyWeight.h" 
int main() 
{ 
 FlyweightFactory flyweightfactory; 
 flyweightfactory.GetFlyweight("hello"); 
 flyweightfactory.GetFlyweight("world"); 
 flyweightfactory.GetFlyweight("hello"); 
 system("pause"); 
 return 0; 
}

代理(Proxy)模式

代理模式（Proxy Pattern）是指为其他对象提供一种代理，以控制对这个对象的访问。 代理对象在客服端和目标对象之间起到中介作用。

1、和适配器模式的区别：适配器模式主要改变所考虑对象的接口，而代理模式不能改变所代理类的接口。
2、和装饰器模式的区别：装饰器模式为了增强功能，而代理模式是为了加以控制。

案例

//代理模式:提供一种代理来控制其他对象的访问
#include <iostream>
using namespace std;

class AbstractCommonInterface {
public:
    virtual void run() = 0;
};
//下面是操作系统类
class MySystem :public AbstractCommonInterface{
public:
    virtual void run() {
        cout << "系统启动" << endl;
    }
};

//代理： 启动系统必须要权限验证,不是所以的人都可以来启动我的系统,必须要提供用户名和密码
class MySystemProxy :public AbstractCommonInterface {
public:
    MySystemProxy(string userName, string password) {
        this->mUserName = userName;
        this->mPassword = password;
        pMySystem = new MySystem;
    }

    bool checkUserNameAndPassword() {
        if (mUserName == "admin" && mPassword == "admin") {
            return true;
        }
        return false;
    }
    virtual void run() {
        if (checkUserNameAndPassword() == true) {
            cout << "启动成功" << endl;
            this->pMySystem->run();
        }
        else {
            cout << "用户名或者密码错误,权限不足" << endl;
        }
    }
    ~MySystemProxy() {
        if (pMySystem != NULL) {
            delete pMySystem;
        }
    }
private:
    string mUserName;
    string mPassword;
    MySystem* pMySystem;
};
void test01() {
    MySystemProxy* proxy = new MySystemProxy("admin", "admin");
    proxy->run();
}

int main()
{
    test01();
}

行为模式

状态(state)模式

主要解决问题：

  • 当状态数目不是很多的时候，Switch/Case 可能可以搞定。但是当状态数目很多的时候（实际系统中也正是如此），维护一大组的Switch/Case 语句将是一件异常困难并且容易出错的事情。
  • 状态逻辑和动作实现没有分离。在很多的系统实现中，动作的实现代码直接写在状态的逻辑当中。这带来的后果就是系统的扩展性和维护得不到保证。

优点：

  • 封装了转换规则。
  • 枚举可能的状态，在枚举状态之前需要确定状态种类。
  • 将所有与某个状态有关的行为放到一个类中，并且可以方便地增加新的状态，只需要改变对象状态即可改变对象的行为。
  • 允许状态转换逻辑与状态对象合成一体，而不是某一个巨大的条件语句块。
  • 可以让多个环境对象共享一个状态对象，从而减少系统中对象的个数。

示例

#include <iostream>

class State {
public:
    virtual void handle() = 0;
};

class ConcreteStateA : public State {
public:
    void handle() override {
        std::cout << "ConcreteStateA handle" << std::endl;
    }
};

class ConcreteStateB : public State {
public:
    void handle() override {
        std::cout << "ConcreteStateB handle" << std::endl;
    }
};

class Context {
public:
    Context() : state_(nullptr) {}

    void setState(State* state) {
        state_ = state;
    }

    void request() {
        if (state_) {
            state_->handle();
        }
    }

private:
    State* state_;
};

int main() {
    Context context;
    ConcreteStateA stateA;
    ConcreteStateB stateB;

    context.setState(&stateA);
    context.request();

    context.setState(&stateB);
    context.request();

    return 0;
}

中介者(Mediator)模式

该模式主要用于对象之间的通信。建立中介者完成对象之间的通信

#include <iostream>
#include <string>
#include <vector>

class Colleague;

// 中介者抽象类
class Mediator {
public:
    virtual void sendMessage(const std::string& message, const Colleague* colleague) const = 0;
};

// 同事抽象类
class Colleague {
public:
    virtual void sendMessage(const std::string& message) const {
        m_mediator->sendMessage(message, this);
    }

    virtual void receiveMessage(const std::string& message) const = 0;

    void setMediator(const Mediator* mediator) {
        m_mediator = mediator;
    }

protected:
    const Mediator* m_mediator;
};

// 具体中介者类
class ConcreteMediator : public Mediator {
public:
    void addColleague(Colleague* colleague) {
        m_colleagues.push_back(colleague);
        colleague->setMediator(this);
    }

    void sendMessage(const std::string& message, const Colleague* colleague) const override {
        for (auto c : m_colleagues) {
            if (c != colleague) {
                c->receiveMessage(message);
            }
        }
    }

private:
    std::vector<Colleague*> m_colleagues;
};

// 具体同事类
class ConcreteColleague1 : public Colleague {
public:
    void receiveMessage(const std::string& message) const override {
        std::cout << "ConcreteColleague1 received message: " << message << std::endl;
    }
};

class ConcreteColleague2 : public Colleague {
public:
    void receiveMessage(const std::string& message) const override {
        std::cout << "ConcreteColleague2 received message: " << message << std::endl;
    }
};

int main() {
    ConcreteMediator mediator;
    ConcreteColleague1 colleague1;
    ConcreteColleague2 colleague2;

    mediator.addColleague(&colleague1);
    mediator.addColleague(&colleague2);

    colleague1.sendMessage("Hello, colleague2!");
    colleague2.sendMessage("Hi, colleague1!");

    return 0;
}

责任链模式

责任链模式属于行为型模式。责任链模式（Chain of Responsibility Pattern）为请求创建了一个接收者对象的链。这种模式给予请求的类型，对请求的发送者和接收者进行解耦。

优点：

  • 降低耦合：请求发送者和接收者之间的耦合关系被解除，每个处理器只需要关注自己负责的请求范围，从而使系统更加灵活和可扩展。
  • 简化代码：责任链模式使得代码更加简洁和易于维护，每个处理器只需要实现自己的处理逻辑，而无需关注其他部分的实现。
  • 支持动态添加或删除处理器：责任链模式允许在运行时动态添加或删除处理器，从而使系统更加灵活和可配置。

示例

class Handler {
public:
    Handler(Handler* successor = nullptr) : successor_(successor) {}
    virtual ~Handler() {}
    virtual void HandleRequest(int request) {
        if (successor_) {
            successor_->HandleRequest(request);
        }
    }
protected:
    Handler* successor_;
};

class ConcreteHandlerA : public Handler {
public:
    void HandleRequest(int request) override {
        if (request >= 0 && request < 10) {
            std::cout << "Handled by ConcreteHandlerA." << std::endl;
        } else if (successor_) {
            successor_->HandleRequest(request);
        }
    }
};

class ConcreteHandlerB : public Handler {
public:
    void HandleRequest(int request) override {
        if (request >= 10 && request < 20) {
            std::cout << "Handled by ConcreteHandlerB." << std::endl;
        } else if (successor_) {
            successor_->HandleRequest(request);
        }
    }
};

int main() {
    Handler* handler1 = new ConcreteHandlerA();
    Handler* handler2 = new ConcreteHandlerB(handler1);
    handler2->HandleRequest(5);
    handler2->HandleRequest(15);
    handler2->HandleRequest(25);
    delete handler2;
    delete handler1;
    return 0;
}
逆流code
关注
专栏目录
《C++ 设计模式》
青春不老，奋斗不止！
02-09 9万+
设计模式代表了最佳的实践，在面向对象的编程中被很多老鸟们反复使用。使用设计模式有很多好处：可重用代码、保证代码可靠性、使代码更易被他人理解 ......
C++ 设计模式
wy749929317的博客
06-18 1593
在C++中，设计模式（Design Patterns）是用于解决在软件设计中经常遇到的一些通用问题的最佳实践。这些设计模式是在多年的软件开发过程中积累下来的经验和智慧的结晶。定义一个操作中的算法的框架，而将一些步骤延迟到子类中。模板方法使得子类可以不改变一个算法的结构即可重新定义该算法的某些特定步骤。将一个类的接口转换成客户端所期望的另一种接口，从而使得原本由于接口不兼容而无法一起工作的类能够一起工作。将一个复杂对象的构建与它的表示分离，使得同样的构建过程可以创建不同的表示。
c++设计模式
qq_45395160的博客
09-04 1472
*你可以深入介绍几个面试中经常提到的设计模式，解释它们的作用、实现方法，并提供简单的示例代码。以下是几个常见的设计模式：3.1 单例模式（Singleton）概念： 确保一个类只有一个实例，并提供全局访问点。回答： “单例模式用于确保一个类在程序中只有一个实例，并且提供一个全局访问点来获取这个实例。它通常用于管理资源（如数据库连接、配置文件）。private:public:// 初始化静态成员3.2 工厂方法模式（Factory Method）
C++ 设计模式——工厂模式
qq_68194402的博客
08-17 1917
工厂模式是一种创建对象的设计模式，主要用于将对象的创建与使用分离。它提供了一种接口来创建对象，但由子类决定实例化哪个类。工厂模式有几种变体，包括简单工厂模式、工厂方法模式和抽象工厂模式。
C++ 设计模式——单例模式
qq_68194402的博客
08-22 2025
单例模式（Singleton Pattern）也称单件模式/单态模式，是一种创建型模式，用于创建只能产生一个对象实例的类。
C++设计模式：原型模式
ajbb093的博客
04-07 1169
在本案例中，如果对史莱姆的原型进行克隆，也就是分裂成不同的对象，而不同的史莱姆型号会对应着不同的技能，假设大型史莱姆是撞击，普通史莱姆是喷射，小型史莱姆是自爆，则简单地进行深克隆以及浅克隆可能会引起异常。因此，对此的解决办法便是原型模式结合状态模式使用，状态模式是指在软件构建过程中，某些对象的状态如果发生改变，其行为也会随之发生变化，使用状态模式将能允许一个对象在其内部状态发生改变时改变它的行为，从而使对象看起来似乎修改了其行为。，普通史莱姆转换成小型史莱姆，其中四只转换后的小型史莱姆共享血量（
C++设计模式（23种）汇总及代码实现
songbijian的博客
09-03 5026
它是继承复用的基石，只有当衍生类可以替换掉基类，软件单位功能不受到影响的时候，基类才能真正被复用，而衍生类也能够在积累的基础上增加新的行为。提供一种遍历集合元素的统一接口，用一致的方法遍历集合元素，不需要知道集合对象的底层表示。它结合了两个独立接口的功能，将一个类的接口转换成客户期望的另一个接口，让原本不兼容的类或者函数可以协同运作，是两个不兼容的接口之间的桥梁。3.当进行深拷贝的时候，需要编写较为复杂的代码，而且当对象之间存在多重嵌套时，为了实现深克隆，每一层对象对应的类都必须支持深克隆，实现复杂。
c++ 设计模式类图
weixin_60569662的博客
06-12 1932
类图(Class diagram)是显示了模型的静态结构，特别是模型中存在的类、类的内部结构以及它们与其他类的关系等。类图不显示暂时性的信息。类图是面向对象建模的主要组成部分。它既用于应用程序的系统分类的一般概念建模，也用于详细建模，将模型转换成编程代码。类图(Class diagram)是显示了模型的静态结构，特别是模型中存在的类、类的内部结构以及它们与其他类的关系等。类图不显示暂时性的信息。类图是面向对象建模的主要组成部分。它既用于应用程序的系统分类的一般概念建模，也用于详细建模，将模型转换成编程代码。
C++设计模式之——命令模式
肩上风骋的博客
12-18 1679
命令模式是一种行为型设计模式，它允许将请求封装为一个对象，从而使得可以参数化客户端请求、将请求排队或者记录请求日志，以及支持可撤销的操作。总的来说，命令模式的应用场景主要在于解耦请求与实现，封装接收方具体命令的实现细节，使得请求方的代码架构稳定，具备良好的扩展性。2.创建具体命令类（Concrete Command）：继承自抽象命令类，实现具体的命令操作，同时持有一个命令接收者对象。在C++中，命令模式通常由一个抽象命令类、具体命令类、命令接收者类和调用者类组成。
C++设计模式.pdf
08-08
C++零基础学习设计模式，23种设计模式精讲，C++开发必备书籍，零基础轻松掌握，每种设计模式附加代码和uml框图！
C++设计模式--基于Qt4开源跨平台开发框架
01-06
《C++设计模式--基于Qt4开源跨平台开发框架》一书主要探讨了如何在C++编程中利用设计模式，并结合Qt4框架进行高效的跨平台应用开发。设计模式是软件工程中的重要概念，它们是经过时间和实践验证的解决特定问题的模板...
c++设计模式全系列+应用场景+实例说明
04-01
1. **工厂模式（Factory Pattern）**：工厂模式是一种创建型设计模式，用于创建对象而无需指定创建对象的具体类。包括简单工厂模式、工厂方法模式和抽象工厂模式。 2. **单例模式（Singleton Pattern）**：单例模式...
VScode中CMake无高亮（就是没有补全的提示）
Moapsw033的博客
10-15 261
原因就是：本地没有配置环境变量，解决方法是下一个cmake然后直接配置环境变量。在我学的过程中我发现我的CMake是这样的，如下图。这非常的难受，所以疯狂的找，最后是CMake报错有。如何配置环境变量就直接上网找就好了，很简单的，加油。但在教学视频里是这样的（如下图）
东方博宜OJ P1000-P1100题 C++ 和 Python 题解代码汇总
10-18 224
【代码】东方博宜OJ P1000-P1100题 C++ 和 Python 题解代码汇总。
【问题解决】——当出现0xc000007b和缺少mfc140.dll时，该怎么做才能让软件可以打开
weixin_42031602的博客
10-17 750
一个处理0xc000007b和mfc140.dll缺失的记录，希望对大家有所启发和帮助。
百度IDGC++一面-面经总结
MatsumotoChrikk
10-18 499
虚函数出现在多态、继承的情况中，在基类定义一个函数，在派生类可以重写。这也是运行时多态，虚函数就是函数前加上virtual关键字依赖虚函数表和虚表指针，只要有虚函数的类-就生成一个虚函数表。虚表指针指向这个虚函数表。查找对应的，调用函数。流量控制使用滑动窗口协议来控制流量。接收方通过广告窗口大小告诉发送方它能够接收的缓冲区大小，从而防止发送方过快地发送数据，避免接收方的缓冲区溢出。拥塞控制TCP 拥塞控制机制通过调整数据传输速率来防止网络拥塞。
C++中的CRTP
最新发布
moter的专栏
10-18 567
我们知道，要定义派生类肯定需要知道基类的类型，而在使用类模板来实例化一个模板类时又得需要知道模板的实参类型，在这里实例化基类时的实参类型又是派生类的类型。CRTP基类是类模板，基类实例化之后，和派生类是一一对应的，即一个基类只能派生一个子类，而模板参数化this指针的实现方式是基类只有一个，而且是非模板类，它的派生类可以有多个，但是每定义一个派生类，在该基类中都会使用派生类类型实例化出一个对应的interface()函数，也就是在基类中会有多个interface()成员函数和它的派生类一一对应。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值