C++设计模式（单例模式，工厂模式）

最新推荐文章于 2024-05-19 15:48:11 发布
最新推荐文章于 2024-05-19 15:48:11 发布
阅读量459 收藏
点赞数
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/fight5_j/article/details/82941438
版权

开放封闭原则：类的改动是通过增加代码进行的，而不是修改源代码

#include <iostream>

 

using namespace std;

 

/*class BankWorker

{

public:

void SaveMoney()

{

cout << "存款业务办理" << endl;

}

 

void GetMoney()

{

cout << "取款业务办理" << endl;

}

 

void TransformMoney()

{

cout << "转账业务办理" << endl;

}

};*/

 

class BankWorker //基类

{

public:

virtual void worker() = 0;

};

 

class GetMoney : public BankWorker

{

public:

void worker()

{

cout << "取款业务办理" << endl;

}

};

 

class SaveMoney : public BankWorker

{

public:

void worker()

{

cout << "存款业务办理" << endl;

}

};

 

int main()

{

/*BankWorker *b = new BankWorker;

 

b->GetMoney();

b->SaveMoney();*/

 

BankWorker *b = new SaveMoney;

b->worker();

delete b;

 

b = new GetMoney;

b->worker();

delete b;

 

return 0;

}

 

依赖倒置原则：依赖于抽象（接口），不要依赖具体的实现（类），也就是针对接口编程

#include <iostream>

 

using namespace std;

 

class HardDisk

{

public:

virtual void work() = 0;

};

 

class AHardDisk : public HardDisk

{

public:

void work()

{

cout << "HardDisk work" << endl;

}

};

 

class CPU

{

public:

virtual void work() = 0;

};

 

class IntelCPU : public CPU

{

public:

void work()

{

cout << "cpu work" << endl;

}

};

 

class Computer

{

private:

HardDisk *m_h;

CPU *m_c;

public:

Computer(HardDisk *h, CPU *c)

{

m_h = h;

m_c = c;

}

void work()

{

m_h->work();

m_c->work();

}

};

 

int main()

{

CPU *c = new IntelCPU;

HardDisk *h = new AHardDisk;

 

Computer *com = new Computer(h, c);

com->work();

 

return 0;

}

 

单例懒汉模式

#include <iostream>

#include <pthread.h>

 

using namespace std;

 

pthread_mutex_t mutex;

 

class Singleton

{

private:

static Singleton *m_instance;

static int count;

private:

Singleton() //构造函数私有 只能在类的内部创建对象

{

}

public:

static Singleton *GetInstance()

{

if (NULL == m_instance)

{

usleep(100000);

m_instance = new Singleton;

}

count++;

return m_instance;

}

 

static int GetCount()

{

return count;

}

 

void Release()

{

count--;

if (count == 0 && m_instance != NULL)

{

delete m_instance;

}

}

};

 

Singleton * Singleton::m_instance = NULL;

int Singleton::count = 0;

 

void *CreateInstance(void *arg)

{

pthread_mutex_lock(&mutex);

Singleton *s = Singleton::GetInstance();

cout << s << endl;

pthread_mutex_unlock(&mutex);

}

 

int main()

{

/*Singleton *s1 = Singleton::GetInstance();

Singleton *s2 = Singleton::GetInstance();

Singleton *s3 = Singleton::GetInstance();

Singleton *s4 = Singleton::GetInstance();

 

cout << Singleton::GetCount() << endl;

 

if (s1 == s2)

{

cout << "equal" << endl;

}*/

 

int ret;

pthread_t tid[10];

 

pthread_mutex_init(&mutex, NULL);

 

for (int i = 0; i < 10; i++)

{

ret = pthread_create(&tid[i], NULL, CreateInstance, NULL);

if (ret != 0)

{

perror("pthread_create");

}

}

 

void *status;

for (int i = 0; i < 10; i++)

{

pthread_join(tid[i], &status);

}

pthread_mutex_destroy(&mutex);

 

return 0;

}

 

单例饿汉模式

#include <iostream>

 

using namespace std;

 

class Singleton

