设计模式： 简单工厂模式 工厂方法模式 抽象工厂模式 单例模式

已于 2023-07-27 14:30:22 修改
阅读量566 收藏 1
点赞数 2
分类专栏： C++算法 文章标签： 单例模式 简单工厂模式 工厂方法模式 抽象工厂模式
于 2023-03-08 18:08:30 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/IS_MOKE/article/details/129407852
版权

目录

简单工厂模式

请添加图片描述

适用场景

（1）工厂类负责创建的对象比较少，由于创建的对象较少，不会造成工厂方法中的业务逻辑太过复杂。

（2）客户端只知道传入工厂类的参数，对于如何创建对象并不关心。

简单工厂模式的优缺点

优点：

(1)实现了对象创建和使用的分离（解耦）。对于对象创建比较复杂情况，使用时不需要考虑其他。

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

缺点：

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

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

设计与实现

class AbstractFruit {
public:
	virtual void ShowName() = 0;
};

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


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

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

enum aa { apple, banana, pear};


class FruitFactor {
public:
	static AbstractFruit* createFruit(aa flag) {
		switch (flag)
		{	
		case 0:
			return new Apple;
		case 1:
			return new Banana;
		case 2:
			return new Pear;

		default:
			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;
}

工厂方法模式

在这里插入图片描述
简单工厂模式 + “开闭原则” = 工厂方法模式

设计与实现

class AbstractFruit {
public:
	virtual void ShowName() = 0;
};

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


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

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


class abstractFruitFactory {
public:
	virtual AbstractFruit* createFruit() = 0;
};


class appleFactory:public abstractFruitFactory {
public:
	AbstractFruit* createFruit() {
		return new Apple;
	}
};


class bananaFactory :public abstractFruitFactory {
public:
	AbstractFruit* createFruit() {
		return new Banana;
	}
};

class pearFactory :public abstractFruitFactory {
public:
	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;

}

工厂方法模式的总结

传统：如果想创建两个苹果，得具体实例化两个，然后再调用功能，以后再用还得记名字

Apple a；
a.func();
Aplle b；
b.func();

工厂方法模式：可以不用具体一个对象，然后调用

factory = new AppleFactory;
fruit = factory->CreateFruit();//造a
fruit->ShowName();
fruit = factory->CreateFruit();//造b
fruit->ShowName();

抽象工厂模式

在这里插入图片描述

设计与实现


class AbstractFruit {
public:
	virtual void ShowName() = 0;
};

class ChinaApple :public AbstractFruit {
public:
	void ShowName() {
		cout << "我是中国苹果!" << endl;
	}
};


class ChinaBanana :public AbstractFruit {
public:
	void ShowName() {
		cout << "我是中国香蕉!" << endl;
	}
};

class ChinaPear :public AbstractFruit {
public:
	void ShowName() {
		cout << "我是中国鸭梨!" << endl;
	}
};

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


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

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

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


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

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


class abstractFactory {
public:
	virtual AbstractFruit* createApple() = 0;
	virtual AbstractFruit* createBanana() = 0;
	virtual AbstractFruit* createPear() = 0;
};


class ChinaFactory:public abstractFactory {
public:
	AbstractFruit* createApple(){
		return new ChinaApple;
	}
	AbstractFruit* createBanana() {
		return new ChinaBanana;
	}
	AbstractFruit* createPear() {
		return new ChinaPear;
	}
};

class USAFactory :public abstractFactory {
public:
	AbstractFruit* createApple() {
		return new USAApple;
	}
	AbstractFruit* createBanana() {
		return new USABanana;
	}
	AbstractFruit* createPear() {
		return new USAPear;
	}
};

class JapanFactory :public abstractFactory {
public:
	AbstractFruit* createApple() {
		return new JapanApple;
	}
	AbstractFruit* createBanana() {
		return new JapanBanana;
	}
	AbstractFruit* createPear() {
		return new JapanPear;
	}
};



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

	factory = new ChinaFactory();
	fruit = factory->createApple();
	fruit->ShowName();
	delete fruit;
	fruit = factory->createBanana();
	fruit->ShowName();
	delete fruit;
	fruit = factory->createPear();
	fruit->ShowName();
	delete fruit;
	delete factory;

	factory = new USAFactory();
	fruit = factory->createApple();
	fruit->ShowName();
	delete fruit;
	fruit = factory->createBanana();
	fruit->ShowName();
	delete fruit;
	fruit = factory->createPear();
	fruit->ShowName();
	delete fruit;	
	delete factory;

	factory = new JapanFactory();
	fruit = factory->createApple();
	fruit->ShowName();
	delete fruit;
	fruit = factory->createBanana();
	fruit->ShowName();
	delete fruit;
	fruit = factory->createPear();
	fruit->ShowName();
	delete fruit;
	delete factory;
	
}

抽象工厂的优缺点

优点：
(1)拥有工厂方法模式的优点

(2)当一个产品族中的多个对象被设计成一起工作时，它能够保证客户端始终只使用同一个产品族中的对象。

(3)增加新的产品族很方便，无须修改已有系统，符合“开闭原则”。

缺点：

​ 增加新的产品等级结构麻烦，需要对原有系统进行较大的修改，甚至需要修改抽象层代码，这显然会带来较大的不便，违背了“开闭原则”。

适用场景

(1) 系统中有多于一个的产品族。而每次只使用其中某一产品族。可以通过配置文件等方式来使得用户可以动态改变产品族，也可以很方便地增加新的产品族。

(2) 产品等级结构稳定。设计完成之后，不会向系统中增加新的产品等级结构或者删除已有的产品等级结构。

单例模式

通过单例模式的方法创建的类在当前进程中只有一个实例；

应用场景

配置管理
日志记录
线程池
连接池
内存池
对象池
消息队列

实现步骤

将类的构造方法定义为私有方法
定义一个私有的静态实例
提供一个公有的获取实例的静态方法

涉及知识点

static静态成员数据
static静态成员函数
template模板类
friend友元类

设计与实现

常用实现
模板实现
线程安全

模板

懒汉式（创建时不初始化）

多线程时，是线程不安全的。（多线程可能创建两个）
Singleton.h

#pragma once
namespace mySingleTon {
template<typename T>
class singleTon {
public:
	static T* instance() {
		if (m_instance == nullptr) {
			m_instance = new T();
		}
		return m_instance;
	}


private:
	singleTon() {};
	singleTon(const singleTon&){}
	~singleTon(){}
	static T* m_instance;
	singleTon<T>& operator =(const singleTon<T>);

};
template<typename T>
T* singleTon<T>::m_instance = nullptr;

};
饿汉式（创建时已经初始化）

多线程时，是线程安全的。
Singleton.h

#pragma once
namespace mySingleTon {
template<typename T>
class singleTon {
public:
	static T* instance() {
		if (m_instance == nullptr) {
			m_instance = new T();
		}
		return m_instance;
	}


private:
	singleTon() {};
	singleTon(const singleTon&){}
	~singleTon(){}
	static T* m_instance;
	singleTon<T>& operator =(const singleTon<T>);

};
template<typename T>
T* singleTon<T>::m_instance = new singleTon<T> ;
};

A.h

//#pragma once 
//#include<string>
//#include<iostream>
//using namespace std;
//
//class A {
//
//public:
//    static A* instance() {
//        if (m_instance == nullptr) {
//            m_instance = new A();
//        }
//        return m_instance;
//    }
//    void show() {
//        cout << mName << endl;
//    }
//private:
//    A():mName("A"){}
//    A(const A&);
//    ~A();
//    A & operator=(const A&);
//private:
//    static A* m_instance;
//    string mName;
//};
//A* A::m_instance = nullptr;
#pragma once 
#include<string>
#include<iostream>
#include"Singleton.h"
using namespace std;

class A {
    friend class mySingleTon::singleTon<A>;
public:
    void show() {
        cout << mName << endl;
    }
private:
    A():mName("A"){}
    A(const A&);
    ~A();
    A & operator=(const A&);
private:
    static A* m_instance;
    string mName;
};
A* A::m_instance = nullptr;

B.h

/*
#pragma once
#include<string>
#include<iostream>
#include"Singleton.h"
using namespace std;

class B {
    friend class mySingleTon::singleTon<B>;
public:
    static B* instance() {
       if (m_instance == nullptr) {
            m_instance = new A();
       }
      return m_instance;
  }
    void show() {
        cout << mName << endl;
    }
private:
    B() :mName("B") {}
    B(const B&);
    ~B();
    B& operator=(const B&);
private:
    static B* m_instance;
    string mName;
};
B* B::m_instance = nullptr;
*/
#pragma once
#include<string>
#include<iostream>
#include"Singleton.h"
using namespace std;

class B {
    friend class mySingleTon::singleTon<B>;
public:

