设计模式--参考代码

已于 2022-11-27 16:02:21 修改
阅读量162 收藏
点赞数
分类专栏： 设计模式 文章标签： 设计模式
于 2022-11-27 15:59:21 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_36318168/article/details/127603505
版权

目录

一、工厂模式

1.简单工厂模式

2.工厂方法模式

3.抽象工厂模式

二.单例模式

2.1不考虑内存释放

 2.2考虑内存释放

2.3单例中的多线程

其他设计模式

参考连接

一、工厂模式

1.简单工厂模式

#include <iostream>
#include <string>
#include <vector>
using namespace std;
//抽象水果
class AbstractFruit {
public:
    virtual void ShowName() = 0;
};

//苹果
class Apple :public AbstractFruit {
public:
    virtual void ShowName() {
        cout << "我是苹果!" << endl;
    }
};

//香蕉
class Banana :public AbstractFruit {
public:
    virtual void ShowName() {
        cout << "我是香蕉!" << endl;
    }
};

//鸭梨
class Pear :public AbstractFruit {
public:
    virtual void ShowName() {
        cout << "我是鸭梨!" << endl;
    }
};

//水果工厂
class FruitFactor {
public:
    static AbstractFruit * CreateFruit(string flag) {
        if (flag == "apple") {
            return new Apple;
        }
        else if (flag == "banana") {
            return new Banana;
        }
        else if (flag == "pear") {
            return new Pear;
        }
        else {
            return NULL;
        }
    }
};

void test01() {
    FruitFactor* factory = new FruitFactor;
    AbstractFruit* fruit = factory->CreateFruit("apple");
    fruit->ShowName();//父类指针指向子类对象
    delete fruit;

    fruit = factory->CreateFruit("banana");
    fruit->ShowName();
    delete fruit;

    fruit = factory->CreateFruit("pear");
    fruit->ShowName();
    delete fruit;

    fruit = NULL;
    delete factory;
    factory = NULL;
}

int main(){
    test01();
    return 0;
}

上述示例中可以得出以下结论：

(1) 在Fruit类中包含很多“if…else…”代码块，整个类的代码相当冗长，维护难度和测试难度也越大；而且大量条件语句的存在还将影响系统的性能，程序在执行过程中需要做大量的条件判断。

(2) Fruit类的职责过重，它负责初始化和显示所有的水果对象，将各种水果对象的初始化代码和显示代码集中在一个类中实现，违反了“单一职责原则”，不利于类的重用和维护；

(3) 当需要增加新类型的水果时，必须修改Fruit类的源代码，违反了“开闭原则”。
简单工厂的优缺点：

优点：

(1)实现了对象创建和使用的分离。

(2)不需要记住具体类名，记住参数即可，减少使用者记忆量。

缺点：

(1)对工厂类职责过重，一旦不能工作，系统受到影响。

(2)增加系统中类的个数，复杂度和理解度增加。

(3)违反“开闭原则”，添加新产品需要修改工厂逻辑，工厂越来越复杂。

主要适用于工厂类需要创建的对象少（对象少，那么工厂方法的业务逻辑就不会复杂），，，客户端值需要知道传入的工厂类参数，对于创建对象不关心


2.工厂方法模式

简单工厂模式的主要缺点就是不符合开闭原则 ，工厂方法模式就是改善了，符合开闭原则

工厂方法定义一个创建产品对象的工厂接口，将实际创建工作推迟到子类当中。核心工厂类不再负责产品的创建，这样核心类成为一个抽象工厂角色，仅负责具体工厂子类必须实现的接口，这样进一步抽象化的好处是使得工厂方法模式可以使系统在不修改具体工厂角色的情况下引进新的产品。

工厂方法模式=简单工厂模式+开闭原则。首先完全实现‘开－闭 原则’，实现了可扩展。

 增加新的水果需要增加新的类，类会越来越多

#include <iostream>
#include <string>
#include <vector>
using namespace std;
//抽象水果
class AbstractFruit {
public:
    virtual void ShowName() = 0;
};

//苹果
class Apple :public AbstractFruit {
public:
    virtual void ShowName() {
        cout << "我是苹果!" << endl;
    }
};

//香蕉
class Banana :public AbstractFruit {
public:
    virtual void ShowName() {
        cout << "我是香蕉!" << endl;
    }
};

//鸭梨
class Pear :public AbstractFruit {
public:
    virtual void ShowName() {
        cout << "我是鸭梨!" << endl;
    }
};

