特殊类的设计

设计一个类不能被拷贝

IO流也是不允许拷贝的

• 思路
  拷贝只会放生在两个场景中：拷贝构造函数以及赋值运算符重载，
  因此想要让一个类禁止拷贝， 只需让该类不能调用拷贝构造函数以及赋值运算符重载即可。

• 实现：分为C++11之前和C++11以及C++11之后

  • C++98
    将拷贝构造函数与赋值运算符重载只声明不定义，并且将其访问权限设置为私有即可。

    class CopyBan
    {// ...
    private:CopyBan(const CopyBan&);CopyBan& operator=(const CopyBan&);//...
    };
    

    • 设计为私有的原因：如果不设计为私有，那么用户可以在类外对这个构造函数和析构函数进行定义，这样的话就又能拷贝了。为了防止这种情况才设计为私有。 赋值重载设置为私有的原因也是如此
      设计为公有导致在类外定义构造函数，使得又能被拷贝的场景

      class ListNode
      {
      public:ListNode(const ListNode& node);ListNode() = default;
      private:string _s;
      };ListNode::ListNode(const ListNode& node)
      {_s = node._s;cout << _s << endl;
      }int main()
      {ListNode node;ListNode copenode(node);
      }
      

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

  • C++11

    • C++11扩展delete的用法，delete除了释放new申请的资源外，如果在默认成员函数后跟上 =delete，表示让编译器删除掉该默认成员函数。*
      delete后，就删除掉了该默认成员函数，在public中删除，还是在private中删除都是可以的。类外无法去定义该函数，因为该函数被删除了

    • 样例

      class ListNode
      {
      public:ListNode(const ListNode& node) = delete;ListNode() = default;
      private:string _s;
      };//ListNode::ListNode(const ListNode& node)
      //{
      //	_s = node._s;
      //	cout << _s << endl;
      //}int main()
      {ListNode node;//ListNode copenode(node);
      }
      

设计一个类，只能在堆上创建对象

• 思路1
  **将类的构造函数私有，拷贝构造声明成私有/删除拷贝构造。**防止别人调用拷贝在栈上生成对象。 然后提供一个静态的成员函数，在该静态成员函数中完成堆对象的创建

  • 样例

    class HeapOnly
    {
    public:static HeapOnly* CreateObject(){return new HeapOnly;}
    private:HeapOnly() {}// C++98// 1.只声明,不实现。因为实现可能会很麻烦，而你本身不需要// 2.声明成私有HeapOnly(const HeapOnly&);// or// C++11    HeapOnly(const HeapOnly&) = delete;
    };int main()
    {	HeapOnly* p1 = HeapOnly::GreatObj();//HeapOnly p2(*p1); 上面防拷贝是为了应对这种情况。
    }
    

    1

• 思路2：析构函数私有化，然后提供一个 销毁new出来对象的函数Destroy

  class HeapOnly
  {
  public:void Destroy(){delete this;}
  private:~HeapOnly(){}
  };int main()
  {	HeapOnly* p1 = HeapOnly::GreatObj();//HeapOnly p2(*p1); 上面不用封拷贝构造的原因是 析构函数被封了，p2创建不出来
  }
  

设计一个类，只能在栈上创建对象

• **关于operator new 与 operator delete：**当一个类重载了 关键字new后，那么new 这个对象的时候，是调用这个operator new 来创建对象。

• 思路1
  将构造函数私有化，然后设计静态方法创建对象返回即可。并且把 operator new 给delete。

  • 样例

    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;
    };int main()
    {// StackOnly* p1 = new StackOnly; 是调不动的StackOnly p2 = StackOnly::CreateObj();StackOnly p3(p2);
    }
    

  • 缺陷：该方法无法给封住静态成员，而静态成员在静态区。

• 思路2
  把构造函数，拷贝构造封死。提供移动构造

  • 样例

    class StackOnly
    {
    public:static StackOnly CreateObj(){return StackOnly();}StackOnly(StackOnly&& sty){}StackOnly(const StackOnly& cop) = delete;
    private:StackOnly():_a(0){}
    private:int _a;
    };int main()
    {// StackOnly* p1 = new StackOnly; 是调不动的//StackOnly p3(p2);StackOnly p2 = StackOnly::CreateObj();//缺陷static StackOnly p3(move(p2));StackOnly p4 = new StackOnly(move(p2));
    }
    

  • 缺陷：当原对象被move后，可以把对象创建到堆上，也可以创建到栈上

