C++设计模式（全网最通俗易懂的设计模式进阶）

最新推荐文章于 2024-06-12 13:51:17 发布
最新推荐文章于 2024-06-12 13:51:17 发布
阅读量485 收藏 3
点赞数
文章标签： 设计模式 c++ java python 数据库
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-NC-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_40523119/article/details/122649133
版权

前言

鉴于架构的重要性，在一个项目开始的时候，在b站上看了一个使用Java做架构的案例，但由于自己对java的语言并不是很熟悉，加上编译环境也没有，因此，就有了下面一个念头，使用c++，将该课程的一个设计模式进行复现。

项目背景

使用c++将完成一个计算器的功能。用户通过在键盘上输入运算符和两个数字，点击确认计算出该运算的结果。实际效果如图：

image

计算器运行结果

0基础的玩法

这个版本就如同绝大多数初学者一样，在hello world的基础上做了一个只是实现功能的，没有任何。算法或者说逻辑可言。

#include <iostream>
#include <sstream>
#include <iomanip>
using namespace std;
/*
实现一个简易的计算器
版本：v1.0
时间：2022年1月21日14:30:12
开发者：董康乐
陕西 西安

TODO v1.0 引出需求(计算器的设计)
TODO 问题：可扩展性、可维护性、高耦合性。代码不规范问题
*/

void main()
{
    std::cout << "第一版计算器v1.0" << std::endl;
    /*-----------------------------------------*/
    //定义字符和数字
    char Operator;//加减乘除四种
    double aaa = 0.0;
    double bbb = 0.0;
    std::cout << "请输入运算符：" << std::endl;
    cin >> Operator;
    std::cout << "请输入第一个数字：" << std::endl;
    cin >> aaa;
    std::cout << "请输入第二个数字：" << std::endl;
    cin >> bbb;
    /*-----------------------------------------*/
    //判断运算符 并在特定的运算符内部完成运算
    double ccc;
    if (Operator == '+')
    {
        ccc = aaa + bbb;
    }
    else
    {
        if (Operator == '-')
        {
            ccc = aaa - bbb;
        }
        else
        {
            if (Operator == '*')
            {
                ccc = aaa * bbb;
            }
            else
            {
                if (Operator == '/')
                {
                    ccc = aaa / bbb ;
                }
            }
        }
    }
    /*-----------------------------------------*/
    cout << "运算结果为：" << std::to_string(ccc);//输出结果

    std::system("pause");
}

总结：上面的代码存着很多问题，除了本身代码的相关性特别强，如果需要增加或者修改功能，需要动大量的代码以外，其命名的规范性以及容错性都没有得到解决，比如说之前要是除法中分母为零的情况。为此我们有了下面的一个升级版v1.1版本。

1 解决容错和代码命名规范

#include <iostream>
#include <sstream>
#include <iomanip>
using namespace std;
/*
实现一个简易的计算器
版本：v1.1
时间：2022年1月21日14:30:12
开发者：董康乐
陕西 西安

TODO v1.0 引出需求(计算器的设计)
解决  代码不规范  代码容错性极差的问题
TODO 问题：可扩展性、可维护性、高耦合性 
*/

void main()
{
    std::cout << "第一版计算器v1.0" << std::endl;
    /*-----------------------------------------*/

    try{
        //定义字符和数字
        char Operator;//加减乘除四种
        double Numb0 = 0.0;
        double Numb1 = 0.0;
        std::cout << "请输入运算符：" << std::endl;
        cin >> Operator;
        std::cout << "请输入第一个数字：" << std::endl;
        cin >> Numb0;
        std::cout << "请输入第二个数字：" << std::endl;
        cin >> Numb1;
        /*-----------------------------------------*/
        //判断运算符 并在特定的运算符内部完成运算
        double result;
        if (Operator == '+')
        {
            result = Numb0 + Numb0;
        }
        else
        {
            if (Operator == '-')
            {
                result = Numb0 - Numb0;
            }
            else
            {
                if (Operator == '*')
                {
                    result = Numb0 * Numb1;
                }
                else
                {
                    if (Operator == '/')
                    {
                        if (Numb1 == 0)
                        {
                            throw "Division by zero condition!";
                        }
                        result = Numb0 / Numb1 ;
                    }
                }
            }
        }
        /*-----------------------------------------*/
        cout << "运算结果为：" << std::to_string(result);//输出结果
    }
    catch (const char* msg) {
        cerr << msg << endl;
    }

    std::system("pause");
}

