文章目录
C++特殊类设计
1、设计一个类，不能被拷贝
拷贝只会放生在两个场景中：拷贝构造函数以及赋值运算符重载，因此想要让一个类禁止拷贝，只需让该类不能调用拷贝构造函数以及赋值运算符重载即可。
C++98中：讲拷贝构造和赋值重载设置为私有，并且只声明不定义。
原因：设置成私有是如果只声明没有设置成private，用户自己如果在类外定义了，就可以不能禁止拷贝了。只声明不定义，不定义是因为该函数根本不会调用，定义了其实也没有什么意义，不写反而还简单，而且如果定义了成员函数内部就可以拷贝了，所以不要定义。
class CopyBan { // ... private: CopyBan(const CopyBan&); CopyBan& operator=(const CopyBan&); //... };C++11中：默认成员函数使用delete关键字可以禁止编译器生成。
// 设计一个类，不能被拷贝 class CannotCopy { public: CannotCopy(){}; CannotCopy(const CannotCopy &cnp) = delete; CannotCopy &operator=(const CannotCopy &cnp) = delete; }; // 特殊类设计 int main() { CannotCopy cnp1; CannotCopy cnp2(cnp1);// 报错 CannotCopy cnp3 = cnp1;// 报错 CannotCopy cnp4; cnp4 = cnp1;// 报错 return 0; }
2、设计一个类，只能在堆上创建对象
实现方式：
- 将构造函数设置为私有，并且将拷贝构造的声明设置为私有，防止有人调用拷贝构造在栈上生成对象。
- 提供一个静态成员函数，在该静态成员函数完成在堆上创建对象。
class CreateHeap { public: static CreateHeap *Create(int x, int y) { return new CreateHeap(x, y); } void Debug() { cout << _x << " " << _y << endl; } private: CreateHeap(int x = 1, int y = 2) : _x(x), _y(y) {} CreateHeap(const CreateHeap& cnp) = delete; int _x; int _y; }; int main() { // 不能直接使用构造函数，不然该对象就是栈上的 // CreateHeap ch; CreateHeap *pcn = CreateHeap::Create(3, 7); pcn->Debug(); return 0; }
3、设计一个类，只能在栈上创建对象
方法一：和上面在堆上创建差不多，把静态成员返回的对象指针改成返回对象。
class CreateHeap { public: static CreateHeap Create(int x, int y) { return CreateHeap(x, y); } void Debug() { cout << _x << " " << _y << endl; } private: CreateHeap(int x = 1, int y = 2) : _x(x), _y(y) {} CreateHeap(const CreateHeap &cnp) = delete; int _x; int _y; }; int main() { CreateHeap pcn = CreateHeap::Create(3, 7); // CreateHeap* pcn1 = new CreateHeap(pcn);// 报错，拷贝构造没定义 pcn.Debug(); return 0; }方法二：重载operator new 和 operator delete，并设置为delete属性，也就是不让new对象。可以避免有人使用拷贝构造new出对象。
class CreateHeap { public: static CreateHeap Create(int x, int y) { return CreateHeap(x, y); } void Debug() { cout << _x << " " << _y << endl; } // 重载operator new 和 operator delete void *operator new(size_t size) = delete; void operator delete(void *ptr) = delete; private: CreateHeap(int x = 1, int y = 2) : _x(x), _y(y) {} // CreateHeap(const CreateHeap &cnp) = delete; int _x; int _y; }; int main() { CreateHeap pcn = CreateHeap::Create(3, 7); // CreateHeap *pcn1 = new CreateHeap(pcn);// 报错，new的属性是delete pcn.Debug(); return 0; }
4、设计一个类，不能被继承
方法一：将构造函数私有化，那么继承的类就使用不了基类的构造函数，这个子类就会报错。也就是C++98方式。
class Base { private: Base() {} }; class Drive : public Base { }; int main() { // Drive d; // 报错 return 0; }方法二：C++11新增final关键字，将基类设置为final类，子类就不能继承了。
class Base final { }; //class Derive:public Base{}; // 报错
5、设计一个类，只能创建一个对象（单例模式）
设计模式：
设计模式（Design Pattern）是一套被反复使用、多数人知晓的、经过分类的、代码设计经验的总结。为什么会产生设计模式这样的东西呢？就像人类历史发展会产生兵法。最开始部落之间打仗时都是人拼人的对砍。后来春秋战国时期，七国之间经常打仗，就发现打仗也是有套路的，后来孙子就总结出了《孙子兵法》。孙子兵法也是类似。使用设计模式的目的：为了代码可重用性、让代码更容易被他人理解、保证代码可靠性。 设计模式使代码编写真正工程化；设计模式是软件工程的基石脉络，如同大厦的结构一样。
单例模式：
一个类只能创建一个对象，即单例模式，该模式可以保证系统中该类只有一个实例，并提供一个访问它的全局访问点，该实例被所有程序模块共享。比如在某个服务器程序中，该服务器的配置信息存放在一个文件中，这些配置数据由一个单例对象统一读取，然后服务进程中的其他对象再通过这个单例对象获取这些配置信息，这种方式简化了在复杂环境下的配置管理。单例模式有两种实现模式：
饿汉模式：就是说不管你将来用不用，程序启动时就创建一个唯一的实例对象。class Singleton { public: static Singleton *GetInstance() { return &sl; } void Debug() { cout << "_x :" << _x << " _y:" << _y << " _p :" << _p << " *_p:" << *_p << endl; } private: int _x; int _y; int *_p; Singleton(int x = 1, int y = 2, int *p = nullptr) : _x(x), _y(y), _p(p) {} // 防止通过拷贝来创建新对象 Singleton(const Singleton &sl) = delete; Singleton &operator=(const Singleton &sl) = delete; static Singleton sl; }; Singleton Singleton::sl = {3, 4, new int(10)}; // 在程序入口之前就完成单例对象的初始化 int main() { Singleton *psl = Singleton::GetInstance(); psl->Debug(); Singleton *psl1 = Singleton::GetInstance(); psl1->Debug(); return 0; }懒汉模式：如果单例对象构造十分耗时或者占用很多资源，比如加载插件啊， 初始化网络连接啊，读取文件啊等等，而有可能该对象程序运行时不会用到，那么也要在程序一开始就进行初始化，就会导致程序启动时非常的缓慢。 所以这种情况使用懒汉模式（延迟加载）更好。
class Singleton { public: // 这里涉及到线程安全问题，需要加锁，后面学了线程再补充 static Singleton *GetInstance() { if (!_psl) // 如果_psl为空，就创建对象，否则（已经有对象了）不创建 _psl = new Singleton(3, 4, new int(10)); // _psl = new Singleton; return _psl; } void Debug() { cout << "_x :" << _x << " _y:" << _y << " _p :" << _p << endl; // cout << "_x :" << _x << " _y:" << _y << " _p :" << _p << " *_p:" << *_p << endl; } static void DelInstance() { if (_psl) { delete _psl; _psl = nullptr; } } private: int _x; int _y; int *_p; Singleton(int x = 1, int y = 2, int *p = nullptr) : _x(x), _y(y), _p(p) {} // 防止通过拷贝来创建新对象 Singleton(const Singleton &sl) = delete; Singleton &operator=(const Singleton &sl) = delete; ~Singleton() { cout << "把数据写入文件" << endl; delete _p; _p = nullptr; } static Singleton *_psl; // 内部类 class GC { public: ~GC() { Singleton::DelInstance(); } }; static GC gc; }; Singleton *Singleton::_psl = nullptr; // 初始化为nullptr，表明当前还没调用过 Singleton::GC Singleton::gc; int main() { Singleton *psl = Singleton::GetInstance(); psl->Debug(); Singleton *psl1 = Singleton::GetInstance(); psl1->Debug(); // psl->DelInstance(); cout << "=====================" << endl; return 0; }这里涉及到线程安全问题，需要加锁，后面学了线程再补充。
OKOK，C++特殊类设计就到这里，如果你对Linux和C++也感兴趣的话，可以看看我的主页哦。下面是我的github主页，里面记录了我的学习代码和leetcode的一些题的题解，有兴趣的可以看看。