C++常见设计模式

最新推荐文章于 2024-07-14 13:39:50 发布
最新推荐文章于 2024-07-14 13:39:50 发布
阅读量353 收藏 1
点赞数
文章标签： c++ 设计模式 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Pcl2001/article/details/133272311
版权

设计模式

设计模式的六大原则：https://zhuanlan.zhihu.com/p/110130347

适配器模式

假设Client想要一个正方形（client Interface），但是提供的服务（service）是个圆形，那么我就把这个圆通过适配器（adapter）装到正方形里，adapter继承了正方形的接口，你以为你用的是个正方形，实际上里面是个圆。
优点：
单一职责原则：可以将接口或数据转换代码从程序主要业务逻辑中分离。
开闭原则： 只要客户端代码通过客户端接口与适配器进行交互，你就能在不修改现有客户端代码的情况下在程序中添加新类型的适配器。
缺点：
代码整体复杂度增加

#include<iostream>
using namespace std;

//Target：客户端需要的目标接口，适配器你往哪转
class JsonInfo
{
public:
        virtual ~JsonInfo() {}
        //这个就是读取的json信息，我们要实现的其实就是xml转为json
        virtual string resquest() const 
        {
                return "Some Json msg.......";
        }
};

//Adaptee: 需要转换的目标,客户端不兼容的接口，需要转换为Target
class XmlInfo
{
public:
        string specialResquest() const
        {
                return "Some Xml msg.......";
        }
};

//Adapter: 适配器，把Adaptee包装起来，让他看上去像是Target
//我们是要转为json，所以需要继承，这样才可以看上去像json
class XmlJsonAdapter :public JsonInfo
{
        
public:
        XmlJsonAdapter(XmlInfo* adptee) :m_adptee(adptee) {}

        virtual string resquest() const override
        {
                string string = m_adptee->specialResquest();
                return "Json->XmlJsonAdapter->XmlInfo";
        }
private:
        //通过对象的方式把XmlInfo内容给包住
        XmlInfo* m_adptee;
};

//表示长图的client
void clientCode(const JsonInfo* info)
{
        cout << "股票分析软件Json: " << info->resquest()<< endl;
        cout << "-----------------------" << endl;
}


int main()
{
        JsonInfo jsonInfo;
        clientCode(&jsonInfo);
        XmlInfo xmlInfo;
        XmlJsonAdapter jsonAdapter(&xmlInfo);
        clientCode(&jsonAdapter);
        return 0;
}

经典的“方钉圆孔问题”
在这里插入图片描述

/*
有一个圆孔，可以把圆钉放进去，但现在只能提供方钉，所以需要一个适配器，把方钉裹成圆钉，就可以被适配器调用了。
获得裹后圆钉的半径，方钉的宽度除2再乘根号2

圆孔就相当于client，圆钉表示客户端可以处理的类型，方钉相当于服务器提供的类型
*/
#include<iostream>
using namespace std;

//定义圆钉
class RoundPeg
{
public:
        RoundPeg(){}
        virtual ~RoundPeg() {}
        RoundPeg(const double& r) :m_radius(r) {};
        virtual int getRadius() const
        {
                return this->m_radius;
        }
private:
        int m_radius;
};

//定义方钉
class SqurePeg
{
public:
        virtual ~SqurePeg() {};
        SqurePeg(const int& wid) :m_wid(wid) {};
        int getWidth()
        {
                return m_wid;
        }
private:
        int m_wid;
};

//定义圆孔
class RoundHole
{
public:
        RoundHole(const int& r) :radius(r) {}
        int getRadius()
        {
                return this->radius;
        }
        bool fits(RoundPeg* roundPeg)
        {
                if (radius < roundPeg->getRadius())
                        return false;
                else
                        return true;
        }
private:
        int radius;
};


//定义适配器，继承自圆钉
class Adapter : public RoundPeg
{
public:
        Adapter(SqurePeg* adptee) :m_adptee(adptee) {}
        int getRadius() const override
        {
                int r = m_adptee->getWidth() * sqrt(2) / 2;
                return r;
        }

private:
        SqurePeg* m_adptee;
};