{

private:

static Singleton *m_instance;

static int count;

private:

Singleton() //构造函数私有 只能在类的内部创建对象

{

}

public:

static Singleton *GetInstance()

{

count++;

return m_instance;

}

 

static int GetCount()

{

return count;

}

 

void Release()

{

count--;

if (count == 0 && m_instance != NULL)

{

delete m_instance;

}

}

};

 

Singleton *Singleton::m_instance = new Singleton;

int Singleton::count = 0;

 

int main()

{

Singleton *s1 = Singleton::GetInstance();

Singleton *s2 = Singleton::GetInstance();

Singleton *s3 = Singleton::GetInstance();

Singleton *s4 = Singleton::GetInstance();

 

cout << Singleton::GetCount() << endl;

 

if (s1 == s2)

{

cout << "equal" << endl;

}

 

return 0;

}

 

简单工厂模式：

#include <iostream>

 

using namespace std;

 

class Fruit

{

public:

virtual void show() = 0;

};

 

class Apple : public Fruit

{

public:

void show()

{

cout << "This is Apple..." << endl;

}

};

 

class Banana : public Fruit

{

public:

void show()

{

cout << "This is banana..." << endl;

}

};

 

class Pear : public Fruit

{

public:

void show()

{

cout << "This is Pear..." << endl;

}

};

 

class Factory

{

public:

Fruit *CreateApple()

{

return new Apple;

}

Fruit *CreateBanana()

{

return new Banana;

}

Fruit *CreatePear()

{

return new Pear;

}

};

 

int main()

{

/*Fruit *f1 = new Apple;

Fruit *f2 = new Banana;

Fruit *f3 = new Pear;*/

 

Fruit *fruit;

Factory *f = new Factory;

 

fruit = f->CreateApple();

fruit->show();

delete fruit;

 

fruit = f->CreatePear();

fruit->show();

 

return 0;

}

 

 

开放封闭原则：类的改动是通过增加代码进行的，而不是修改源代码

#include <iostream>

 

using namespace std;

 

/*class BankWorker

{

public:

void SaveMoney()

{

cout << "存款业务办理" << endl;

}

 

void GetMoney()

{

cout << "取款业务办理" << endl;

}

 

void TransformMoney()

{

cout << "转账业务办理" << endl;

}

};*/

 

class BankWorker //基类

{

public:

virtual void worker() = 0;

};

 

class GetMoney : public BankWorker

{

public:

void worker()

{

cout << "取款业务办理" << endl;

}

};

 

class SaveMoney : public BankWorker

{

public:

void worker()

{

cout << "存款业务办理" << endl;

}

};

 

int main()

{

/*BankWorker *b = new BankWorker;

 

b->GetMoney();

b->SaveMoney();*/

 

BankWorker *b = new SaveMoney;

b->worker();

delete b;

 

b = new GetMoney;

b->worker();

delete b;

 

return 0;

}

 

依赖倒置原则：依赖于抽象（接口），不要依赖具体的实现（类），也就是针对接口编程

#include <iostream>

 

using namespace std;

 

class HardDisk

{

public:

virtual void work() = 0;

};

 

class AHardDisk : public HardDisk

{

public:

void work()

{

cout << "HardDisk work" << endl;

}

};

 

class CPU

{

public:

virtual void work() = 0;

};

 

class IntelCPU : public CPU

{

public:

void work()

{

cout << "cpu work" << endl;

}

};

 

class Computer

{

private:

HardDisk *m_h;

CPU *m_c;

public:

Computer(HardDisk *h, CPU *c)

{

m_h = h;

m_c = c;

}

void work()

{

m_h->work();

m_c->work();

}

};

 

int main()

{

CPU *c = new IntelCPU;

HardDisk *h = new AHardDisk;

 

Computer *com = new Computer(h, c);

com->work();

 

return 0;

}

 

单例懒汉模式

#include <iostream>

#include <pthread.h>

 

using namespace std;

 

pthread_mutex_t mutex;

 

class Singleton