总结：这个版本中我们使用了try、throw、catch等方式。对代码的容错性进了进行提高，并且将命名的规范性。进一步修改。

2 客户端分离

在这个版本中，我们将客户端进行了分离。将客户端的功能在单独的一个类内实现。这么多可扩充性。高融合性等得到一定程度的解决。

main.cpp

/*
实现一个简易的计算器
版本：v1.2
时间：2022年1月21日13:50:19
开发者：董康乐
陕西西安

TODO v1.2 引出需求(计算器的设计)
使用 面向对象的思维解决 分离客户端和业务端 只是解决部分问题
TODO 问题：可扩展性、可维护性、高耦合性 解决70%
*/

#include <iostream>
#include <sstream>
#include <iomanip>
#include "Operator.h"

using namespace std;

void main()
{
    std::cout << "第一版计算器v1.2" << std::endl;
    /*-----------------------------------------*/

    try{
        //客户端
        //定义字符和数字
        char operatorFunction;//加减乘除四种
        double Numb0 = 0.0;
        double Numb1 = 0.0;
        std::cout << "请输入运算符：" << std::endl;
        cin >> operatorFunction;
        std::cout << "请输入第一个数字：" << std::endl;
        cin >> Numb0;
        std::cout << "请输入第二个数字：" << std::endl;
        cin >> Numb1;
        /*-----------------------------------------*/
        //业务端
        double result = Operator::countResult(operatorFunction, Numb0, Numb1);
        cout << "运算结果为：" << std::to_string(result);//输出结果
    }
    catch (const char* msg) {
        cerr << msg << endl;
    }

    std::system("pause");
}

实际运算的类为Operator类

其中：Operator.h

#pragma once
#include <iostream>
#include <sstream>
#include <iomanip>
using namespace std;
class Operator
{
public:
    Operator();
    ~Operator();

    static double countResult(char Operator, double Numb0, double Numb1);
};

Operator.cpp如下

/*
功能：业务端的分离
*/
#include "Operator.h"

Operator::Operator()
{

}

Operator::~Operator()
{
}

double Operator::countResult(char Operator, double Numb0, double Numb1)
{
    //判断运算符 并在特定的运算符内部完成运算
    double result;
    if (Operator == '+')
    {
        result = Numb0 + Numb0;
    }
    else
    {
        if (Operator == '-')
        {
            result = Numb0 - Numb0;
        }
        else
        {
            if (Operator == '*')
            {
                result = Numb0 * Numb1;
            }
            else
            {
                if (Operator == '/')
                {
                    if (Numb1 == 0)
                    {
                        throw "Division by zero condition!";
                    }
                    result = Numb0 / Numb1;
                }
            }
        }
    }
    return result;
}

3解决高耦合性问题

使用了对虚函数的继承的方式来实现用一个虚函数，完成整体的架构，在不同的基层函数里面完成独立的运算，解决高高耦合性问题。在这个基础上，如果我们要增加或者减少一个单独的功能，那么就会变得非常容易。在某个单独实现的内内也可以独立的进行增加内容。

主函数main.cpp

/*
实现一个简易的计算器
版本：v1.3
时间：2022年1月21日16:08:48
开发者：董康乐
陕西西安

TODO v1.3 引出需求(计算器的设计)
使用  解决可扩展性、可维护性问题
TODO 问题：高耦合性 解决70%
*/