设计一个类，不能被继承

• C++98方式
  C++98中构造函数私有化，派生类中调不到基类的构造函数。则无法继承。

  // C++98中构造函数私有化，派生类中调不到基类的构造函数。则无法继承
  class NonInherit{public:static NonInherit GetInstance(){return NonInherit();}private:NonInherit(){}};
  

• C++11方式：final关键字
  通过final关键字修饰类

  class A final
  {//...
  };
  

  设计一个类，只能创建一个对象（单例模式）

  设计模式

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

  单例模式

  概念

  **一个类只能创建一个对象，即单例模式，该模式可以保证系统中该类只有一个实例，并提供一个 访问它的全局访问点，该实例被所有程序模块共享。**比如在某个服务器程序中，该服务器的配置 信息存放在一个文件中，这些配置数据由一个单例对象统一读取，然后服务进程中的其他对象再 通过这个单例对象获取这些配置信息，这种方式简化了在复杂环境下的配置管理。

单例模式的实现

单例模式的实现有两种方式：饿汉模式，懒汉模式

• 饿汉模式

  如果这个单例对象在多线程高并发环境下频繁使用，性能要求较高，那么使用饿汉模式来避 免资源竞争，提高响应速度更好。

  • 概念：无论将来用不用，程序启动时就创建一个唯一的实例对象。

  • 思路
    将析构函数设为私有，此举防止了直接构造出对象
    在类域中声明 该类的静态对象。注意：这也是此后该类实例化的唯一一个成员
    防拷贝。这是为了防止 通过该类的静态对象拷贝构造出新的对象
    注意：静态变量是在进入main函数前就被创建的

  • 代码实现样例

    class Singleton
    {
    public:static Singleton* GetInstance(){return &m_instance;}
    private:// 构造函数私有Singleton() {};// C++98 防拷贝Singleton(Singleton const&);Singleton& operator=(Singleton const&);// or// C++11Singleton(Singleton const&) = delete;Singleton& operator=(Singleton const&) = delete;//这里的m_instance不是Singleton的成员，而是声明静态变量m_instance，并将其限制到类域中static Singleton m_instance;
    };
    Singleton Singleton::m_instance;

  • 缺点

    1. 多个饿汉模式的单例，某个对象初始化内容较多(读文件)，会导致程序慢
    2. 如果A和B两个饿汉对象初始化存在依赖关系，要求A先初始化，B再初始化，饿汉无法保证

• 懒汉模式

  懒汉模式是在第一次使用实例对象的时候创建对象

  • 概念：如果单例对象构造十分耗时或者占用很多资源，比如加载插件啊， 初始化网络连接啊，读取 文件啊等等，而有可能该对象程序运行时不会用到，那么也要在程序一开始就进行初始化， 就会导致程序启动时非常的缓慢。 所以这种情况使用懒汉模式（延迟加载）更好。

  • 思路：在饿汉模式的基础上，将声明的静态对象改为静态对象指针，静态对象指针定义为nullptr，并且在调用时当静态对象指针为nullptr时对其实例化，后续不再实例化

  • 代码实现样例

    //懒汉模式
    class InfoMgr
    {
    public://C++11前static InfoMgr& GetInstance(){// 第一次调用时创建单例对象// 线程安全的风险if (_pins == nullptr){_pins = new InfoMgr;}return *_pins;}void Print(){cout << _ip << endl;cout << _port << endl;cout << _buffSize << endl;}static void DelInstance(){delete _pins;_pins = nullptr;}private:InfoMgr(const InfoMgr&) = delete;InfoMgr& operator=(const InfoMgr&) = delete;InfoMgr(){cout << "InfoMgr()" << endl;}
    private:string _ip = "127.0.0.1";int _port = 80;size_t _buffSize = 1024 * 1024;//...static InfoMgr* _pins;
    };InfoMgr* InfoMgr::_pins = nullptr;
    

  • 缺点：有线程安全的风险