【C++高阶(八)】单例模式&特殊类的设计

简介: 【C++高阶(八)】单例模式&特殊类的设计

1. 前言

在实际场景中,总会遇见一些特殊情况,

比如设计一个类,只能在堆上开辟空间,

亦或者是设计一个类只能实例化一个对象

在实际需求的场景下,来学习这节实用课

本章重点:

本篇文章着重讲解如何设计一些特殊
的类,包括不能被拷贝,只能在栈/堆上
创建对象以及此类只能实例化一个对象,
这也就是题目中的单例模式,单例模式又
包含饿汉和懒汉模式,文章都是干货
请同学们耐心学习!


2. 设计一个不能被拷贝/继承的类

  1. 设计一个不能被拷贝的类

C++11中引入的关键字delete

就能很好的解决这个问题,并且

不仅仅要禁用拷贝,还有赋值!

class CopyBan
{
    CopyBan(const CopyBan&)=delete;
    CopyBan& operator=(const CopyBan&)=delete;
};

在C+98中,也有方法能够解决,

那就是显示将拷贝构造函数和

赋值运算符重载函数私有化!

class CopyBan
{
private:
    CopyBan(const CopyBan&);
    CopyBan& operator=(const CopyBan&);
};
  1. 设计一个不能被继承的类

使用关键字final就能解决问题

class A  final
{
    // ....
};

在C++98中,将构造函数私有化也能

达到目的,因为子类的构造会调用基类

的构造,如果私有了基类的构造就会报错!

class NonInherit
{
private:
  NonInherit()
  {}
};

3. 只能在堆上创建对象的类

只能在堆上创建对象的含义就是

必须使用new来创建对象.

本篇文章是实用性的,就直接讲方法了:

  1. 将析构函数私有化

将析构函数私有化后,由于对象析构时并不能调用到析构函数,所以不管是在堆上还是栈上创建对象都会报错!但是我们可以特殊处理,在共有域定义一个函数,此函数显示调用析构!

//思路一,封析构函数
class HeapOnly
{
public:
  void destory()
  {
    delete this;
  }
private:
  ~HeapOnly()
  {
    cout<<"调用析构成功!"<<endl;
  }
};

能否达到目的大家可以自行测试!

  1. 将构造函数私有化

将构造函数设置为私有后,不管是在堆上还是栈上都不能创建对象,但是我们可以在共有域写一个函数显示去调用构造函数,注意,这里的共有域函数必须设置为static类型,因为必须有了对象后才能调用函数,但是要调用了此函数才能创建对象,就会出现先有鸡还是先有蛋的问题,所以设置为static后,可以用类域调用!

//思路二,封构造函数
class HeapOnly
{
public:
  static HeapOnly* CreateObject(int x = 0)
  {
    return new HeapOnly(x);
  }
private:
  HeapOnly(int x = 0):_x(x)
  {}
  int _x;
};
  1. 以上两种方案真的就ok了吗?

事实上并不够ok,因为即使封掉了析构

或者是构造,人们也能用拷贝构造或

赋值来在栈上开辟空间,比如在方法二

中,我们可以这样打破规则:

HeapOnly* ho1 = HeapOnly::CreateObject(10);
HeapOnly ho(*ho1);

所以在上面两种方案的基础上
要禁用拷贝构造和赋值重载两个函数!


4. 只能在栈上创建对象的类

有了前面的思想,解决这个类型

的问题就显示很小儿科了!

同上将构造函数私有化然后设计
静态方法创建对象返回对象即可

class StackOnly
{
public:
  static StackOnly CreateObj()
  {
    return StackOnly();
  }
// 禁掉operator new可以把下面用new 调用拷贝构造申请对象给禁掉
// StackOnly obj = StackOnly::CreateObj();
// StackOnly* ptr3 = new StackOnly(obj);
  void* operator new(size_t size) = delete;
  void operator delete(void* p) = delete;
private:
  StackOnly()  
    :_a(0)
  {}
  private:
  int _a;
};

5. 只能实例化一个对象的类的介绍

一个类只能实例化一个对象
这就是大名鼎鼎的"单例模式"

谈单例模式前,先谈设计模式:

单例模式就是设计模式中的一种:

单例模式在实际场景下使用非常广泛

如果你恰好在读我的并发内存池项目

亦或者是你学过线程池(thread pool),

这里都能看见单例模式的影子,并且,

单例模式有两种实现模式:

  • 饿汉模式:就是说不管你将来用不用,程序启动时就创建一个唯一的实例对象
  • 懒汉模式:第一次使用时才创建一个唯一的实例对象

6. 饿汉模式的具体实现

注意,这里实现的是样例(demo)代码,在
不同的工程场景下需要大家做灵活的变换

// 饿汉模式
// 优点:简单
// 缺点:可能会导致进程启动慢,且如果有多个单例类对象实例启动顺序不确定。
class Singleton
{
public:
  static Singleton* GetInstance()
  {
    return _ins;
  }
private:
  //限制类外随意创建对象
  Singleton(const Singleton& s) = delete;
  Singleton& operator=(const Singleton& s) = delete;
  Singleton()
  {}
private:
  static Singleton* _ins;
};
Singleton* Singleton::_ins = new Singleton;