int main()
{
        //定义圆孔
        RoundHole hole =  RoundHole(5);
        //定义圆钉
        RoundPeg r_peg1 = RoundPeg(3);
        RoundPeg r_peg2 = RoundPeg(10);
        //定义方钉
        SqurePeg s_peg1 = SqurePeg(2);
        SqurePeg s_peg2 = SqurePeg(10);

        bool res = hole.fits(&r_peg1);

        if (res) cout << "r_peg1 畅通无阻" << endl;
        else cout << "r_peg1 堵死" << endl;

        res = hole.fits(&r_peg2);
        if (res) cout << "r_peg2 畅通无阻" << endl;
        else cout << "r_peg2 堵死" << endl;

        Adapter adapter(&s_peg1);
        res = hole.fits(&adapter);
        if (res) cout << "s_peg1 畅通无阻" << endl;
        else cout << "s_peg1 堵死" << endl;

        Adapter adapter2(&s_peg2);
        res = hole.fits(&adapter2);
        if (res) cout << "s_peg2 畅通无阻" << endl;
        else cout << "s_peg2 堵死" << endl;

        return 0;
}

单例模式

单例模式：一个类不管创建多少次对象，永远只能得到该类型的一个实例。像日志模块，数据库模块就会用到。
个人理解，单例本质上就是全局变量，只不过是又包装了一层。

饿汉式单例模式：

饿汉式单例，即使没调用对象，static Singleton instance;也会实例化，因为存在数据段，会在main执行前执行初始化。
一定是线程安全的，线程函数启动前实例就会初始化好。
缺点：对象的实例化会调用构造函数，但是这个构造函数在实际应用时，会构造很多东西，比如加载配置文件什么的，要是不使用这些东西，构造的不就浪费了，白费时间

 #include<iostream>
 using namespace std;
 
 class Singleton
 {
 public:
     //3 获取类的唯一实例对象的接口方法
     static Singleton* getInstance()
     {
         return &instance;
     }
 
 private:
     //2 定义一个唯一类的实例对象
     static Singleton instance;
 
     //1 构造函数私有化，并禁止拷贝构造和赋值构造
     Singleton()
     {
 
     }
     Singleton(const Singleton&) = delete;
     Singleton& operator=(const Singleton&) = delete;
 };
 
 Singleton Singleton::instance;
 
 
 int main()
 {
     Singleton* p1 = Singleton::getInstance();
     Singleton* p2 = Singleton::getInstance();
     return 0;
 }

懒汉式单例实现模式：
把对象的实例化延迟到第一次获取该实例对象的时候
线程安全的单例模式-使用互斥锁加双重判断

#include<iostream>
 #include<mutex>
 
 using namespace std;
 
 mutex mtx;
 
 class Singleton
 {
 public:
     //3 获取类的唯一实例对象的接口方法
     //锁加双重判断
     static Singleton* getInstance()
     {
         //lock_guard<mutex> guard(mtx); //锁的粒度太大了，单线程完全不用这样
         if (instance == nullptr)
         {
             lock_guard<mutex> guard(mtx);
             /*
             开辟内存
             构造对象
             给instance赋值
             */
             if (instance == nullptr)
             {
                 instance = new Singleton();
             }
         }//出括号释放锁
         return instance;
     }
 
 private:
     //2 定义一个唯一类的实例对象 存放在数据段
     static Singleton volatile instance;  //加上volatile后，当一个线程对instance改变，其他线程立马就能看到改变了，看的都是内存里的值
 
     //1 构造函数私有化，并禁止拷贝构造和赋值构造
     Singleton()
     {
 
     }
     Singleton(const Singleton&) = delete;
     Singleton& operator=(const Singleton&) = delete;
 };
 
 Singleton* volatile Singleton::instance=nullptr;
 
 
 int main()
 {
     Singleton* p1 = Singleton::getInstance();
     Singleton* p2 = Singleton::getInstance();
     return 0;
 }