{

private:

static Singleton *m_instance;

static int count;

private:

Singleton() //构造函数私有 只能在类的内部创建对象

{

}

public:

static Singleton *GetInstance()

{

if (NULL == m_instance)

{

usleep(100000);

m_instance = new Singleton;

}

count++;

return m_instance;

}

 

static int GetCount()

{

return count;

}

 

void Release()

{

count--;

if (count == 0 && m_instance != NULL)

{

delete m_instance;

}

}

};

 

Singleton * Singleton::m_instance = NULL;

int Singleton::count = 0;

 

void *CreateInstance(void *arg)

{

pthread_mutex_lock(&mutex);

Singleton *s = Singleton::GetInstance();

cout << s << endl;

pthread_mutex_unlock(&mutex);

}

 

int main()

{

/*Singleton *s1 = Singleton::GetInstance();

Singleton *s2 = Singleton::GetInstance();

Singleton *s3 = Singleton::GetInstance();

Singleton *s4 = Singleton::GetInstance();

 

cout << Singleton::GetCount() << endl;

 

if (s1 == s2)

{

cout << "equal" << endl;

}*/

 

int ret;

pthread_t tid[10];

 

pthread_mutex_init(&mutex, NULL);

 

for (int i = 0; i < 10; i++)

{

ret = pthread_create(&tid[i], NULL, CreateInstance, NULL);

if (ret != 0)

{

perror("pthread_create");

}

}

 

void *status;

for (int i = 0; i < 10; i++)

{

pthread_join(tid[i], &status);

}

pthread_mutex_destroy(&mutex);

 

return 0;

}

 

单例饿汉模式

#include <iostream>

 

using namespace std;

 

class Singleton

{

private:

static Singleton *m_instance;

static int count;

private:

Singleton() //构造函数私有 只能在类的内部创建对象

{

}

public:

static Singleton *GetInstance()

{

count++;

return m_instance;

}

 

static int GetCount()

{

return count;

}

 

void Release()

{

count--;

if (count == 0 && m_instance != NULL)

{

delete m_instance;

}

}

};

 

Singleton *Singleton::m_instance = new Singleton;

int Singleton::count = 0;

 

int main()

{

Singleton *s1 = Singleton::GetInstance();

Singleton *s2 = Singleton::GetInstance();

Singleton *s3 = Singleton::GetInstance();

Singleton *s4 = Singleton::GetInstance();

 

cout << Singleton::GetCount() << endl;

 

if (s1 == s2)

{

cout << "equal" << endl;

}

 

return 0;

}

 

简单工厂模式：

#include <iostream>

 

using namespace std;

 

class Fruit

{

public:

virtual void show() = 0;

};

 

class Apple : public Fruit

{

public:

void show()

{

cout << "This is Apple..." << endl;

}

};

 

class Banana : public Fruit

{

public:

void show()

{

cout << "This is banana..." << endl;

}

};

 

class Pear : public Fruit

{

public:

void show()

{

cout << "This is Pear..." << endl;

}

};

 

class Factory

{

public:

Fruit *CreateApple()

{

return new Apple;

}

Fruit *CreateBanana()

{

return new Banana;

}

Fruit *CreatePear()

{

return new Pear;

}

};

 

int main()

{

/*Fruit *f1 = new Apple;

Fruit *f2 = new Banana;

Fruit *f3 = new Pear;*/

 

Fruit *fruit;

Factory *f = new Factory;

 

fruit = f->CreateApple();

fruit->show();

delete fruit;

 

fruit = f->CreatePear();

fruit->show();

 

return 0;

}

 

 

开放封闭原则：类的改动是通过增加代码进行的，而不是修改源代码

#include <iostream>

 

using namespace std;

 

/*class BankWorker

{

public:

void SaveMoney()

{

cout << "存款业务办理" << endl;

}

 

void GetMoney()

{

cout << "取款业务办理" << endl;

}

 

void TransformMoney()

{

cout << "转账业务办理" << endl;

}

};*/

 

class BankWorker //基类

{

public:

virtual void worker() = 0;

};

 

class GetMoney : public BankWorker

{

public:

void worker()

{

cout << "取款业务办理" << endl;

}

};

 

class SaveMoney : public BankWorker

{

public:

void worker()

{

cout << "存款业务办理" << endl;

}

};

 