#include <iostream>
#include <sstream>
#include <iomanip> 
#include "Operator.h"
#include "OperatorMul.h"
#include "OperatorAdd.h"
#include "OperatorSub.h"
#include "OperatorDiv.h"

using namespace std;

void main()
{
    std::cout << "第一版计算器v1.3" << std::endl;
    /*-----------------------------------------*/

    try{
        //客户端
        //定义字符和数字
        char operatorFunction;//加减乘除四种
        double Numb0 = 0.0;
        double Numb1 = 0.0;
        std::cout << "请输入运算符：" << std::endl;
        std::cin >> operatorFunction;
        std::cout << "请输入第一个数字：" << std::endl;
        cin >> Numb0;
        std::cout << "请输入第二个数字：" << std::endl;
        cin >> Numb1;
        /*-----------------------------------------*/
        //业务端
        //只面向抽象，面向高层 ，面向接口的感觉

        Operator  *oper =NULL;
        //Operator  *oper = new OperatorAdd();
        switch (operatorFunction)
        {
        case '+':
            oper = new OperatorAdd();
            break;
        case '-':
            oper = new OperatorSub();
            break;
        case '*':
            oper = new OperatorMul();
            break;
        case '/':
            oper = new OperatorDiv();
            break;
        }
        oper->setNumb0(Numb0);
        oper->setNumb1(Numb1);
        cout << "运算结果为：" << std::to_string(oper->countResult());//输出结果
    }
    catch (const char* msg) {
        cerr << msg << endl;
    }

    std::system("pause");
}

operator类

#pragma once
class Operator
{
public:
    Operator();
    ~Operator();
    double getNumb0();
    double getNumb1();

    void setNumb0(double);
    void setNumb1(double);

    virtual double countResult()=0;
private :
    double numb0;
    double numb1;

};
/*
首先定义规则。【计算器业务的规则】
抽象的：numb0、numb1、计算使用 依赖导致原则
*/
#include "Operator.h"

Operator::Operator()
{
}

Operator::~Operator()
{
}

double Operator::getNumb0()
{
    return numb0;
}

double Operator::getNumb1()
{
    return numb1;
}

void Operator::setNumb0(double numb0)
{
    this->numb0 = numb0;
}
void Operator::setNumb1(double numb1)
{
    this->numb1 = numb1;
}
/*
使用 单一职责原则
加法业务的逻辑 具体细节
*/
#include "OperatorAdd.h"
#include "Operator.h"

OperatorAdd::OperatorAdd()
{
}

OperatorAdd::~OperatorAdd()
{
}

//以后随着项目越来越多，这里面代码会越来越多
double OperatorAdd::countResult()
{
    //此处略去100万行代码
    //......
    double result = getNumb0() + getNumb1();
    return result;
}
#pragma once
#include "Operator.h"
class OperatorAdd :
    public Operator
{
public:
    OperatorAdd();
    ~OperatorAdd();
    virtual double countResult();
};
#include "OperatorDiv.h"
#include "Operator.h"

OperatorDiv::OperatorDiv()
{
}

OperatorDiv::~OperatorDiv()
{
}

//以后随着项目越来越多，这里面代码会越来越多
double OperatorDiv::countResult()
{
    //此处略去100万行代码
    //......
    double result;
    if (getNumb1() != 0)
    {
        result = getNumb0() / getNumb1();
    }
    else
    {
        throw "Division by zero condition!";
    }
    return result;
}
#pragma once
#include "Operator.h"
class OperatorDiv :
    public Operator
{
public:
    OperatorDiv();
    ~OperatorDiv();
    virtual double countResult();
};
#include "OperatorMul.h"
#include "Operator.h"

OperatorMul::OperatorMul()
{
}

OperatorMul::~OperatorMul()
{
}