上面的代码可以关注下 volatile 的用法。

观察者模式

主要关注的是对象之间的一对多通信，也就是多个对象都依赖一个对象，当该对象状态发生改变的时候，其他对象都能够接收到相应的通知。

#include<iostream>
#include<unordered_map>
#include<list>
using namespace std;

class Observer
{
public:
        //处理消息的接口
        virtual void handle(int msgid) = 0;
};

//观察者1
class Observer1 :public Observer
{
public:
        void handle(int msgid)
        {
                switch (msgid)
                {
                case 1:
                        cout << "Observer1 recv 1 msg!" << endl;
                        break;
                case 2:
                        cout << "Observer1 recv 2 msg!" << endl;
                        break;
                default:
                        cout << "Observer1 recv unknown msg!" << endl;
                        break;
                }
        }
};

//观察者2
class Observer2 :public Observer
{
public:
        void handle(int msgid)
        {
                switch (msgid)
                {
                case 2:
                        cout << "Observer2 recv 2 msg!" << endl;
                        break;
                default:
                        cout << "Observer2 recv unknown msg!" << endl;
                        break;
                }
        }
};

//观察者3
class Observer3 :public Observer
{
public:
        void handle(int msgid)
        {
                switch (msgid)
                {
                case 1:
                        cout << "Observer3 recv 1 msg!" << endl;
                        break;
                case 3:
                        cout << "Observer3 recv 3 msg!" << endl;
                        break;
                default:
                        cout << "Observer3 recv unknown msg!" << endl;
                        break;
                }
        }
};

class Subject
{
public:
        void addObserver(Observer* obs, int msgid)
        {
                //使用unordered_map,重载的[]运算符，如果找到了就直接插入，找不到会重新创建
                subMap[msgid].push_back(obs);
        }

        //主题检测发生变化，通知相应的观察者对象处理事件
        void dispatch(int msgid)
        {
                auto it = subMap.find(msgid);
                if (it != subMap.end())
                {
                        for (auto pObs : it->second)
                        {
                                pObs->handle(msgid);
                        }
                }
        }
private:
        //使用一个map存储哪个观察者对哪个消息感兴趣
        unordered_map<int, list<Observer*>> subMap;
};


int main()
{
        Subject subject;
        Observer* p1 = new Observer1();
        Observer* p2 = new Observer2();
        Observer* p3 = new Observer3();

        subject.addObserver(p1, 1);
        subject.addObserver(p1, 2);
        subject.addObserver(p2, 2);
        subject.addObserver(p3, 1);
        subject.addObserver(p3, 3);

        int msgid = 0;
        for (;;)
        {
                cout << "输入消息ID：";
                cin >> msgid;
                if (msgid == -1)
                        break;
                subject.dispatch(msgid);
        }

        return 0;
}

代理模式

这里主要说的是保护代理，即给不同的用户提供不同的对象访问权限。
通过代理类，来控制实际对象的访问权限。
下面的代码，主要是实现了用户观看普通电影，VIP电影，用券影的相关权限。

#include<iostream>
using namespace std;

//抽象类
class VideoSite
{
public:
        virtual void freeVideo() = 0;
        virtual void vipVideo() = 0;
        virtual void ticketVideo() = 0;
};

//委托类
class FixBugVideoSite :public VideoSite
{
        virtual void freeVideo()
        {
                cout << "观看免费电影" << endl;
        }
        virtual void vipVideo()
        {
                cout << "观看免费电影" << endl;
        }
        virtual void ticketVideo()
        {
                cout << "观看免费电影" << endl;
        }
};