//抽象工厂  实现满足开闭原则
class AbstractFruitFactory {
public:
    virtual AbstractFruit* CreateFruit() = 0;//返回抽象水果
};


//苹果工厂
class AppleFactory :public AbstractFruitFactory {
public:
    virtual AbstractFruit* CreateFruit() {
        return new Apple;
    }
};

//香蕉工厂
class BananaFactory :public AbstractFruitFactory {
public:
    virtual AbstractFruit* CreateFruit() {
        return new Banana;
    }
};

//鸭梨工厂
class PearFactory :public AbstractFruitFactory {
public:
    virtual AbstractFruit* CreateFruit() {
        return new Pear;
    }
};


void test01() {
    AbstractFruitFactory* factory = NULL;
    AbstractFruit* fruit = NULL;

    //创建一个苹果工厂
    factory = new AppleFactory;
    fruit = factory->CreateFruit();
    fruit->ShowName();
    delete fruit;
    delete factory;

    //创建一个香蕉工厂
    factory = new BananaFactory;
    fruit = factory->CreateFruit();
    fruit->ShowName();
    delete fruit;
    delete factory;

    //创建一个鸭梨工厂
    factory = new PearFactory;
    fruit = factory->CreateFruit();
    fruit->ShowName();
    delete fruit;
    delete factory;
    fruit = NULL;
    factory = NULL;

}

int main() {
    test01();
    return 0;
}

3.抽象工厂模式

参考：3.C++设计模式-创建型模型_毕加索来喽的博客-CSDN博客 

#include <iostream>
#include <string>
#include <vector>
using namespace std;
//抽象苹果  因为有中国的  美国的
class AbstractApple {
public:
    virtual void ShowName() = 0;
};

//中国苹果
class ChinaApple :public AbstractApple {
public:
    virtual void ShowName() {
        cout << "中国苹果！" << endl;
    }
};

//美国苹果
class USAApple :public AbstractApple {
public:
    virtual void ShowName() {
        cout << "美国苹果！" << endl;
    }
};

//日本苹果
class JapanApple :public AbstractApple {
public:
    virtual void ShowName() {
        cout << "日本苹果！" << endl;
    }
};

//抽象香蕉
class AbstractBanana {
public:
    virtual void ShowName() = 0;
};

//中国香蕉
class ChinaBanana :public AbstractBanana {
public:
    virtual void ShowName() {
        cout << "中国香蕉！" << endl;
    }
};

//美国香蕉
class USABanan :public AbstractBanana {
public:
    virtual void ShowName() {
        cout << "美国香蕉！" << endl;
    }
};

//日本香蕉
class JapanBanan :public AbstractBanana {
public:
    virtual void ShowName() {
        cout << "日本香蕉！" << endl;
    }
};

//抽象鸭梨
class AbstractPear {
public:
    virtual void ShowName() = 0;
};


//中国鸭梨
class ChinaPear:public AbstractPear{
public:
    virtual void ShowName() {
        cout << "中国鸭梨！" << endl;
    }
};

//美国鸭梨
class USAPear :public AbstractPear {
public:
    virtual void ShowName() {
        cout << "美国鸭梨！" << endl;
    }
};

//日本鸭梨
class JapanPear :public AbstractPear {
public:
    virtual void ShowName() {
        cout << "日本鸭梨！" << endl;
    }
};


//抽象工厂 针对产品族
class AbstractFactory {
public:
    virtual AbstractApple* CreateApple() = 0;
    virtual AbstractBanana* CreateBanana() = 0;
    virtual AbstractPear* CreatePear() = 0;
};

//中国工厂
class ChinaFactory :public AbstractFactory {
public:
    virtual AbstractApple* CreateApple() {
        return new ChinaApple;
    }
    virtual AbstractBanana* CreateBanana(){
        return new ChinaBanana;
    }
    virtual AbstractPear* CreatePear() {
        return new ChinaPear;
    }
};

//美国工厂
class USAFactory :public AbstractFactory {
public:
    virtual AbstractApple* CreateApple() {
        return new USAApple;
    }
    virtual AbstractBanana* CreateBanana() {
        return new USABanan;
    }
    virtual AbstractPear* CreatePear() {
        return new  USAPear;
    }
};