    void show() {
        cout << mName << endl;
    }
private:
    B() :mName("B") {}
    B(const B&);
    ~B();
    B& operator=(const B&);
private:
    static B* m_instance;
    string mName;
};
B* B::m_instance = nullptr;

main.c

#include"Singleton.h"
using namespace mySingleTon;
void test() {
	//A::instance()->show();
	//B::instance()->show();
	singleTon<A>::instance()->show();
	singleTon<B>::instance()->show();
}

示例

上面是模板，和下面程序没关系，不必一起运行。

main.c

#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
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
C++设计模式：抽象工厂模式
CodeBowl的博客
12-11 2844
抽象工厂模式是一种创建型设计模式， 它能创建一系列相关的对象， 而无需指定其具体类。
设计模式：单例设计模式（全部实现方式）工厂设计模式，抽象工厂模式
10-18
单例设计模式、工厂设计模式和抽象工厂模式是常见的软件开发设计模式。这些设计模式提供了一些有用的思想和实现方式，可以帮助开发人员在设计和实现复杂的软件系统时，更加灵活和高效地进行编程。 单例设计模式是一...
设计模式创建型——抽象工厂模式
tszc95的博客
04-06 7712
抽象工厂模式（Abstract Factory Pattern）隶属于设计模式中的创建型模式，用于产品族的构建。抽象工厂是所有形态的工厂模式中最为抽象和最具一般性的一种形态。抽象工厂是指当有多个抽象角色时使用的一种工厂模式。抽象工厂模式可以向客户端提供一个接口，使客户端在不必指定产品的具体情况下，创建多个产品族中的产品对象。
设计模式：单例模式和工厂模式
Sinder小德的博客
12-07 3915
单例模式与工厂模式的基本原理和实现，以及单例模式结合工厂模式的基本应用。
Java设计模式之创建型：工厂模式详解（简单工厂+工厂方法+抽象工厂）
热门推荐
张维鹏的博客
09-13 7万+
工厂模式将目的将创建对象的具体过程屏蔽隔离起来，从而达到更高的灵活性，工厂模式可以分为三类：简单工厂模式、工厂方法模式、抽象工厂模式；简单工厂模式的核心是定义一个创建对象的接口，将对象的创建和本身的业务逻辑分离。工厂方法模式将工厂抽象化，并定义一个创建对象的接口。每增加新产品，只需增加该产品以及对应的具体实现工厂类，由具体工厂类决定要实例化的产品是哪个，将对象的创建与实例化延迟到子类。抽象工厂模式用于创建相关对象的家族。当一个产品族中需要被设计在一起工作时，通过抽象工厂模式，保证客户端始终只使用同一个产品族
设计模式：（二）单例与工厂模式
余笙的博客
02-28 1658
一、单例设计模式（Singleton） 1、概述 类的单例设计模式，就是采取一定的方法保证在整个的软件系统中，对某个类只能存在一个对象实例，并且该类只提供一个取得其对象实例的方法（静态方法）。 定义：指一个类只有一个实例，且该类能自行创建这个实例的一种模式。 举例：Windows 中只能打开一个任务管理器，这样可以避免因打开多个任务管理器窗口而造成内存资源的浪费，或出现各个窗口显示内容的不一致等错误。还有操作系统中的文件系统、多线程中的线程池、显卡的驱动程序对象、打印机的后台处理服务、应用程序的日志对象、
设计模式——工厂模式、抽象工厂、单例模式、建造者模式、原型模式
Tmoon的博客
07-16 517
设计模式(1/3)——工厂模式、抽象工厂、单例模式、原型模式、建造者模式
设计模式之单例设计模式和抽象工厂模式
Echo_Wish的博客
07-03 241
设计模式之单例设计模式和抽象工厂模式
Java设计模式---单例 工厂 代理模式
m0_69005620的博客
01-23 1607
意图：保证一个类仅有一个实例，并提供一个访问它的全局访问点。主要解决：一个全局使用的类频繁地创建与销毁所造成的资源浪费问题。何时使用：当您想控制实例数目，节省系统资源的时候。如何解决：判断系统是否已经有这个单例，如果有则返回，如果没有则创建。关键代码：构造函数是私有的。简单工厂模式（Simple Factory Pattern）意图：提供一个用于创建对象的接口，让子类决定实例化哪一个类。结构：由一个工厂类负责创建不同类的产品对象。// 简单工厂角色} else {// 抽象产品角色。
Java设计模式：工厂模式之简单工厂、工厂方法、抽象工厂（三）
码到三十五
02-28 5401
在软件设计中，工厂模式是一种常见的设计模式，它提供了一种创建对象的最佳方式。通过工厂模式，我们可以将对象的创建逻辑与使用逻辑分离，降低代码的耦合度，提高系统的可扩展性和可维护性。Java作为一种面向对象的编程语言，自然也支持工厂模式的实现。接下来，我们将详细介绍Java中工厂模式的多种实现方式。
详解常用的设计模式——单例模式、工厂模式、代理模式
一米九的博客
03-16 2555
详解几种常用的设计模式
浅析Java设计模式编程中的单例模式和简单工厂模式
09-02
为了解决这个问题，可以考虑使用更灵活的工厂方法模式或抽象工厂模式。 总结来说，单例模式和简单工厂模式在Java编程中扮演着重要角色。单例模式用于控制共享资源的唯一性，保证线程安全，并优化资源利用；而简单...
java常用设计模式-抽象工厂模式
08-26
* 抽象工厂模式可以与其他设计模式结合使用，例如工厂方法模式、单例模式等。 抽象工厂模式是一种非常有用的设计模式，它可以帮助我们降低耦合度、提高灵活性和可扩展性。但是，需要注意抽象工厂模式的缺点，并适当...
基于Java实现的23种设计模式Demo，抽象工厂模式、建造模式、工厂方法模式、原型模式、单例模式、外观模式、适配器模式等
12-29
基于Java实现的23种设计模式Demo，抽象工厂模式、建造模式、工厂方法模式、原型模式、单例模式、外观模式、适配器模式等 Java设计模式共有23种，分别为：抽象工厂模式、建造模式、工厂方法模式、原型模式、单例模式...
实例解析Java单例模式编程中对抽象工厂模式的运用
09-02
在Java编程中，单例模式和抽象工厂模式都是非常重要的设计模式，它们分别解决了不同的问题。单例模式确保一个类只有一个实例，并提供一个全局访问点，以此来控制对象的创建。而抽象工厂模式则是在一个大的系统中，当...
C++设计模式之单例模式
congwang3960的博客
06-19 219
单例模式涉及到一个单一的类，该类负责创建自己的对象，同时确保只有单个对象被创建。这个类提供了一种访问其唯一的对象的方式，可以直接访问，不需要实例化该类的对象。
Harmony设计模式-单例模式
不懂先生的博客
06-14 1141
软件设计模式（[Design pattern](https://baike.baidu.com/item/Design pattern/10186718?fromModule=lemma_inlink)），又称设计模式，是一套被反复使用、多数人知晓的、经过分类编目的、经验的总结。使用设计模式是为了可重用代码、让代码更容易被他人理解、保证代码可靠性、程序的重用性。
什么是Java中的单例模式？请列举几种常见的单例实现方式，并讨论其优缺点。请解释Java中的设计模式，并列举几种常见的设计模式及其应用场景。
weixin_53180424的博客
06-20 332
什么是Java中的单例模式？请列举几种常见的单例实现方式，并讨论其优缺点。Java中的单例模式是一种创建型设计模式，它确保一个类只有一个实例，并提供一个全局访问点来访问这个实例。这种模式在多线程环境中特别有用，因为它可以确保线程安全，避免资源冲突。instanceinstance请解释Java中的设计模式，并列举几种常见的设计模式及其应用场景。Java中的设计模式是一套被反复使用、多数人知晓的、经过分类编目的、代码设计经验的总结。
多路h265监控录放开发-（4）完成摄像机管理的数据的增删改模型层代码（单例模式）
最新发布
m0_51386664的博客
06-21 36
【代码】多路h265监控录放开发-（4）完成摄像机管理的数据的增删改模型层代码（单例模式）
java单例模式和工厂模式
08-17
工厂模式是Java中常用的设计模式之一，它属于创建型模式，提供了一种创建对象的最佳方式。工厂模式通过定义一个共同的接口或抽象类来创建对象，然后由具体的工厂类来实现这个接口或抽象类，并负责创建具体的对象。...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值