单例模式的饿汉模式中,程序一启动就会
把_ins,也就是唯一的实例对象给初始化,
并且由于构造函数被私有了,只能调用共
有的GetInstance()函数获取_ins对象,又
由于这个对象是static类型的,所以不管你
调用多少次GetInstance()都获取的是同
一个对象,也就是_ins


7. 懒汉模式的具体实现

//懒汉模式
class Singleton
{
public:
  static Singleton* GetInstance()
  {
    if (_ins == nullptr)//双检查加锁,只有第一次进来时需要加锁,其他情况不用加锁
    {
      imtx.lock();
      if (_ins == nullptr)//第一次调用才创建实例!
      {
        _ins = new Singleton;
      }
      imtx.unlock();
    }
    
    return _ins;
  }
  void DelInstance()
  {
    imtx.lock();
    if (_ins != nullptr)
    {
      cout << "over!!!" << endl;
      delete _ins;
      _ins = nullptr;
    }
    imtx.unlock();
  }
private:
  //限制类外随意创建对象
  Singleton(const Singleton& s) = delete;
  Singleton& operator=(const Singleton& s) = delete;
  Singleton()
  {}
private:
  static Singleton* _ins;
  static mutex imtx;
};
Singleton* Singleton::_ins = nullptr;
mutex Singleton::imtx;

与饿函数模式不同的是,懒汉模式在多线程
情况下有线程安全问题,所以在第一次拿唯
一的对象前需要加锁,并且对象在程序启动
时被置空了,只有调用了GetInstance()才会
真正的分配空间

当然,这两个模式都是样例代码,大家要随机应变


8. 总结以及拓展

特殊类的设计这块儿,大家需要在写某些

项目的时候真正运用到它才能体会出它

的作用和奥妙之处,总的来说单例模式是

使用很广泛并且很有用的一种设计模式!

对设计模式的拓展:

常见的设计模式不仅仅有单例模式,还有工厂模式、抽象工厂模式、适配器模式、装饰者模式、代理模式、外观模式、桥接模式、组合模式、享元模式、观察者模式和命令模式等,如果大家有兴趣的话可以阅读这篇文章拓展自己的知识

C++常见的11种设计模式


🔎 下期预告:C++类型转换以及IO流🔍


相关文章
|
12天前
|
存储 编译器 C语言
【c++丨STL】string类的使用
本文介绍了C++中`string`类的基本概念及其主要接口。`string`类在C++标准库中扮演着重要角色,它提供了比C语言中字符串处理函数更丰富、安全和便捷的功能。文章详细讲解了`string`类的构造函数、赋值运算符、容量管理接口、元素访问及遍历方法、字符串修改操作、字符串运算接口、常量成员和非成员函数等内容。通过实例演示了如何使用这些接口进行字符串的创建、修改、查找和比较等操作,帮助读者更好地理解和掌握`string`类的应用。
25 2
|
18天前
|
存储 编译器 C++
【c++】类和对象(下)(取地址运算符重载、深究构造函数、类型转换、static修饰成员、友元、内部类、匿名对象)
本文介绍了C++中类和对象的高级特性,包括取地址运算符重载、构造函数的初始化列表、类型转换、static修饰成员、友元、内部类及匿名对象等内容。文章详细解释了每个概念的使用方法和注意事项,帮助读者深入了解C++面向对象编程的核心机制。
53 5
|
24天前
|
存储 编译器 C++
【c++】类和对象(中)(构造函数、析构函数、拷贝构造、赋值重载)
本文深入探讨了C++类的默认成员函数,包括构造函数、析构函数、拷贝构造函数和赋值重载。构造函数用于对象的初始化,析构函数用于对象销毁时的资源清理,拷贝构造函数用于对象的拷贝,赋值重载用于已存在对象的赋值。文章详细介绍了每个函数的特点、使用方法及注意事项,并提供了代码示例。这些默认成员函数确保了资源的正确管理和对象状态的维护。
56 4
|
26天前
|
存储 编译器 Linux
【c++】类和对象(上)(类的定义格式、访问限定符、类域、类的实例化、对象的内存大小、this指针)
本文介绍了C++中的类和对象,包括类的概念、定义格式、访问限定符、类域、对象的创建及内存大小、以及this指针。通过示例代码详细解释了类的定义、成员函数和成员变量的作用,以及如何使用访问限定符控制成员的访问权限。此外,还讨论了对象的内存分配规则和this指针的使用场景,帮助读者深入理解面向对象编程的核心概念。
57 4
|
2月前
|
存储 编译器 对象存储
【C++打怪之路Lv5】-- 类和对象(下)
【C++打怪之路Lv5】-- 类和对象(下)
28 4
|
2月前
|
编译器 C语言 C++
【C++打怪之路Lv4】-- 类和对象(中)
【C++打怪之路Lv4】-- 类和对象(中)
25 4
|
2月前
|
存储 安全 C++
【C++打怪之路Lv8】-- string类
【C++打怪之路Lv8】-- string类
23 1
|
2月前
|
C++
C++单例模式
C++中使用模板实现单例模式的方法,并通过一个具体的类A示例展示了如何创建和使用单例。
33 2
|
2月前
|
存储 编译器 C++
【C++类和对象(下)】——我与C++的不解之缘(五)
【C++类和对象(下)】——我与C++的不解之缘(五)
|
2月前
|
编译器 C++
【C++类和对象(中)】—— 我与C++的不解之缘(四)
【C++类和对象(中)】—— 我与C++的不解之缘(四)