//日本工厂
class JapanFactory :public AbstractFactory {
public:
    virtual AbstractApple* CreateApple() {
        return new JapanApple;
    }
    virtual AbstractBanana* CreateBanana() {
        return new JapanBanan;
    }
    virtual AbstractPear* CreatePear() {
        return new  JapanPear;
    }
};

void test01() {
    AbstractFactory* factory = NULL;
    AbstractApple* apple = NULL;
    AbstractBanana* banana = NULL;
    AbstractPear* pear = NULL;

    //中国工厂
    factory = new ChinaFactory;
    apple = factory->CreateApple();
    banana = factory->CreateBanana();
    pear = factory->CreatePear();

    apple->ShowName();
    banana->ShowName();
    pear->ShowName();
    //注意内存泄露
}

int main() {
    test01();
    return 0;
}

二.单例模式

系统只需要提供一个唯一的实例对象，例如Windows资源管理器，只允许使用一个公共访问点，除了这个公共访问点之外，不能通过其他的途径访问这个实例

2.1不考虑内存释放

系统只能创建一个对象，不能创建多个

类中的static：C++——【类中的static】_拾漓的博客-CSDN博客_类的static

#include <iostream>
using namespace std;

class A {
private:
    A() {
        a = new A;
    }
public:
    static A* getInstance() {
        return a;
    }
private:
    static A* a;//静态成员为所有类对象所共享，不属于某个具体的对象，存放在静态区
};
//静态成员变量必须在类内声明，类外初始化！！！ 可以通过类名：：访问或者是对象.访问
A* A::a = NULL;

//实现单例步骤
//1.构造函数私有化---防止外面还能直接new，因为new会调用构造函数
//2.增加静态私有的当前类的指针变量---一定是私有的，不然别的就有可鞥改变了，用来返回单例类创建的对象
//3.提供静态对外接口，可以让用户获得单例对象

//单例 分为懒汉式 饿汉式

//1.懒汉式(需要的时候才会创建)
class Singleton_lazy {
private:
    Singleton_lazy() { cout << "我是懒汉构造！" << endl; }
public:
    static Singleton_lazy* getInstance() {
        if (pSingleton == NULL) {
            pSingleton = new Singleton_lazy;
        }
        return pSingleton;
    }
private:
    static Singleton_lazy* pSingleton;
};
//类外初始化
Singleton_lazy* Singleton_lazy::pSingleton = NULL;

//2.饿汉式
class Singleton_hungry {
private:
    Singleton_hungry() { cout << "我是饿汉构造！" << endl; }
public:
    static Singleton_hungry* getInstance() {
        return pSingleton;
    }
private:
    static Singleton_hungry* pSingleton;
};
//类外初始化
Singleton_hungry* Singleton_hungry::pSingleton = new Singleton_hungry;//初始化就创建

void test01() {
    Singleton_lazy* p1 = Singleton_lazy::getInstance();
    Singleton_lazy* p2 = Singleton_lazy::getInstance();
    if (p1 == p2) {
        cout << "1两个指针指向同一块内存空间，是单例！" << endl;
    }
    else {
        cout << "1不是单例模式！" << endl;
    }

    Singleton_hungry* p3 = Singleton_hungry::getInstance();
    Singleton_hungry* p4 = Singleton_hungry::getInstance();
    if (p3 == p4) {
        cout << "2两个指针指向同一块内存空间，是单例！" << endl;
    }
    else {
        cout << "2不是单例模式!" << endl;
    }
}

int main() {

    //A a; // 或A*a=new A;  这两个会调用构造函数，要让不能构造函数
    //A::getInstance();

    test01();
    cout << "main函数开始执行！" << endl;

    return 0;
}

 2.2考虑内存释放

单例一般不考虑内存释放，因为只有一份

//1.单例对象从头到尾就一份内存，没必要释放
//2.如果非要提供释放，可以如下，运行完自动释放：
#include <iostream>
using namespace std;

//实现单例步骤
//1.构造函数私有化
//2.增加静态私有的当前类的指针变量
//3.提供静态对外接口，可以让用户获得单例对象

//单例 分为懒汉式 饿汉式

//1.懒汉式(需要的时候才会创建)
class Singleton_lazy {
private:
    Singleton_lazy() { cout << "我是懒汉构造！" << endl; }
public:
    static Singleton_lazy* getInstance() {
        if (pSingleton == NULL) {
            pSingleton = new Singleton_lazy;
        }
        return pSingleton;
    }
#if 0
    //不能这样释放不行，全局只有一份，万一释放，就直接没了，其余还怎么用呢？？？
	static void freeSpace() {
		if (pSingleton != NULL) {
			delete pSingleton;
		}
	}
#endif
    //如果非要写，可以加个这个，运行完自动释放
    class Garbo {
        ~Garbo() {
            if (pSingleton != NULL) {
                delete pSingleton;
            }
        }
    };


private:
    static Singleton_lazy* pSingleton;
    static Garbo garbo;
};

