C++中实现一些特殊的类|设计模式

---

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

拷贝只会发生在两个场景中：拷贝构造以及赋值运算符重载。想要让一个类禁止拷贝，只需要该类不能调用拷贝构造和赋值运算符重载

1. c++98中 将拷贝构造与赋值运算符重载只声明不定义，不定义是因为该函数根本不会调用，定义了也没有意义，而且如果定义了就不会防止成员函数内部拷贝了。并且将访问权限设为私有。设置为私有：如果只声明没有设置为private,用户自己在类外定义了，就不能禁止拷贝了
2. c++11中扩展delete的用法，delete除了释放new申请的资源外，如果默认成员函数后面=delete，表示让编译器删除掉该默认成员函数

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



class copyBan
{
    //...
    copyBan(const copyBan&) = delete;
    copyBan& operator=(const copyBan&) = delete;
    //...
};

2.设计一个类，在堆上创建

实现方式:

1.将析构函数设置为私有

编译器在为类对象分配栈空间时，会先检查类的析构函数的访问性，其实不光是析构函数，只要是非静态的函数，编译器都会进行检查。如果类的析构函数是私有的，则编译器不会在栈空间上为类对象分配内存

2.将构造函数设置为私有,拷贝构造声明称私有，防止别人调用拷贝在栈上生成对象，提供一个静态的成员函数，在该静态成员函数中完成堆对象的创建

//1.析构私有
class  A  
{  
public :  
    A(){}  
    void  destory(){ delete   this ;}  
private :  
    ~A(){}  
}; 

//2.构造私有
class A
{
    public:
     static getObj()
       {
            A* p = new A();
            return p;
       }
        
}  
    private:
        A(){}
    public:
        ~A(){}
};

3.设计一个类，在栈上创建

1.将构造函数私有化，设计静态方法创建对象返回

class StackOnly
{
public:
 static StackOnly CreateObj()
 {
 return StackOnly();
 }
    
   
 void* operator new(size_t size) = delete;
 void operator delete(void* p) = delete;
private:
 StackOnly()  
 :_a(0)
 {}
private:
 int _a;
};

4.设计一个类，不能被继承

1. c++98中将构造函数设置为私有，派生类中调不到基类的构造函数，则无法继承
2. c++11使用final关键字，final修饰类，表示该类不能被继承

c++98:

class nonInherit
{
    public:
    

    private:
        nonInherit()
        {}
};


c++11
class A final
{
};

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

设计模式：

设计模式是一套被反复使用，代码设计经验的总结。设计设计模式，为了代码可重用性，让代码更容易被理解，保证代码的可靠性。设计模式使代码编写真正工程化

单例模式:

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

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

饿汉模式：不管将来是否使用，程序启动时就创建一个唯一的实例对象

class singleTon
{
    public:
        static singleTon * getInstance()
        {
            return _ins;
        }

        void add(const string& str)
        {
            _v.push_back(str);
            ++_n;
        }

        void Print()
        {
          for(auto& e:_v)
          {
            cout<<e<<endl;
          }   
        }
    private:
        singleTon()
        {
        }

    private:
        int _n = 0;
        vector<int> _v; //想让vector全局只有一份
        //限制在类外随意创建对象
        static singleTon * _ins;
}

static singleTon:: singleTon * _int = new singleTon; 



int main()
{
    singleTon s1; 


    return 0;
}

懒汉模式：如果单例对象构造十分耗时或者消耗很多资源，比如加载插件，初始化网络连接，读取文件等，而且有可能该对象程序运行时不会用到，那么程序如果一开始就初始化，导致程序启动十分缓慢，这种情况使用懒汉模式（延迟加载）更优