int main()

{

/*BankWorker *b = new BankWorker;

 

b->GetMoney();

b->SaveMoney();*/

 

BankWorker *b = new SaveMoney;

b->worker();

delete b;

 

b = new GetMoney;

b->worker();

delete b;

 

return 0;

}

 

依赖倒置原则：依赖于抽象（接口），不要依赖具体的实现（类），也就是针对接口编程

#include <iostream>

 

using namespace std;

 

class HardDisk

{

public:

virtual void work() = 0;

};

 

class AHardDisk : public HardDisk

{

public:

void work()

{

cout << "HardDisk work" << endl;

}

};

 

class CPU

{

public:

virtual void work() = 0;

};

 

class IntelCPU : public CPU

{

public:

void work()

{

cout << "cpu work" << endl;

}

};

 

class Computer

{

private:

HardDisk *m_h;

CPU *m_c;

public:

Computer(HardDisk *h, CPU *c)

{

m_h = h;

m_c = c;

}

void work()

{

m_h->work();

m_c->work();

}

};

 

int main()

{

CPU *c = new IntelCPU;

HardDisk *h = new AHardDisk;

 

Computer *com = new Computer(h, c);

com->work();

 

return 0;

}

 

单例懒汉模式

#include <iostream>

#include <pthread.h>

 

using namespace std;

 

pthread_mutex_t mutex;

 

class Singleton

{

private:

static Singleton *m_instance;

static int count;

private:

Singleton() //构造函数私有 只能在类的内部创建对象

{

}

public:

static Singleton *GetInstance()

{

if (NULL == m_instance)

{

usleep(100000);

m_instance = new Singleton;

}

count++;

return m_instance;

}

 

static int GetCount()

{

return count;

}

 

void Release()

{

count--;

if (count == 0 && m_instance != NULL)

{

delete m_instance;

}

}

};

 

Singleton * Singleton::m_instance = NULL;

int Singleton::count = 0;

 

void *CreateInstance(void *arg)

{

pthread_mutex_lock(&mutex);

Singleton *s = Singleton::GetInstance();

cout << s << endl;

pthread_mutex_unlock(&mutex);

}

 

int main()

{

/*Singleton *s1 = Singleton::GetInstance();

Singleton *s2 = Singleton::GetInstance();

Singleton *s3 = Singleton::GetInstance();

Singleton *s4 = Singleton::GetInstance();

 

cout << Singleton::GetCount() << endl;

 

if (s1 == s2)

{

cout << "equal" << endl;

}*/

 

int ret;

pthread_t tid[10];

 

pthread_mutex_init(&mutex, NULL);

 

for (int i = 0; i < 10; i++)

{

ret = pthread_create(&tid[i], NULL, CreateInstance, NULL);

if (ret != 0)

{

perror("pthread_create");

}

}

 

void *status;

for (int i = 0; i < 10; i++)

{

pthread_join(tid[i], &status);

}

pthread_mutex_destroy(&mutex);

 

return 0;

}

 

单例饿汉模式

#include <iostream>

 

using namespace std;

 

class Singleton

{

private:

static Singleton *m_instance;

static int count;

private:

Singleton() //构造函数私有 只能在类的内部创建对象

{

}

public:

static Singleton *GetInstance()

{

count++;

return m_instance;

}

 

static int GetCount()

{

return count;

}

 

void Release()

{

count--;

if (count == 0 && m_instance != NULL)

{

delete m_instance;

}

}

};

 

Singleton *Singleton::m_instance = new Singleton;

int Singleton::count = 0;

 

int main()

{

Singleton *s1 = Singleton::GetInstance();

Singleton *s2 = Singleton::GetInstance();

Singleton *s3 = Singleton::GetInstance();

Singleton *s4 = Singleton::GetInstance();

 

cout << Singleton::GetCount() << endl;

 

if (s1 == s2)

{

cout << "equal" << endl;

}

 

return 0;

}

 

简单工厂模式：

#include <iostream>

 

using namespace std;

 

class Fruit

{

public:

virtual void show() = 0;

};

 

class Apple : public Fruit