//类外初始化
Singleton_lazy* Singleton_lazy::pSingleton = NULL;

//2.饿汉式
class Singleton_hungry {
private:
    Singleton_hungry() { cout << "我是饿汉构造！" << endl; }
public:
    static Singleton_hungry* getInstance() {
        return pSingleton;
    }
private:
    static Singleton_hungry* pSingleton;
};

//类外初始化
Singleton_hungry* Singleton_hungry::pSingleton = new Singleton_hungry;

void test01() {
    Singleton_lazy* p1 = Singleton_lazy::getInstance();
    Singleton_lazy* p2 = Singleton_lazy::getInstance();
    if (p1 == p2) {
        cout << "两个指针指向同一块内存空间，是单例！" << endl;
    }
    else {
        cout << "不是单例模式！" << endl;
    }

    Singleton_hungry* p3 = Singleton_hungry::getInstance();
    Singleton_hungry* p4 = Singleton_hungry::getInstance();
    if (p3 == p4) {
        cout << "两个指针指向同一块内存空间，是单例！" << endl;
    }
    else {
        cout << "不是单例模式!" << endl;
    }
}

#if 0
void test02() {
	Singleton_lazy::freeSpace();
}
#endif


int main() {

    test01();
    cout << "main函数开始执行！" << endl;
    return 0;
}

2.3单例中的多线程

对于懒汉式，多线程下线程不安全，因为可能创建两次，但是在饿汉式下是线程安全的，因为在线程起来之前就已经创建好了，

其他设计模式

视频：2-13 代理概念理解案例_哔哩哔哩_bilibili

CSDN： https://blog.csdn.net/weixin_42636062/category_11313224.html?spm=1001.2014.3001.5482