//代理类 代理委托类
class FreeVideoSite :public VideoSite
{
public:
        FreeVideoSite() { pVideo = new FixBugVideoSite(); }
        ~FreeVideoSite() { delete pVideo; }
        //必须全部重写这些方法，要是不重写，代理类本身也成抽象类了
        void freeVideo()
        {
                pVideo->freeVideo();
        }
        void vipVideo()
        {
                cout << "您是普通用户，请升级VIP后观看" << endl;
        }
        void ticketVideo()
        {
                cout << "您未购买券，请购买后观看" << endl;
        }
private:
        VideoSite* pVideo;
};

class VipVideoSite :public VideoSite
{
public:
        VipVideoSite() { pVideo = new FixBugVideoSite(); }
        ~VipVideoSite() { delete pVideo; }
        //必须全部重写这些方法，要是不重写，代理类本身也成抽象类了
        void freeVideo()
        {
                cout << "观看普通电影" << endl;
        }
        void vipVideo()
        {
                pVideo->vipVideo();
        }
        void ticketVideo()
        {
                cout << "您未购买券，请购买后观看" << endl;
        }
private:
        VideoSite* pVideo;
};

class ticketVideoSite :public VideoSite
{
public:
        ticketVideoSite() { pVideo = new FixBugVideoSite(); }
        ~ticketVideoSite() { delete pVideo; }
        //必须全部重写这些方法，要是不重写，代理类本身也成抽象类了
        void freeVideo()
        {
                cout << "观看普通电影" << endl;
        }
        void vipVideo()
        {
                cout << "观看VIP电影" << endl;
        }
        void ticketVideo()
        {
                pVideo->ticketVideo();
        }
private:
        VideoSite* pVideo;
};

void showMovie(VideoSite* ptr)
{
        ptr->freeVideo();
        ptr->vipVideo();
        ptr->ticketVideo();
}

int main()
{
        VideoSite* p1 = new FreeVideoSite();
        VideoSite* p2 = new ticketVideoSite();
        showMovie(p1);
        showMovie(p2);
        delete p1;
        delete p2;
        return 0;
}

简单工厂模式

在创建的类比较多的时候可以使用工厂模式，主要是封装了对象的创建。
把这些对象都封装到一个工厂类里面，不需要知道这个对象是怎么创建的，就比如士兵上战场，只需要给他一把枪就可以了，不需要让他再new一个枪出来。
不符合开闭原则

#include<iostream>
#include<memory>
using namespace std;

//工厂模式主要是封装了对象的创建
/*
简单工厂模式
不符合开放封闭原则
如果要多加几个工厂，就得修改switch
*/
class Car
{
public:
        Car(string name) :m_name(name) {};
        virtual void show() = 0;
protected:
        string m_name;
};

class Bmw : public Car
{
public:
        Bmw(string name) :Car(name) {}
        void show()
        {
                cout << "购买了一辆宝马：" << m_name << endl;
        }
};

class Audi : public Car
{
public:
        Audi(string name) :Car(name) {}
        void show()
        {
                cout << "购买了一辆奥迪：" << m_name << endl;
        }
};


enum CarType
{
        BMW,
        AUDI
};

class SimpleFactory
{
public:
        Car* createCar(CarType ct)
        {
                switch (ct)
                {
                case BMW:
                        return new Bmw("X1");
                case AUDI:
                        return new Audi("A8");
                default:
                        cerr << "传入参数不正确" << endl;
                        break;
                }
                return nullptr;
        }
};

int main()
{
        unique_ptr<SimpleFactory> factory(new SimpleFactory());
        unique_ptr<Car> p1(factory->createCar(BMW));
        unique_ptr<Car> p2(factory->createCar(AUDI));
        p1->show();
        p2->show();

        return 0;
}

工厂方法

可以弥补简单工厂方法的缺点，符合开闭原则。以本例来看，如果想生产其他的汽车，只需要添加对应的工厂类即可。

#include<iostream>
#include<memory>
using namespace std;

/*
工厂方法可以解决简单工厂模式遇到的问题
一个基类，包含一个虚工厂函数，实现多态
多个子类，重写父类的工厂函数，每个工厂负责生产一种汽车，如果想生产其他的汽车，只需要添加对应的工厂类
*/