//以后随着项目越来越多，这里面代码会越来越多
double OperatorMul::countResult()
{
    //此处略去100万行代码
    //......
    double result = getNumb0() * getNumb1();
    return result;
}
#pragma once
#include "Operator.h"
class OperatorMul :
    public Operator
{
public:
    OperatorMul();
    ~OperatorMul();
    virtual double countResult();
};
#include "OperatorSub.h"
#include "Operator.h"

OperatorSub::OperatorSub()
{
}

OperatorSub::~OperatorSub()
{
}

//以后随着项目越来越多，这里面代码会越来越多
double OperatorSub::countResult()
{
    //此处略去100万行代码
    //......
    double result = getNumb0() - getNumb1();
    return result;
}
#pragma once
#include "Operator.h"
class OperatorSub :
    public Operator
{
public:
    OperatorSub();
    ~OperatorSub();
    virtual double countResult();
};

4 使用设计模式解决耦合问题

在实际项目中，我们使用了设计模式中的简单工厂模式进行代码的重新架构。在此，我们为了增加代码的健壮性，做了输入之后，判断运算符的输入个数，因此做了两种模式，一种是将输入的信息转化成cha型，另外一种是将输入的信息转化成string型。String的目的是为了读取键盘中敲入了运算符的个数是多少个，如果超过一个的话，那么我们会其是他的运算符，个数超限。如果是一个的话，那么我们再进行判断，看他是不是我们本次工程中需求的四种运算符及加减乘除四种运算符，如果不是这四种运算符中的字符，我们将会报错。而在数据输入中，我们为了检验输入的数据是不是double型，我们做了进行判断，其cin.good()这样来判断字符中会不会出现其他非法字符的情况，保证运算中我们对整个运算进行了Throw监测目的是确保每次出现错误后会被cache抓到，保证cache的抓取过程中我们抓取的几种类型，一种类型是int类型，一种类型则是string类型。整个代码在main函数中暴露出来的都是高层的抽象的。具体的实现则是在它的内部实现的，给用户暴露的是相对比较简单的内容。整体代码如下：
/*
实现一个简易的计算器
版本：v1.4
时间：2022年1月21日17:04:49
开发者：董康乐
陕西西安

TODO v1.4 引出需求(计算器的设计)
使用 设计模式 简单工厂
TODO 解决耦合度高的问题

更新：try catch throw
时间：2022年1月21日21:52:24
*/

#include <iostream>
#include <sstream>
#include <iomanip> 
#include "OperatorFactory.h"