3AM的小菜鸡
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
代码架构--设计模式概述
beanguys的博客
02-17 660
代码架构--设计模式一级目录二级目录三级目录 一级目录 二级目录 三级目录
代码设计模式
fjnu_se的博客
06-26 1301
代码设计模式 MVC全名是Model View Controller，是模型(model)－视图(view)－控制器(controller)的缩写，一种软件设计典范，用一种业务逻辑、数据、界面显示分离的方法组织代码，将业务逻辑聚集到一个部件里面，在改进和个性化定制界面及用户交互的同时，不需要重新编写业务逻辑。MVC被独特的发展起来用于映射传统的输入、处理和输出功能在一个逻辑的图形化用户界面的结...
一些可以用来参考的代码
weixin_43925866的博客
03-12 392
define和typedefine #include <iostream> #define INTPTR1 int * typedef int * INTPTR2; using namespace std; int main() { INTPTR1 p1, p2; // p1: int *; p2: int INTPTR2 p3, p4; // p3: int *; p4: int * int var = 1; const INTPTR1 p5 = &var; /
参考的代码
12-20
这中参考QZ都市网修改需要的代码
参考类代码参考
09-15
只是一小段参考代码，关于2018数学建模的第一题，不可以全信，只希望大家参考看看。
参考代码_sendChallenge
maqingbin8888的专栏
10-13 1222
默认返回401未认证,可以进行修改 @Override protected boolean sendChallenge(ServletRequest request, ServletResponse response) { HttpServletResponse httpResponse = WebUtils.toHttp(response); try { httpRespon...
h264/avc 参考代码
云行雨施 品物流形
03-06 1110
jm8.6 http://iphome.hhi.de/suehring/tml 解析 http://iphome.hhi.de/suehring/tml/doc/ldec/html/files.html
设计模式代码-仅供参考
04-14
"设计模式代码-仅供参考"这个主题，意味着我们将探讨如何通过代码实现这些设计模式。 在给定的标签“源码”和“工具”中，我们可以推测这个压缩包可能包含了用于理解和学习设计模式的实际代码示例。源码是理解设计...
设计模式-实例代码
07-26
总结来说，这个“设计模式-实例代码”的资源很可能提供了关于迭代器模式以及其他设计模式的实现，这对于学习和应用设计模式的开发者来说是一份宝贵的参考资料。通过研究这些代码，我们可以加深对设计模式的理解，...
研磨设计模式-配套源代码 UTF-8格式
01-22
这个UTF-8格式的压缩包包含了书中介绍的各种设计模式的实现，是学习和研究设计模式的重要参考资料。 设计模式是软件工程中的宝贵经验总结，它是在特定上下文中解决常见问题的最佳实践。通过学习和运用设计模式，...
C++设计模式 源代码.rar
06-21
本资源包含了与C++设计模式相关的课件和源代码，对于学习和理解C++设计模式非常有帮助。 首先，设计模式分为三大类：创建型、结构型和行为型。创建型模式关注对象的创建过程，如工厂方法、抽象工厂、单例等；结构型...
C#经典设计模式及代码示例
04-18
《C#经典设计模式及代码示例》是针对C#开发者深入理解并应用设计模式的一份宝贵资源。设计模式是软件工程中经过实践验证的、解决常见问题的有效模板，能够帮助程序员提高代码的可读性、可维护性和复用性。这本书结合...
常用设计模式
u010992421的专栏
07-12 938
设计模式是在软件开发中经过验证的、用于解决常见问题的最佳实践。它们可以帮助开发者设计出更加灵活、可维护和可扩展的软件系统。这些设计模式通常被分为三大类：创建型模式、结构型模式和行为型模式。
GPT带我学-设计模式13-策略模式
qq_37398465的博客
07-09 495
策略模式。
Java学习笔记整理: 关于设计模式解析和设计原则 2024/7/10；
gzx233的博客
07-10 601
Java设计模式设计原则
JavaScript设计模式 -- 代理模式
m0_73280507的博客
07-10 975
@FilePath: \设计模式\代理模式.md* @Description: 这是默认设置,请设置`customMade`, 打开koroFileHeader查看配置 进行设置: https://github.com/OBKoro1/koro1FileHeader/wiki/%E9%85%8D%E7%BD%AE。
设计模式探索：适配器模式
搬砖的小熊猫的博客
07-09 1166
将一个类的接口转换为客户期望的另一个接口，适配器可以让不兼容的两个类一起协同工作。适配器模式的主要作用是把原本不兼容的接口，通过适配修改做到统一，使得用户方便使用。比如，万能充电器和多接口数据线都是为了适配各种不同的接口。为什么要转换接口？原接口和目标接口都已经存在，不易修改接口代码。抽象接口希望复用已有组件的逻辑。优点：解耦合: 适配器模式允许两个没有直接关联的类协同工作，降低了它们之间的耦合度。提高复用性: 通过适配器，可以重用现有的类，而不需要修改它们的代码。统一接口。
java设计模式之:策略模式+工厂模式整合案例实战(一)
最新发布
royal1235的博客
07-12 297
然后通过策略工厂来获取具体的策略类：(由于只有三个策略类，所以通过注入的方式对channel进行判断)案例1：项目中对系统中的客户和销售进行事件通知(短信、邮件、钉钉)到此该版本的策略模式+工厂模式就结束了，欢迎点评和指出不足之处。首先要有通知的策略接口，接口里面要有一个方法就是通知的方法。有了接口那必然有实现类，三个实现类短信、邮件、钉钉。该案例是针对策略类比较少的情况。下一篇会讲解策略类比较多的案例。本文介绍项目中常用的。
Java面试题系列 - 第9天
一杯梅子酱的博客
07-11 884
它们是前辈开发者在实践中总结出来的经验教训，通过模式化的设计，可以减少代码的复杂性，提高代码的复用性和可维护性。设计模式的重要性在于，它们提供了一种通用的语言，使得开发者能够更有效地沟通和协作。：观察者模式 观察者模式定义了一种一对多的依赖关系，让多个观察者对象同时监听某一个主题对象。：设计模式是软件工程中解决问题的常见方案，它们提供了经过验证的模板，帮助开发者解决在软件设计过程中遇到的特定问题。设计模式的学习是一个持续的过程，随着经验的积累，开发者会更加熟练地应用这些模式来解决复杂的设计问题。
软件设计模式作业+答案
06-12
本篇文章主要总结了几种常见的软件设计模式，并提供了相应的参考链接和答案。 1. 创建型设计模式 1.1 工厂模式 工厂模式是一种创建对象的设计模式，根据不同的情况选择相应的工厂来创建对象。工厂模式符合开闭原则...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值