{

public:

void show()

{

cout << "This is Apple..." << endl;

}

};

 

class Banana : public Fruit

{

public:

void show()

{

cout << "This is banana..." << endl;

}

};

 

class Pear : public Fruit

{

public:

void show()

{

cout << "This is Pear..." << endl;

}

};

 

class Factory

{

public:

Fruit *CreateApple()

{

return new Apple;

}

Fruit *CreateBanana()

{

return new Banana;

}

Fruit *CreatePear()

{

return new Pear;

}

};

 

int main()

{

/*Fruit *f1 = new Apple;

Fruit *f2 = new Banana;

Fruit *f3 = new Pear;*/

 

Fruit *fruit;

Factory *f = new Factory;

 

fruit = f->CreateApple();

fruit->show();

delete fruit;

 

fruit = f->CreatePear();

fruit->show();

 

return 0;

}

 

 

 

fight5_j
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
C++ 设计模式-单例-工厂
老夫编代码就是一把梭
09-12 706
设计模式的六大原则 （1）几种设计原则的小结（6个原则的首字母组合单词（S.O.L.I.D，表示稳定） ①单一职责原则告诉我们实现类要职责单一； ②里氏替换原则告诉我们不要破坏继承体系；所有使用基类的地方必须能透明地使用子类替换，而程序的行为没有任何变化 ③依赖倒置原则告诉我们要面向接口编程； ④接口隔离原则告诉我们在设计
设计模式C++学习之单例模式（Singleton）
09-07
在C++中，还有一些其他的设计模式，如工厂模式、观察者模式、装饰器模式等，它们都有各自的用途和适用场景。理解并熟练运用这些设计模式，能够提高代码的可读性、可维护性和复用性，是每个专业程序员必备的技能。在...
工厂模式与单例模式
05-26
NULL 博文链接：https://zhaohong.iteye.com/blog/483396
C++设计模式（工厂模式）
最新发布
qq_55882840的博客
05-19 1066
简单工厂模式工厂方法模式和抽象工厂模式。工厂模式的作用是生产对象，可以简化代码、提高可维护性，并旦可以通过工厂类生产多种对象。简单工厂模式适用于创建简单的对象，工厂模式适用于创建复杂的对象，而抽象工厂模式适用于创建更复杂的对象。
单例模式+工厂模式的c++实现
meetings的专栏
06-08 1354
一、单例 #include using namespace std; class Singleton { public: static Singleton& getInst (void) { return s_inst; } private: Singleton (void) {} Singleton (const Singleton&); static Singleton
C++ 单例工厂模型
Benjaminzhou93的专栏
08-18 254
template<typename T> class Singleton { protected: Singleton() = default; public: static T& inst() { static T instance; return instance; } }; template<typename T, typename... Args> class SingletonFactory : public Singleton<Si.
C++设计模式之单例工厂模式
智能网联汽车V2X开发网的博客
05-22 471
今天居家办公第55天，疫情期间，每天抢菜，抢菜。。抢菜完成之后，就学习一会设计模式吧，今天学习的内容是工厂模式。 个人觉得工厂模式主要是为了把创建对象的代码放到专门的工厂类里，这样可以通过改一个工厂类的代码，使得整个工程的new的对象发生改变，当然工厂类得有个基类作为支撑，这样主干工程调用的方法才不用改。 ...
C++和java设计模式之单例模式
08-31
单例模式是一种常见的软件设计模式，它的核心思想是确保一个类只有一个实例，并提供一个全局访问点来获取这个唯一的实例。这种模式在很多场景下非常有用，例如控制资源的共享、管理配置信息或者创建昂贵的对象等。在...
C++中的单例模式.rar
04-06
单例模式是软件设计模式中的一种，它保证一个类只有一个实例，并提供一个全局访问点。在C++中，实现单例模式有多种方法，每种都有其优缺点。本篇文章将详细探讨C++中实现单例模式的常见方法，以及它们在实际应用中的...
常用设计模式特点比如工厂模式、单例模式等等
04-22
在本文中，我们将深入探讨两个主要的设计模式：工厂模式和单例模式，以及它们在实际应用中的特点。 1. 工厂模式： 工厂模式是一种对象创建型设计模式，它提供了一种创建对象的最佳方式，通过将实例化过程封装在单独...
23种设计模式(C++).pdf
11-29
《设计模式精解－GoF 23 种设计模式解析附 C++实现源码》是一本深入探讨软件设计模式的书籍，它涵盖了创建型、结构型和行为型三种主要类型的23个经典设计模式，并提供了C++语言的实现代码。设计模式是软件工程中的...
C++设计模式-工厂和单例
11-08
C++ 设计模式中的工厂模式和单例模式VC下源码实现
c++工厂模式
10-23 757
设计模式--工厂模式 一、什么是工厂模式 将一个复杂的对象的构建和其部件分离，将耦合度降到最低。换句话说，就是当初始化一个对象需要很多步骤、复杂工作时，不要使用new来创建对象，而是通过工厂模式抽象出来专门生成对象的一种方法。代码量会增加，但耦合度降低、维护方便。 二、代码结构实现工厂模式 工厂模式设计思路：工厂类负责对产品类的创建，即产品类不能直接实例，不能new，产品类的对象必须由工厂类创建。...
C++单例模式、工厂模式
m0_75034791的博客
03-06 1224
线程安全的懒汉式单例和饿汉式单例，三种最基本的工厂模式：简单工厂，工厂方法模式，抽象工厂，以及封装性更为良好的模板工厂，“产品注册制工厂”（产品注册模板类 + 单例工厂模板类）。
C++单例模式与工厂模式
qq_42987967的博客
07-31 1217
工厂模式中对象的创建过程是我们不需要去关心的，而我们注重的是对象的实际操作，所以，我们需要分离对象的创建和操作两部分，如此，方便后期的程序扩展和维护。在这懒汉式用的是静态局部变量的方法，充分使用了静态局部变量的特点。C#当中弱化了全局变量的声明与定义的概念，用C#写单例也相对简单的多。抽象产品类、具体产品类、抽象工厂类、具体工厂类。抽象产品类、具体产品类、抽象工厂类、具体工厂类。抽象产品类、具体产品类、一个简单工厂类。一个具体的工厂可以生产多个具体产品。每个具体工厂只能生产一种具体的产品。...
C++ Work 1
FeiSKYdeC的博客
12-25 443
《C++程序与设计》（第 3 版） WORK ONE T 1 //编写程序，输出以下信息： //Please input password : #include <iostream> using namespace std; int main () { cout << "Please input password :\n"; system ("pause"); } T 2 //编写程序，输出以下信息： //$$$$$##### * **** //This is
C++实现一个线程安全的单例工厂
zb872676223的专栏
04-18 337
我们见到经常有人用 static 局部对象的方式实现了类似单例模式,最近发现一篇文章明确写明 编译器在处理  static局部变量的时候 并不是线程安全的 ！！！http://blogs.msdn.com/b/oldnewthing/archive/2004/03/08/85901.aspx     https://blog.csdn.net/yue7603835/article/details/...
C++ 设计模式之——简单工厂模式(SimpleFactoryPattern)
行走
02-18 1715
简单工厂模式   简单工厂模式是属于创建型模式，又叫做静态工厂方法（Static Factory Method）模式，但不属于23种GOF设计模式之一。简单工厂模式是由一个工厂对象决定创建出哪一种产品类的实例。简单工厂模式是工厂模式家族中最简单实用的模式，可以理解为是不同工厂模式的一个特殊实现。 优点 工厂类是整个模式的关键.包含了必要的逻辑判断,根据外界给定的信息,决
C++设计模式：三种工厂模式详解（简单工厂，工厂模式，抽象工厂）
ylh的博客
01-04 879
简单工厂，工厂模式，抽象工厂的实现+图文详解 c++语言
C++设计模式详解：工厂模式与简单实现
"C++设计模式.pdf"是一份详细介绍C++编程中常见设计模式的文档，特别关注于如何在代码设计中实现模块化和解耦。该文档的核心内容围绕着工厂模式展开，这是一种创建型设计模式，主要用于隐藏对象的创建细节，并通过...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值