using namespace std;
int check(char buf, int len)
{
    int i;
    char tmp[1024];
    memcpy(tmp, &buf, len);
    for (i = 0; i<len; i++){
        if ((tmp[i]>0x39 || tmp[i]<0x30) && (tmp[i] != '.'))
            return 1;
    }
    return 0;
}
void main()
{
    std::cout << "第一版计算器v1.4" << std::endl;
    /*-----------------------------------------*/
    //客户端
    //定义字符和数字

    double Numb0 = 0.0;
    double Numb1 = 0.0;
    try{
        if (0)
        {
            char operatorFunction;//加减乘除四种
            std::cout << "请输入运算符：" << std::endl;
            std::cin >> operatorFunction;
            if ((operatorFunction != '+'&&operatorFunction != '-'
                &&operatorFunction != '/' && operatorFunction != '*'))
            {
                throw "运算符输入错误！";
            }

            std::cout << "请输入第一个数字：" << std::endl;
            cin >> Numb0;
            //if ()
            std::cout << "请输入第二个数字：" << std::endl;
            cin >> Numb1;
            /*-----------------------------------------*/
            //业务端//只面向抽象，面向高层 ，面向接口的感觉    //此工厂模式至面向高层 抽象
            Operator  *oper = OperatorFactory::CreatOperator(operatorFunction);
            oper->setNumb0(Numb0);
            oper->setNumb1(Numb1);
            cout << "运算结果为：" << std::to_string(oper->countResult());//输出结果
        }
        else
       {            
            string operatorFunction;//加减乘除四种

            std::cout << "请输入运算符：" << std::endl;
            std::cin >> operatorFunction;
            if ((operatorFunction.size())>1)//判断运算符个数是否过多
            {
                throw "运算符个数过多！";
            }

            if ((operatorFunction != "+"&&operatorFunction != "-"     //判断字符串是我为运算符
                &&operatorFunction != "/" && operatorFunction != "*"))
            {
                throw "运算符输入错误！";
            }

            std::cout << "请输入第一个数字：" << std::endl;
            cin >> Numb0;
            //判断输入的是否为数字(如果含有两个小数点，第二个小数点及后面的数字后默认为0)
            if (!cin.good()){
                throw "输入的第一个数字为非数字!";
            }
            std::cout << "请输入第二个数字：" << std::endl;
            cin >> Numb1;
            if (!cin.good()){
                throw "输入的第二个数字为非数字!";
            }
            /*-----------------------------------------*/
            //业务端//只面向抽象，面向高层 ，面向接口的感觉    //此工厂模式至面向高层 抽象
            Operator  *oper = OperatorFactory::CreatOperator(operatorFunction);
            oper->setNumb0(Numb0);
            oper->setNumb1(Numb1);
            cout << "运算结果为：" << std::to_string(oper->countResult());//输出结果
        }

    }
    //此处的catch监测的是运算符输入是否正确，
    //如果错误，则被判断运算符的throw监测，并输出字符串类型的异常信息，
    //这个catch就会抓住，并显示这个字符串
    catch (const char* e) {        
        cout << e << endl;
    }

    //此处的catch监测的是除法运算中分母为零的错误，
    //如果错误，则被判断分母为零的throw监测(在OperatorDiv类中监测)，并输出int类型的异常信息(0)，
    //这个catch就会抓住，并显示这个字符串
    catch (int e) {
        cout << "发生异常！监测到除法运算中分母为： " <<to_string(e) << endl;
    }

    //对于其他不好说的错误，则在这个catch中被检测
    catch (...) {
        cout << "发生其他未知异常！" << endl;
    }
    std::system("pause");
}

/*
关于try catch throw
一、基本理论
try用来保护特定行内的代码，确保其正确，一旦有异常，会被检测到
throw检测器所在上面的所有代码，
catch 监测异常的情况；根据不同的throw类型，来检测不同的异常；对于三不管的代码，则是catch(...)来输出
其中，一致的catch顺序只能是顺序执行，因此我们通常将catch(...)放在最后，把最后一道关
    try{

        //此处有十万行代码-------代码段1
            throw xxx(类型)；//此处的throw只负责监控上面10w行代码，下面的一百万行代码2，还是“黑跑”
        //此处有一百万行代码-------代码段2
            throw yyy(类型)；//此处的throw只负责监控上面10w行代码1和一百万行代码2，下面的1000w行代码不保护
        //此处有一千万行代码-------代码段3
            throw zzz(类型)；
    }
    catch(xxx(类型))
    {

    }
    catch(yyy(类型))
    {

    }
    catch(zzz(类型))
    {

    }
    catch(...)//检测其他方面的
    {

    }

*/
/*
首先定义规则。【计算器业务的规则】
抽象的：numb0、numb1、计算使用 依赖导致原则
*/
#include "Operator.h"

Operator::Operator()
{
}

Operator::~Operator()
{
}

double Operator::getNumb0()
{
    return numb0;
}

double Operator::getNumb1()
{
    return numb1;
}

void Operator::setNumb0(double numb0)
{
    this->numb0 = numb0;
}
void Operator::setNumb1(double numb1)
{
    this->numb1 = numb1;
}
#pragma once
class Operator
{
public:
    Operator();
    ~Operator();
    double getNumb0();
    double getNumb1();

    void setNumb0(double);
    void setNumb1(double);

