C++特殊类设计-阿里云开发者社区

零、前言

本章我们主要讲解学习特殊类的设计方式

一、不能被拷贝

想要让一个类禁止拷贝，只需让该类不能调用拷贝构造函数以及赋值运算符重载即可

方式1：

C++98下，私有化拷贝构造函数与赋值运算符重载并且只声明不定义

示例代码：

class NoCopy
{
public:
  NoCopy()
    :_a(0)
  {}
private:
  NoCopy(const NoCopy& oh);//只声明不用实现(C98)
  NoCopy& operator=(const NoCopy& oh) ;
  int _a;
};

解释：

设置成私有：如果只声明没有设置成private，用户自己如果在类外定义了，就可以不能禁止拷贝了

只声明不定义：不定义是因为该函数根本不会调用，定义了其实也没有什么意义

方式二：

C++11下，在拷贝构造函数与赋值运算符重载函数后跟上=delete

示例代码：

class NoCopy
{
public:
  NoCopy()
    :_a(0)
  {}
private:
  NoCopy(const NoCopy& oh)=delete;//C++11
  NoCopy& operator=(const NoCopy& oh)=delete;
  int _a;
};

注：C++11扩展delete的用法，delete除了释放new申请的资源外，如果在默认成员函数后跟上=delete，表示让编译器删除掉该默认成员函数，即不能被调用

示图：

二、只能在堆上创建对象

方式1：

构造函数私有化，栈上创建的对象销毁调用不了析构函数而报错；给定特有的销毁函数，对堆上变量进行销毁

示例代码：

class OnlyHeap
{
public:
  void Destory()
  {
    delete this;//类函数里调用delete
    cout << "delete" << endl;
  }
private:
  ~OnlyHeap()//析构函数私有化，栈上创建的对象销毁不能调用会报错
  {
    cout << "~OnlyHeap" << endl;
  }
  int _a;
};

解释：

构造函数私有化：对于栈上创建的对象销毁调用不了析构函数会报错，也就是间接的不让创建栈对象

给定特有的销毁函数：在类函数里可以访问私有成员，进行delete时能够使用私有的析构函数并进行释放对象

方式2：

私有化构造函数，拷贝构造。防止别人调用拷贝在栈上生成对象；提供静态的成员函数，在该静态成员函数中完成堆对象的创建

示例代码：

class OnlyHeap
{
public:
  static OnlyHeap* ObjCreat()//提供对象创建的静态成员方法
  {
    cout << "new OnlyHeap" << endl;
    return new OnlyHeap;
  }
private:
  OnlyHeap()//禁止直接调用构造
    :_a(0)
  {
    cout << "OnlyHeap" << endl;
  }
  OnlyHeap(const OnlyHeap& oh);//防止拷贝
  OnlyHeap& operator=(const OnlyHeap& oh);
  int _a;
};

解释：

私有化构造函数/拷贝构造：防止别人调用拷贝在栈上生成对象

提供静态创建对象函数：在该静态成员函数中完成堆对象的创建，类里的函数能够调用私有化的构造函数

注：一定是静态的成员函数，静态成员函数不需要依赖对象进行调用，普通的成员函数则不行

示图：

三、只能在栈上创建对象

方式1：

显示声明并私有化operator new/operator delete函数

示例代码：

class OnlyStack
{
public:
  OnlyStack()
    :_a(0)
  {
    cout << "Onlystack" << endl;
  }
private:
  //显示成私有化避免调用
  void* operator new(size_t size);
  void operator delete(void* p);
  int _a;
};

解释：

显示私有化：显示是为了让new的时候找到对象专属的operator new函数，私有化则是为了不让operator new函数不被成功使用，避免调用

注：唯一的缺点是不能避免在静态区创建对象

示图：

方式2：

私有化构造函数，提供特定创建对象的静态成员函数

示例代码：

class OnlyStack
{
public:
  static OnlyStack ObjCreat()
  {
    return OnlyStack();//类里进行调用构造
  }
private:
  OnlyStack()//构造私有化，避免new调用
    :_a(0)
  {
    cout << "OnlyStack" << endl;
  }
  int _a;
};

解释：

私有化构造函数：new一个对象=调用类的构造函数+operator new()，这里避免new调用创建对象

四、不能被继承的类

方式1：

在C++98下，私有化构造函数，提供特定的创建静态成员函数