class Car
{
public:
        Car(string name) :m_name(name) {};
        virtual void show() = 0;
protected:
        string m_name;
};

class Bmw : public Car
{
public:
        Bmw(string name) :Car(name) {}
        void show()
        {
                cout << "购买了一辆宝马：" << m_name << endl;
        }
};

class Audi : public Car
{
public:
        Audi(string name) :Car(name) {}
        void show()
        {
                cout << "购买了一辆奥迪：" << m_name << endl;
        }
};

//工厂类
class Factory
{
public:
        virtual Car* createCar(string name) = 0;
};

//宝马工厂
class BmwFty : public Factory
{
        Car* createCar(string name)
        {
                return new Bmw(name);
        }
};

//奥迪工厂
class AudiFty : public Factory
{
        Car* createCar(string name)
        {
                return new Audi(name);
        }
};

int main()
{
        unique_ptr<Factory> bmwfty(new BmwFty());
        unique_ptr<Factory> audifty(new AudiFty());
        unique_ptr<Car> p1(bmwfty->createCar("X1"));
        unique_ptr<Car> p2(audifty->createCar("A8"));
        p1->show();
        p2->show();
        return 0;
}

抽象工厂方法

一个工厂可能不止是生产汽车，也要生产相关的配件。

#include<iostream>
#include<memory>
using namespace std;

/*
一个工厂不只生产车，还会生产相关的零件
*/

//产品系列1
class Car
{
public:
        Car(string name) :m_name(name) {};
        virtual void show() = 0;
protected:
        string m_name;
};

class Bmw : public Car
{
public:
        Bmw(string name) :Car(name) {}
        void show()
        {
                cout << "购买了一辆宝马：" << m_name << endl;
        }
};

class Audi : public Car
{
public:
        Audi(string name) :Car(name) {}
        void show()
        {
                cout << "购买了一辆奥迪：" << m_name << endl;
        }
};

//系列产品2
class Light
{
public:
        virtual void show() = 0;
};

class BmwLight :public Light
{
        void show()
        {
                cout << "BMW LIght" << endl;
        }
};

class AudiLight :public Light
{
        void show()
        {
                cout << "Audi LIght" << endl;
        }
};


//工厂类 -> 抽象工厂类（对有一组关联关系的产品，提供产品对象的统一创建）
//如果新建灯也写一个类，那类太多了，太麻烦了
class AbsFactory
{
public:
        virtual Car* createCar(string name) = 0; //工厂方法 创建汽车
        virtual Light* createLight() = 0; //工厂方法 创建汽车关联的产品，车灯
};

//宝马工厂
class BmwFty : public AbsFactory
{
        Car* createCar(string name)
        {
                return new Bmw(name);
        }
        Light* createLight()
        {
                return new BmwLight();
        }
};

//奥迪工厂
class AudiFty : public AbsFactory
{
        Car* createCar(string name)
        {
                return new Audi(name);
        }
        Light* createLight()
        {
                return new AudiLight();
        }
};

int main()
{
        unique_ptr<AbsFactory> bmwfty(new BmwFty());
        unique_ptr<AbsFactory> audifty(new AudiFty());
        unique_ptr<Car> p1(bmwfty->createCar("X1"));
        unique_ptr<Car> p2(audifty->createCar("A8"));
        unique_ptr<Light> l1(bmwfty->createLight());
        unique_ptr<Light> l2(audifty->createLight());
        p1->show();
        l1->show();
        p2->show();
        l2->show();
        return 0;
}

工厂模式总结：

  1. 简单工厂：把对象的创建封装到一个接口函数里，通过传入不同的标识，返回创建的对象。客户不用自己负责 new 一个对象，不用了解对象创建的详细过程。但是不符合设计模式的开闭原则。
  2. 工厂方法：定义一个基类，提供一个纯虚函数（创建产品），定义派生类（具体产品的工厂）负责创建爱你对应的产品，可以做到不同的产品在不同的工厂里创建，能够实现对现有的工厂，以及产品的修改关闭。缺点是：实际上，很多产品都会有关联关系，不应该放在不同的工厂里去创建。
  3. 抽象工厂方法：把有关联关系的的产品放在一个抽象工厂里面AbsFactory，派生类负责创建该系列所有的产品。