    virtual double countResult()=0;
private:
    double numb0;
    double numb1;

};
#include "OperatorFactory.h"
#include <iostream>
#include <sstream>
#include <iomanip> 
#include "Operator.h"
#include "OperatorMul.h"
#include "OperatorAdd.h"
#include "OperatorSub.h"
#include "OperatorDiv.h"
#include <iostream>
#include <sstream>
#include <iomanip> 

//前面应用了 依赖倒置原则 +  单一职责原则
//再次应用 简单工厂模式 来解决 客户端的解耦合

OperatorFactory::OperatorFactory()
{
}

OperatorFactory::~OperatorFactory()
{
}

//给用户暴露的永远是高层和抽象，而不是暴露细节，
//如果暴露工具类，那就是工具类了，就不再是我们这次的工厂模式
Operator* OperatorFactory::CreatOperator(char oper_char )
{
    Operator  *oper = NULL;
    switch (oper_char)
    {
    case '+':
        oper = new OperatorAdd();
        break;
    case '-':
        oper = new OperatorSub();
        break;
    case '*':
        oper = new OperatorMul();
        break;
    case '/':
        oper = new OperatorDiv();
        break;
    }
    return oper;
}

Operator* OperatorFactory::CreatOperator(string oper_string)
{
    Operator  *oper = NULL;
    char  oper_char = oper_string[0];
    switch (oper_char)
    {
    case '+':
        oper = new OperatorAdd();
        break;
    case '-':
        oper = new OperatorSub();
        break;
    case '*':
        oper = new OperatorMul();
        break;
    case '/':
        oper = new OperatorDiv();
        break;
    }
    return oper;
}
#pragma once
#include <iostream>
#include <sstream>
#include <iomanip> 
#include "Operator.h"
#include "OperatorMul.h"
#include "OperatorAdd.h"
#include "OperatorSub.h"
#include "OperatorDiv.h"
using namespace std;
class OperatorFactory
{
public:
    OperatorFactory();
    ~OperatorFactory();
    /*传入 一个计算器的操作符号*/
    static Operator* CreatOperator(char);
    static Operator* CreatOperator(string);

};
/*
使用 单一职责原则
加法业务的逻辑 具体细节
*/
#include "OperatorAdd.h"
#include "Operator.h"

OperatorAdd::OperatorAdd()
{
}

OperatorAdd::~OperatorAdd()
{
}

//以后随着项目越来越多，这里面代码会越来越多
double OperatorAdd::countResult()
{
    //此处略去100万行代码
    //......
    double result = getNumb0() + getNumb1();
    return result;
}
#pragma once
#include "Operator.h"
class OperatorAdd :
    public Operator
{
public:
    OperatorAdd();
    ~OperatorAdd();
    virtual double countResult();
};
#include "OperatorDiv.h"
#include "Operator.h"

OperatorDiv::OperatorDiv()
{
}

OperatorDiv::~OperatorDiv()
{
}

//以后随着项目越来越多，这里面代码会越来越多
double OperatorDiv::countResult()
{
    //此处略去100万行代码
    //......
    double result;
    if (getNumb1() != 0)
    {
        result = getNumb0() / getNumb1();
    }
    else
    {
        throw 0;//如果分母为零，则会再次被throw监测到，经这个int类型的变量甩出，并被第二个catch(int)监测
    }
    return result;
}
#pragma once
#include "Operator.h"
class OperatorDiv :
    public Operator
{
public:
    OperatorDiv();
    ~OperatorDiv();
    virtual double countResult();
};
#include "OperatorMul.h"
#include "Operator.h"

OperatorMul::OperatorMul()
{
}

OperatorMul::~OperatorMul()
{
}

//以后随着项目越来越多，这里面代码会越来越多
double OperatorMul::countResult()
{
    //此处略去100万行代码
    //......
    double result = getNumb0() * getNumb1();
    return result;
}
#pragma once
#include "Operator.h"
class OperatorMul :
    public Operator
{
public:
    OperatorMul();
    ~OperatorMul();
    virtual double countResult();
};
#include "OperatorSub.h"
#include "Operator.h"

