特殊类设计

不可被拷贝的类

拷贝只会放生在两个场景中：拷贝构造函数以及赋值运算符重载，因此 想要让一个类禁止拷贝，

只需让该类不能调用拷贝构造函数以及赋值运算符重载即可 。

C++98

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

class CopyBan

{

    // ...

   

private :

    CopyBan ( const CopyBan & );

    CopyBan & operator = ( const CopyBan & );

    //...

};

原因：

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

能禁止拷贝了

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

反而还简单，而且如果定义了就不会防止成员函数内部拷贝了。

C++11

C++11扩展delete的用法，delete除了释放new申请的资源外，如果在默认成员函数后跟上

=delete，表示让编译器删除掉该默认成员函数。

class CopyBan

{

    // ...

    CopyBan ( const CopyBan & ) = delete ;

    CopyBan & operator = ( const CopyBan & ) = delete ;

    //...

};

 只能在堆上创建的类

实现方式：

1. 将类的构造函数私有，拷贝构造声明成私有。防止别人调用拷贝在栈上生成对象。

2. 提供一个静态的成员函数，在该静态成员函数中完成堆对象的创建

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 ;

};

只能在栈上创建对象的类

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

class StackOnly

{

public :

        static StackOnly CreateObj ()

        {

        return StackOnly ();

        }

   

    // 禁掉 operator new 可以把下面用 new 调用拷贝构造申请对象给禁掉

        void* operator new ( size_t size ) = delete ;

        void operator delete ( void* p ) = delete ;

private :

        StackOnly ()  

        : _a ( 0 )

        {}

private :

        int _a ;

};

不可被继承的类

C++98

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

class NonInherit

{

public :

        static NonInherit GetInstance ()

        {

        return NonInherit ();

        }

private :

        NonInherit ()

        {}

};

C++11 方法

final关键字，final修饰类，表示该类不能被继承。

class A   final

{

    // ....

};

只能创建一个对象的类（单例）

单例模式：

一个类只能创建一个对象，即单例模式，该模式可以保证系统中该类只有一个实例，并提供一个

访问它的全局访问点，该实例被所有程序模块共享 。比如在某个服务器程序中，该服务器的配置

信息存放在一个文件中，这些配置数据由一个单例对象统一读取，然后服务进程中的其他对象再

通过这个单例对象获取这些配置信息，这种方式简化了在复杂环境下的配置管理。

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

饿汉模式

就是说不管你将来用不用，程序启动时就创建一个唯一的实例对象。

// 饿汉模式

// 优点：简单

// 缺点：可能会导致进程启动慢，且如果有多个单例类对象实例启动顺序不确定。

  class Singleton

{

  public :

      static Singleton * GetInstance ()

    {

          return & m_instance ;

    }

  private :

    // 构造函数私有

    Singleton (){};

   

    // C++98 防拷贝

    Singleton ( Singleton const & );

    Singleton & operator = ( Singleton const & );

     

    // or

     

    // C++11

    Singleton ( Singleton const & ) = delete ;

    Singleton & operator = ( Singleton const & ) = delete ;

    static Singleton m_instance ;

};

  Singleton Singleton::m_instance ;   // 在程序入口之前就完成单例对象的初始化

如果这个单例对象在多线程高并发环境下频繁使用，性能要求较高，那么显然使用饿汉模式来避

免资源竞争，提高响应速度更好。

懒汉模式

如果单例对象构造十分耗时或者占用很多资源，比如加载插件啊， 初始化网络连接啊，读取

文件啊等等，而有可能该对象程序运行时不会用到，那么也要在程序一开始就进行初始化，

就会导致程序启动时非常的缓慢。 所以这种情况使用懒汉模式（延迟加载）更好。

// 懒汉

// 优点：第一次使用实例对象时，创建对象。进程启动无负载。多个单例实例启动顺序自由控

制。

// 缺点：复杂

#include <iostream>

#include <mutex>

#include <thread>

using namespace std ;

class Singleton

{

public :

        static Singleton * GetInstance () {

// 注意这里一定要使用 Double-Check 的方式加锁，才能保证效率和线程安全

                if ( nullptr == m_pInstance ) {

                         m_mtx . lock ();

                if ( nullptr == m_pInstance ) {

        m_pInstance = new Singleton ();

        }

        m_mtx . unlock ();

        }

        return m_pInstance ;

}

// 实现一个内嵌垃圾回收类    

class CGarbo {

public :

        ~CGarbo (){

                if ( Singleton::m_pInstance )

                        delete Singleton::m_pInstance ;

        }

};

// 定义一个静态成员变量，程序结束时，系统会自动调用它的析构函数从而释放单例对象

        static CGarbo Garbo ;

private :

// 构造函数私有

        Singleton (){};

// 防拷贝

        Singleton ( Singleton const & );

        Singleton & operator = ( Singleton const & );

        static Singleton * m_pInstance ; // 单例对象指针

        static mutex m_mtx ;   // 互斥锁

};

Singleton * Singleton::m_pInstance = nullptr ;

Singleton::CGarbo Garbo ;

mutex Singleton::m_mtx ;

int main ()

{

        thread t1 ([]{ cout << & Singleton::GetInstance () << endl ; });

        thread t2 ([]{ cout << & Singleton::GetInstance () << endl ; });

        t1 . join ();

        t2 . join ();

        cout << & Singleton::GetInstance () << endl ;

        cout << & Singleton::GetInstance () << endl ;

        return 0 ;

}