Ap21ril
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
C++常见设计模式——模板模式
hang_1994的博客
03-06 833
设计模式是对设计原则的具体化。用江湖话说就是武林秘籍，总结出来的一些固定套路，可以帮助有根基的程序员迅速打通任督二脉，从此做什么都特别快。常用的模式及其场景如下 C++常见设计模式——模板模式 模板模式：定义一个操作中的算法的骨架，而将一些步骤延迟到子类中。模板方法使得子类可以不改变一个算法的结构即可重定义该算法的某些特定步骤。 当多个类有相同的方法，并且逻辑相同，只是细节上有差异时，可以考虑使用...
C++ 常见设计模式教程
07-14
设计模式是软件工程中的一种通用解决方案，它描述了在软件设计中遇到的常见问题以及解决这些问题的可重用设计。设计模式不是完成的代码，而是一种模板，指导开发者如何在特定情况下解决问题。在C++中，设计模式的...
C++设计模式（23种）汇总及代码实现
songbijian的博客
09-03 4302
它是继承复用的基石，只有当衍生类可以替换掉基类，软件单位功能不受到影响的时候，基类才能真正被复用，而衍生类也能够在积累的基础上增加新的行为。提供一种遍历集合元素的统一接口，用一致的方法遍历集合元素，不需要知道集合对象的底层表示。它结合了两个独立接口的功能，将一个类的接口转换成客户期望的另一个接口，让原本不兼容的类或者函数可以协同运作，是两个不兼容的接口之间的桥梁。3.当进行深拷贝的时候，需要编写较为复杂的代码，而且当对象之间存在多重嵌套时，为了实现深克隆，每一层对象对应的类都必须支持深克隆，实现复杂。
C++：继承、模板、CRTP：谈谈C++多态设计模式
C++ JAVA的专栏
11-19 733
C++：继承、模板、CRTP：谈谈C++多态设计模式
设计模式经典入门C++篇
C++ 爱好者 make_it_simple888
02-21 1489
http://blog.csdn.net/column/details/design.html
C++ 常见设计模式
HYB3701的博客
04-25 7903
一、定义：定义一系列算法(将算法定义为虚函数，子类重写它），将它们封装起来，并使他们可互相替换（变化）。 二、应用场景：在软件构建过程中，某些对象使用的算法可能多种多样，经常改变，如果将这些算法都编码到对象中，将会使对象变得异常复杂；而且有时候支持不使用的算法也是一个性能负担（例如if/else条件判断语句有很多判断语句不会被执行）。 三、解决什么问题：在运行时根据需要透明地更改对象的算法；将算法与对象本身解耦。 原始代码设计（伪代码）： enum TaxBase { CN_Tax, ...
C++ 常见设计模式总结
qq_41952309的博客
08-22 1723
c++ 常见设计模式整理。
C++常见设计模式之组合模式
scarificed的博客
11-15 1690
1、组合模式（Composite）： 组合模式是为了解决整体和部分的一致对待的问题而产生的，要求这个整体与部分有一致的行为或操作，部分和整体都继承于一个公共的抽象类（公共操作），这样外部使用他们的时候是一致的 ，不管是对于整体还是部分使用一个方法即可遍历整体中所有的部分。上面说的可能有一些难懂，我们举一个例子。 有一家北京的公司在北京有自己的总部，还有旗下的很多个部门，这家北京的公司发展的很好，它在上海和杭州等地都有自己的分支公司，同样这些在其他地方的分公司旗下也有很多个部门，如果分支公司发展的好，同样也会
C++几种常用设计模式
热门推荐
qq_46423987的博客
09-05 1万+
设计模式
C++ 常用设计模式
qq_40309341的博客
09-15 4842
设计模式1、工厂模式1.1、简单工厂模式1.2、工厂方法模式1.3、抽象工厂模式2、策略模式2.1、传统的策略模式实现2.2、使用函数指针实现策略模式3、适配器模式3.1、使用复合实现适配器模式3.2、使用继承实现适配器模式4、单例模式4.1、懒汉单例模式4.2、饿汉单例模式5、原型模式6、模板模式7、建造者模式8、外观模式9、组合模式10、代理模式11、享元模式12、桥接模式13、装饰模式14、备忘录模式15、中介者模式16、职责链模式17、观察者模式 1、工厂模式 在工厂模式中，我们在创建对象时不会对客
C++常见设计模式的解析和实现+源码解析
03-22
本资料包"《C++常见设计模式的解析和实现》"深入浅出地探讨了23种经典的设计模式，并配以C++源代码，旨在帮助读者理解和应用这些模式。 1. **单例模式**：保证一个类只有一个实例，常用于管理共享资源，如线程池或...
C++常见设计模式的解析和实现+源码解析.rar
04-30
常见设计模式的解析和实现(C++)，真的很经典，我也在学 常见设计模式的解析和实现(C++)之一-Factory模式 常见设计模式的解析和实现(C++)之二-Abstract Factory模式 常见设计模式的解析和实现(C++)之三-Builder模式 ...
C++设计模式学习框架
01-04
"C++设计模式学习框架"是一个专为学习和实践这些模式而构建的资源集合，它涵盖了各种常见的设计模式，帮助开发者深入理解并熟练应用到实际项目中。 设计模式通常分为三类：创建型模式（Creational Patterns）、结构...
C++ 23种设计模式1
08-04
设计模式是经过时间和实践验证的解决方案，它们针对常见的编程问题提供了一套标准的模板，使得开发者能够更高效地编写可复用、可维护的代码。以下是针对23种设计模式的概述，以及C++中的实现。 **创建型模式**关注...
C++常见设计模式——单例模式
hang_1994的博客
10-31 1014
C++常见设计模式——单例模式单例模式懒汉单例模式非线程安全的懒汉单例模式线程安全的懒汉单例模式返回一个reference指向local static对象饿汉单例模式 设计模式是对设计原则的具体化。用江湖话说就是武林秘籍，总结出来的一些固定套路，可以帮助有根基的程序员迅速打通任督二脉，从此做什么都特别快。 单例模式 单例模式是一种常用的软件设计模式。 在它的核心结构中只包含一个被称为单例类的特殊类...
c++ primer plus 第16章string 类和标准模板库,string 类输入
最新发布
zhyjhacker的博客
07-14 745
c++ primer plus 第16章string 类和标准模板库,string 类输入。
C++初探究（2）
Frenemy__的博客
07-09 1490
public:// 成员函数private:// 成员变量int* array;size_t top;而我们如果想要对函数定义，则需要专门使用类域来定义函数.
05day--C++日期类的实现与取地址运算符的重载
weixin_73863912的博客
07-13 420
• const实际修饰该成员函数隐含的this指针，表明在该成员函数中不能对类的任何成员进⾏修改。const 修饰Date类的Print成员函数，Print隐含的this指针由 Date* const this 变为 const Date* const this。• 将const修饰的成员函数称之为const成员函数，const修饰成员函数放到成员函数参数列表的后⾯。取地址运算符重载分为普通取地址运算符重载和const取地址运算符重载，⼀般这两个函数编译器⾃动。⽣成的就可以够我们⽤了，不需要去显⽰实现。
c++常见的设计模式
10-17
常见的 C++ 设计模式有以下几种： 1. 工厂模式（Factory Pattern）：定义一个用于创建对象的接口，让子类决定实例化哪一个类。工厂方法使一个类的实例化延迟到其子类。 2. 单例模式（Singleton Pattern）：保证一...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

Ap21ril

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值