示例：

class NonInherit
{
public:
  static NonInherit GetInstance()
  {
    return NonInherit();
  }
private:
  // 构造函数私有
  NonInherit()
  {}
};
class Derive : NonInherit
{};

解释：

C++98 这种方式不够直接，这里是可以继承的，但是Derive不能创建对象，因为Derive的构造函数必须要调用父类NonInherit构造，但是NonInherit的构造函数私有了，私有在子类不可见，那么这里继承不会报错，继承的子类创建对象会报错

方式2：

final修饰类，表示该类不能被继承

示例代码：

class NoInherit final
{
};
class Derive : NoInherit
{};

示图：

五、只能创建一个对象

设计模式的概念：

设计模式（Design Pattern）是一套被反复使用、多数人知晓的、经过分类的、代码设计经验的总结

使用设计模式的目的：

为了代码可重用性、让代码更容易被他人理解、保证代码可靠性；设计模式使代码编写真正工程化

单例模式：

一个类只能创建一个对象，即单例模式，该模式可以保证系统中该类只有一个实例，并提供一个访问它的全局访问点，该实例被所有程序模块共享

比如：

在某个服务器程序中，该服务器的配置信息存放在一个文件中，这些配置数据由一个单例对象统一读取，然后服务进程中的其他对象再通过这个单例对象获取这些配置信息，这种方式简化了在复杂环境下的配置管理

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

饿汉模式和懒汉模式

1、饿汉模式

当程序启动时就创建一个唯一的实例对象

示例代码：

class Singleton
{
public:
  static Singleton& GetInstance()//获取实例地址
  {
    return _s;
  }
  vector<int> _v;//可以选择私有也可以选择公有
private:
  Singleton();//构造私有化，禁止随意构造
  //delete拷贝构造和赋值函数，防拷贝赋值
  Singleton(const Singleton& s) = delete;
  Singleton& operator=(const Singleton& s) = delete;
  static Singleton _s;//在类里的变量都是声明，在cpp文件中进行定义
};

解释：

类里面的成员变量只是声明，而静态成员对象需要在类外进行定义，并且不能在.h文件中定义，如果多个.cpp文件包含该头文件，那么则会报重复定义的错误

效果：

优势：

实现简单

劣势：

如果单例对象构造十分耗时或者占用很多资源，比如加载插件啊，初始化网络连接啊，读取文件啊等等，而有可能该对象程序运行时不会用到，那么也要在程序一开始就进行初始化，就会导致程序启动时非常的缓慢

对于多个单例类的如果具有依赖关系的话，则无法进行控制定义顺序（静态变量）

2、懒汉模式

懒汉模式则是需要的时候在第一次调用的时候进行创建

示例代码：

class Singleton
{
public:
  //提供获取对象以及释放对象的静态方法
  static Singleton& GetInstance()
  {
    //提高效率，避免多次锁住及解锁
    if (_s == nullptr)
    {
      //保证线程安全
      _m.lock();//锁住
      if (_s == nullptr)
      {
        _s = new Singleton;
      }
      _m.unlock();//解锁
    }
    return *_s;
  }
  static void DelInstance()
  {
    //提高效率，避免多次锁住及解锁
    if (_s != nullptr)
    {
      //保证线程安全
      _m.lock();//锁住
      if (_s != nullptr)
      {
        delete _s;
        _s = nullptr;
      }
      _m.unlock();//解锁
    }
  }
  vector<int> _v;
private:
  Singleton() {};//要有函数体，否则只是声明，当new的时候找不到对应的实体
  Singleton(const Singleton& s) = delete;
  Singleton& operator=(const Singleton& s) = delete;
  static Singleton* _s;//储存实例对象地址
  static mutex _m;//互斥锁
};

解释：

对于懒汉模式需要注意的是要保证线程安全，当多个进行调用GetInstance()/DelInstance()时，可能多次进行new和delete，可能造成数据的丢失

效果：

优势：

无启动负载；可以自由控制多个单例类的定义顺序

劣势：

实现复杂

C++特殊类设计

零、前言

一、不能被拷贝

二、只能在堆上创建对象

三、只能在栈上创建对象

四、不能被继承的类

五、只能创建一个对象

1、饿汉模式

2、懒汉模式

热门文章

最新文章

相关课程

相关电子书

相关实验场景