【C++】特殊类设计

特殊类设计

• 1.请设计一个类，不能被拷贝
• 2.请设计一个类，只能在堆上创建对象
• 3.请设计一个类，只能在栈上创建对象
• 4.请设计一个类，不能被继承
• 5.请��计一个类，只能创建一个对象(单例模式）

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

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

  • C++98

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

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

    为什么只声明不实现呢?

    因为自己不声明，库就会自动生成。因此只要自己写库就不会默认生成。

    为什么声明私有呢？

    如果声明为公有类外面可以实现别人就可以调用。

    • C++11

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

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

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

      1.首先我们必须要把构造函数私有

      如果不把构造私有分分钟钟就创建出三个对象，并且这三个对象在不同的位置栈、堆、静态区。

      class HeapOnly{};int main(){HeapOnly hp1;HeapOnly* php2 = new HeapOnly;static HeapOnly hp3;return 0;}

      因此把构造私有

      class HeapOnly{private:HeapOnly(){}};int main(){HeapOnly hp1;HeapOnly* php2 = new HeapOnly;static HeapOnly hp3;return 0;}

      这样类外面就调不了构造函数。外面就不随便创建对象！

      但是我还是需要创建需要的对象，因此类内部写一个创建对象的成员函数

      class HeapOnly{public:HeapOnly* CreateObj(){return new HeapOnly;}private:HeapOnly(){}};

      但是现在问题就来了，外面根本不能创建出对象，也就是说根本调不动CreteObj。

      那怎么办呢？

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

      静态成员函数没有this指针，可以不用对象去调用，使用类域::类的成员函数调用

      class HeapOnly{public:static HeapOnly* CreateObj(){return new HeapOnly;}private:HeapOnly(){}};int main(){//HeapOnly hp1;//HeapOnly* php2 = new HeapOnly;//static HeapOnly hp3;HeapOnly* php4=HeapOnly::CreateObj();return 0;}

      现在这个写法有没有什么地方没有考虑到？

      就是不只在堆上，还可以在别的地方创建出对象，假如是栈。

      int main(){HeapOnly* php4=HeapOnly::CreateObj();//hp5在栈上！HeapOnly hp5(*php4);//拷贝构造return 0;}

      3.防拷贝

      class HeapOnly{public:static HeapOnly* CreateObj(){return new HeapOnly;}private:HeapOnly(){}HeapOnly(const HeapOnly&) = delete;//这里赋值不用delete的，自己不写编译器默认生成的是浅拷贝，对象还是在堆上};

      这是一种完整方法，只能在堆上创建对象！

      还有一种方法析构函数私有+拷贝构造delete！

      class HeapOnly{public:HeapOnly(){}private:~HeapOnly(){}HeapOnly(const HeapOnly&) = delete;};int main(){HeapOnly hp1;return 0;}

      原因在于出了作用域会调用析构函数，这里不让调用编译就报错了。

      这种写法确实只可以在堆上申请对象！但是有没有什么问题？

      int main(){//HeapOnly hp1;HeapOnly* php2 = new HeapOnly;return 0;}

      最显然就是没有办法delete释放资源了，有没有什么办法解决一下？

      在类内部写一个Destory去释放资源。

      class HeapOnly{public:HeapOnly(){}void Destory(){delete this;//或者调用显示调用析构1：对象.析构  2：this->析构//this->~HeapOnly();}private:~HeapOnly(){}HeapOnly(const HeapOnly&) = delete;};int main(){HeapOnly* php2 = new HeapOnly;php2->Destory();return 0;}

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

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

      class StackOnly{public:static StackOnly CreateObj(){return StackOnly();}private:StackOnly(){}};int main(){StackOnly so1=StackOnly::CreateObj();return 0;}

      还有一种方法说的禁掉new和delete。

      因为new在底层调用void* operator new(size_t size)，只需要将该函数屏蔽掉即可。

      注意：也要防止定位new

      class StackOnly{public:static StackOnly CreateObj(){return StackOnly();}void* operator new(size_t size) = delete;void* operator delete(size_t size) = delete;//private:StackOnly(){}};int main(){StackOnly so1=StackOnly::CreateObj();StackOnly* pso = new StackOnly;//静态封不掉static StackOnly so2;return 0;}

      这种方法是有问题的，如果只禁用operator new、operator delete，只是不想在堆上创建对象，但是可以在除了堆上的其他地方创建对象，全局、局部、静态都可以！

      如果加上也可以，但是还是要把构造给封掉，不然静态还是可以的。

      方法1的代码还有没有其他问题？

      有的，方法1并没有把路封***！

      class StackOnly{public:static StackOnly CreateObj(){return StackOnly();}private:StackOnly(){}};int main(){StackOnly so1=StackOnly::CreateObj();static StackOnly so2 = StackOnly::CreateObj();return 0;}

      静态对象还可以实现

      那把拷贝构造封掉试一试

      class StackOnly{public:static StackOnly CreateObj(){return StackOnly();}StackOnly(const StackOnly&) = delete;private:StackOnly(){}};

      但是这里又不行了

      这里拷贝构造不行了，那我提供一个移动构造

      class StackOnly{public:static StackOnly CreateObj(){return StackOnly();}StackOnly(StackOnly&&){}StackOnly(const StackOnly&) = delete;private:StackOnly(){}};

      但这里又行了

      这里想说的是这个类封不***！静态的确实没有很好的办法解决。

      如果真的把这里封***就一种办法，把拷贝构造封***，不让用的人这样使用。

      class StackOnly{public:static StackOnly CreateObj(){return StackOnly();}//StackOnly(StackOnly&&)//{}void Print() const{cout }};int main(){//不用这样使用//StackOnly so1=StackOnly::CreateObj();//static StackOnly so2 = StackOnly::CreateObj();//而是这样用//1.StackOnly::CreateObj().Print();//2.const StackOnly& so1= StackOnly::CreateObj();so1.Print();return 0;}public:static NonInherit GetInstance(){return NonInherit();}private:NonInherit(){}};    // ....};public:private:InfoSingleton(){}map//InfoSingleton s1;//InfoSingleton s2;//InfoSingleton s3;return 0;}public:static InfoSingleton& GetInstance(){}private:InfoSingleton(){}mappublic:static InfoSingleton& GetInstance(){}private:InfoSingleton(){}mappublic:static InfoSingleton& GetInstance(){//直接返回就行return _sins;}private:InfoSingleton(){}mapInfoSingleton::GetInstance();return 0;}public:static InfoSingleton& GetInstance(){return _sins;}void insert(string name, int salary){_info[name] = salary;}void Print(){for (auto& kv : _info){cout }map//1.InfoSingleton::GetInstance().insert("张三",10000);//2.InfoSingleton& infos1 = InfoSingleton::GetInstance();infos1.insert("李四", 15000);infos1.insert("王五", 30000);infos1.Print();return 0;}//1.InfoSingleton::GetInstance().insert("张三",10000);//2.InfoSingleton& infos1 = InfoSingleton::GetInstance();infos1.insert("李四", 15000);infos1.insert("王五", 30000);infos1.Print();//拷贝构造InfoSingleton copy = InfoSingleton::GetInstance();copy.insert("赵六", 20000);copy.Print();infos1.Print();return 0;}public:static InfoSingleton& GetInstance(){return _sins;}void insert(string name, int salary){_info[name] = salary;}void Print(){for (auto& kv : _info){cout }InfoSingleton(const InfoSingleton& info) = delete;InfoSingleton& operator=(const InfoSingleton& info) = delete;map//1.InfoSingleton::GetInstance().insert("张三",10000);//2.InfoSingleton& infos1 = InfoSingleton::GetInstance();infos1.insert("李四", 15000);infos1.insert("王五", 30000);infos1.Print();//拷贝构造//InfoSingleton copy = InfoSingleton::GetInstance();//copy.insert("赵六", 20000);//copy.Print();infos1.Print();return 0;}public://这里可以也可以返回指针static InfoSingleton& GetInstance(){//第一次获取单例对象的时候创建对象if (_psins == nullptr){_psins = new InfoSingleton;}return *_psins;}void insert(string name, int salary){_info[name] = salary;}void Print(){for (auto& kv : _info){cout }InfoSingleton(const InfoSingleton& info) = delete;InfoSingleton& operator=(const InfoSingleton& info) = delete;mappublic://这里可以也可以返回指针static InfoSingleton& GetInstance(){_smtx.lock();if (_psins == nullptr){_psins = new InfoSingleton;}_smtx.unlock();return *_psins;}void insert(string name, int salary){_info[name] = salary;}void Print(){for (auto& kv : _info){cout }InfoSingleton(const InfoSingleton& info) = delete;InfoSingleton& operator=(const InfoSingleton& info) = delete;map//第一次if，对象new出来之后，避免每次都加锁的检查，提高性能if (_psins == nullptr){_smtx.lock();//第二次if，保证线程安全且只能new一次if (_psins == nullptr){_psins = new InfoSingleton;}_smtx.unlock();}return *_psins;}if (_psins == nullptr){_smtx.lock();try{if (_psins == nullptr){_psins = new InfoSingleton;}}catch (...){_smtx.unlock();throw;}}return *_psins;}public:LockGuard(Lock& mtx):_mtx(mtx)//锁不能拷贝构造,1.传锁的地址过来  2.私有成员给个引用{_mtx.lock();}~LockGuard(){_mtx.unlock();}private:Lock& _mtx;//引用的成员变量，必须在初始化列表初始化};class InfoSingleton{public://这里可以也可以返回指针static InfoSingleton& GetInstance(){if (_psins == nullptr){LockGuard_psins = new InfoSingleton;}//_smtx.unlock();}return *_psins;}//。。。。};if (_psins == nullptr){std::lock_guard_psins = new InfoSingleton;}}return *_psins;}//保存数据到文件//...std::lock_guarddelete _psins;_psins = nullptr;}}public:static InfoSingleton& GetInstance(){if (_psins == nullptr){std::lock_guard_psins = new InfoSingleton;}}return *_psins;}static void DelInstance(){//保存数据到文件//...std::lock_guarddelete _psins;_psins = nullptr;}}class GC//内部类是外部类有元{public:~GC(){if (_psins){DelInstance();//所以这里可以直接调}}};//。。。private:static InfoSingleton* _psins;static mutex _smtx;static GC _gc;};InfoSingleton* InfoSingleton::_psins=nullptr;mutex InfoSingleton::_smtx;InfoSingleton::GC InfoSingleton::_gc;//定义一个GC类的对象,main函数结束之后会自动调用GC的析构函数public://静态函数中写个该类静态对象static InfoSingleton& GetInstance(){static InfoSingleton sinst;return sinst;}//。。。private:InfoSingleton(){cout