OperatorSub::OperatorSub()
{
}

OperatorSub::~OperatorSub()
{
}

//以后随着项目越来越多，这里面代码会越来越多
double OperatorSub::countResult()
{
    //此处略去100万行代码
    //......
    double result = getNumb0() - getNumb1();
    return result;
}
#pragma once
#include "Operator.h"
class OperatorSub :
    public Operator
{
public:
    OperatorSub();
    ~OperatorSub();
    virtual double countResult();
};

参考文献

设计模式演变try块和异常处理try、catch语句

rexinx
关注
  • 0
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
Delphi设计模式讲解代码示例讲解
05-06
这本书用通俗易懂的语言和实用的范例，解说了23个经典的设计模式，并提供了模式编程的实践范例。 3. Delphi设计模式的示例：博客园上有文章详细介绍了Delphi中的设计模式，包括工厂模式、适配器模式等，并通过...
设计模式C++实现
11-12
对于GoF设计模式的精解 内容翔实易懂，是不可多得的设计模式学习入门教材 用C++实现设计模式实例，语言通俗易懂
C++设计模式（全23种）
热门推荐
weixin_45712636的博客
04-27 6万+
设计模式概述 设计模式是软件开发人员在软件开发过程中面临的一般问题的解决方案。这些解决方案是众多软件开发人员经过相当长的一段时间的试验和错误总结出来的。等这种思想融入到了思想中后，你就会不自觉地使用这种思想去进行你的设计和开发。 文章目录设计模式概述一、创建型模式Factory 模式（工厂模式）AbstactFactory 模式（抽象工厂模式）Singleton 模式（ 单例模式）Builder 模式（建造者模式）Prototype 模式（原型模式）二、结构型模式Bridge 模式（桥接模式）总结
C++中的23种设计模式
最新发布
GOLOJO的博客
06-12 2267
C++的23种设计模式
C++设计模式总结
长期更新Java自学笔记
09-06 4468
一、单例模式 一个类不管常见多少次对象，永远只能得到该类型一个对象的实例 // p1、p2、p3指向同一对象 A* p1 = new A(); A* p2 = new A(); A* p3 = new A(); 饿汉式单例模式： 还没有获取实例对象，实例对象就已经产生了 优点：线程安全。对象存放在数据段，main函数还没有开始执行，对象就已经初始化好了，一定是线程安全的。 缺点： 获取在软件启动的时候，并没有使用到这个对象，然而这个对象已经产生，这就比较浪费资源。 #include<iostream
c++—设计模式
m0_72814368的博客
06-05 2590
c++—设计模式
C++常用的11种设计模式解释及示例
独行猫a 的沉淀、积累、总结。天天学习，好好向上...c/c++,嵌入式 linux,Android,HarmonyOS)
02-06 5552
c++常用的设计模式包括单例模式、工厂模式、抽象工厂模式、适配器模式、装饰者模式、代理模式、外观模式、桥接模式、组合模式、享元模式、观察者模式和命令模式等。 使用设计模式的好处：提高代码的可读性和可维护性；将常见的设计问题隔离程序的业务逻辑；重用已有的实现；消除重复代码；消除手动调整代码以达到正确逻辑的所有痛苦。
C++几种常用设计模式
qq_46423987的博客
09-05 1万+
设计模式
经典C++设计模式 不要错过啊 通熟易懂的
10-10
经典C++设计模式是软件开发中的重要课题，它能够帮助程序员编写可复用、可维护和可扩展的代码。本教程以通俗易懂的方式讲解了这些模式，使初学者也能快速掌握。 首先，我们要理解设计模式的基本概念。设计模式不是...
c++语音程序设计（第2版）
10-16
《C++语言程序设计》以通俗易懂的语言，系统地介绍了C++语言的面向对象设计思想及编程方法，为读者迅速掌握C++的面向对象方法和规则提供了很好的参考。本书共分15 章，全面地、系统地、深入地讲解了C++程序设计语言...
matlab改变代码颜色-PTrack2:PTrack2是用C++实现的粒子识别软件，它使用一些众所周知的设计模式来实现可扩展性和代码重用
05-26
matlab改变代码颜色＃欢迎使用PTrack2 Wiki页面 PTrack2是一种用C ++实现的粒子识别软件，它使用一些众所周知的设计模式来实现可扩展性和代码重用。 该软件基于Mauricio Cerda C的第一个实现和Scott Waitukaitis变体，用于识别智利大学物理系的高密度图像中的粒子。 所使用的算法是基于第一个粒子识别算法，该算法使用Mark D. Shattuck教授基于卷积的最小二乘拟合实现，该算法在中实现。 笔记 2015年10月6日使用OSX（El Capitan的最新版本）时，正确安装Xcode和命令工具非常重要。 这应该通过在终端中执行xcode-select --install来完成。 不这样做可能会在安装和执行时出现问题。 2015-10-07由于ImageMagick的更改，某些图像现在被视为sRGB，在读取时会产生一些错误。 如果存在问题，请将这些图像的色彩空间更改为RGB。
二十四种设计模式全实现_含图解
12-09
二十四设计模式在暑假空余时间的全实现，附带图解材料阅读。
C++ 中 10 种常见设计模式实现
sinat_28305511的博客
06-08 1044
C++ 10中常见设计模式，强烈建议收藏
《C++ 新经典》设计模式前言
Alkaid#3529的博客
11-26 328
本系列将详细剖析王建伟老师编著的 《C++ 新经典 设计模式》一书，结合书中知识与笔者个人分析，对设计模式进行详细讲解，希望对初学者能够有所帮助。本文将作为此系列的引言，首先为大家介绍设计模式的概念和各种模式的分类。
C++设计模式（建议收藏）
qq_56999918的博客
10-04 1684
如果在多线程环境下线程一判断完这个_inst为空由于时间片的原因被切走了，此时线程二进来发现为空创建了对象，当线程一再次被切回来的时候，继续往下执行又创建了一份对象此时和我们预期的就不一样了。单例模式是指在内存当中只会创建一次对象的设计模式，有时候在一个程序当中多次使用一个对象并且作用相同时，此时如果创建多个对象是非常的浪费内存的，单例模式可以让对象在内存当中只被创建一份。单例模式在面试当中也是考察的非常多的一个设计模式，在面试当中需要我们掌握的是场景的两种一种是懒汉模式，一种是饿汉模式。
程序开发的23种模式
u013430241的博客
07-28 694
一、设计模式的分类 总体来说设计模式分为三大类： 创建型模式，共五种：工厂方法模式、抽象工厂模式、单例模式、建造者模式、原型模式。 结构型模式，共七种：适配器模式、装饰器模式、代理模式、外观模式、桥接模式、组合模式、享元模式。 行为型模式，共十一种：策略模式、模板方法模式、观察者模式、迭代子模式、责任链模式、命令模式、备忘录模式、状态模式、访问者模式、中介者模式、解释器模式。 其实还有两类
设计模式（C++）
u013183558的博客
01-31 165
简单介绍了几种常见的设计模式，带有具体的C++代码实现
C++ 设计模式原理与实战大全-架构师需备课程
06-12
C++属于难学易用的工程开发语言，C++繁复的语法往往使得开发人员过于强调细节而缺乏软件体系结构的大局观。特别需要指出的是，缺乏面向对象的软件设计能力是制约从业人员从开发者向设计者转变的重要因素。设计模式是来源于工业实践的重要开发经验，它实际上是面向对象的数据结构，掌握设计模式是掌握面向对象设计的根本要求，该课程基于C++语言讲解设计模式。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

rexinx

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

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

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

打赏作者

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

抵扣说明：

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

余额充值