C++特殊类的设计

前言

一、设计一个类不能被拷贝

C++98方法

C++11方法

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

1、设计思路：

2、细节

3、代码

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

1、设计思路

2、细节

3、代码

四、设计一个类，只能在堆上创建对象（其他方法）

1、设计思路

2、细节

3、代码

五、设计模式——单例模式

1、设计模式：

2、单例模式：

3、饿汉模式

1、解决思路：

2、细节

3、代码

4、问题

4、懒汉模式

1、解决思路

2、细节

3、懒汉对象释放问题

4、代码

5、简单懒汉模式

结束语

附录（特殊类设计的代码）

二、只能在堆上创建对象

三、只能在栈上创建对象

四、只能在堆上创建对象（其他方法）

五、单例模式

饿汉模式

懒汉模式

简单懒汉

前言

本篇博客针对C++中特殊类设计做相关介绍，剖析设计原理，梳理设计思路

一、设计一个类不能被拷贝

拷贝只会发生在两个场景中：拷贝构造函数以及赋值运算符重载，因此想要让一个类禁止拷贝，只需让该类不能调用拷贝构造函数以及赋值运算符重载即可，有以下两种方法（这类问题在C++11系列博客中，新增关键字部分有讲解，这里只介绍，不做详细举例介绍）

C++98方法

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

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

2. 只声明不定义：不定义是因为该函数根本不会调用，定义了其实也没有什么意义，不写反而还简单，而且如果定义了就不会防止成员函数内部拷贝了。

C++11方法

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

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

1、设计思路：

1. 将类的构造函数私有,使得类外无法调用构造函数生成类的实例化对象

2. 提供一个静态的成员函数，可以通过类域直接访问，在该静态成员函数中完成堆对象的创建并且返回对象指针

3，拷贝构造，与赋值拷贝禁用，防止别人调用拷贝在栈上生成对象。

2、细节

1、静态方法创建对象，参数写成可变参数，自动推导匹配构造函数，只写一个

3、代码

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

1、设计思路

1、将构造函数私有化，

2、提供一个静态的成员函数，可以通过类域直接访问，在该静态成员函数中完成不再用new构造对象，而是直接创建对象。

2、细节

1、不能禁用拷贝构造，创建的对象是局部变量，需要传值返回。虽然编译器直接优化为构造，但是实在拷贝构造+构造的前提下进行的，所以不能没有拷贝构造。

2、但如果有拷贝构造的话，就有可能将拷贝得到的对象放在堆上，与需求不符合，所以采用杜绝new的这种方式，直接重载一个类的专属operator new（禁用）。

3、代码

四、设计一个类，只能在堆上创建对象（其他方法）

1、设计思路

1、将析构函数写为私有成员

2、提供可以释放this对象空间的成员函数

在静态区创建的对象是自动调用析构函数的，但他无法从类外面调用析构函数，所以无法将对象析构，最终导致不能在静态区创建对象；对于创建在堆上的对象，显示的调用释放成员函数，在成员函数内部通过delete，可以调用私有析构函数释放对象，即只有用new才能创建对象，并通过显示调用对象成员函数调用到析构函数才能释放空间。

2、细节

Q：如果忘记显示调用怎么办

结合智能指针，定制删除器，调用对象的成员函数（用于释放），自动释放空间。

3、代码

五、设计模式——单例模式

1、设计模式：

设计模式是指一套被反复使用、多数人知晓的、经过分类的、代码设计经验的总结。为什么会产生设计模式这样的东西呢？就像人类历史发展会产生兵法。最开始部落之间打仗时都是人拼人的对砍。后来春秋战国时期，七国之间经常打仗，就发现打仗也是有套路的，后来孙子就总结出了《孙子兵法》。孙子兵法也是类似。使用设计模式的目的：为了代码可重用性、让代码更容易被他人理解、保证代码可靠性。 设计模式使代码编写真正工程化；设计模式是软件工程的基石脉络，如同大厦的结构一样。

2、单例模式：

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

一般用法：想让一些数据，当前程序只有一份，那就可以把这些数据作为成员变量放到这个类里面，再把这个类设置成单例，这样数据就只有一份了，且随时可以访问与更改。

对于单例模式，不能创建新的对象，那么首要任务就是要将构造函数私有化，拷贝构造与赋值拷贝全部禁用。对于创建第一个对象又有着两种不同的实现方法：饿汉模式与懒汉模式

3、饿汉模式

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

1、解决思路：

（1）、创建一个类内的静态成员变量（对象），类内定义该对象，类外声明，它可以调用到私有的构造函数完成对象的创建。

（2）、提供获取对象指针的函数，写成静态，允许通过类域访问获得对象指针

（3）、防止拷贝构造出新的对象，禁用拷贝构造

2、细节

（1）、静态成员对象，不存在对象中，存在静态区，相当于全局的，只是定义在类中，受类域限制。

（2）、由于创建的对象是全局的，一开始进入main（）函数之前就会创建该对象。如下图证明，先进行对象的构建，在进入main（）函数执行命令。

3、代码

4、问题

（1）、如果单例对象数据较多，构造初始化成本高，那么会影响程序启动的速度。迟迟进入不了main（）函数

（2）、如果单例类有初始化启动依赖关系，饿汉无法控制，假设：A和B两个单例，建设现要求A初始化，B再初始化。饿汉无法控制

4、懒汉模式

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

1、解决思路

（1）、把饿汉中创建静态对象，改为静态的对象指针成员

（2）、在第一次调用获取对象指针的静态函数时，new创建对象并且返回对象指针。

（3）、提供获取对象指针的函数，允许通过类域访问获得，写成静态

2、细节

（1）、在第一次调用获取对象指针的静态函数时，new创建对象并且返回对象指针，即指针为空才用new创建对象

（2）、防止拷贝构造出新的对象，禁用拷贝构造

3、懒汉对象释放问题

本来就希望只要进程存在，对象就一直存在，代码一直可以跑，进程结束代码随之结束。所以一般不需要提前释放，但有的时候希望把数据写到日志记录或腾出空间，通过析构函数把数据写到日志，释放原来的对象，由于不能随意的释放单例空间，所以我们也要将析构函数写为私有，防止类外删除这个对象，但同时要提供可以释放空间的静态成员函数，能够通过类域显示调用，在类内调用析构函数。

注意：

有的时候难免存在忘记，忘记显示调用静态的释放函数。

设计一个GC类来解决，即内嵌垃圾回收类，在GC的析构中显示的调用静态的释放函数，构建一个静态的GC对象为单例对象的成员变量，出了全局作用域GC类对象会自动调用析构函数，那么就会自动显示的调用单例对象的释放空间函数，释放单例空间；

GC类的设计专门为释放单例对象做准备；一般将GC类写为单例类的内部类，定义其类的静态对象为单例类的静态成员变量。

4、代码

5、简单懒汉模式

实现核心：

将原来new出来的对象，定义为局部的静态对象，第一次调用函数时构造初始化，由于写在类的静态成员函数中，所以它可以调用到类内私有的析构函数。由于是静态局部对象，他的作用域为全局，即程序结束，会调用析构。大大化简了之前对于单例空间释放的操作。

结束语

本篇文章的内容就到此结束了，对于特殊类设计的介绍也来到尾声，希望大家能有所收获，能够应用自如，如果有什么内容不明白的，大家可以在评论去向我提问，我会一一回答，当然有什么错误或者有什么不足的地方，希望大家可以包容并指出。希望大家可以持续关注之后内容，最后向每一位读者送上真诚的小花。

附录（特殊类设计的代码）

二、只能在堆上创建对象

//只能建立在堆上的类
class HeapOnly
{
public://写成可变参数，自动推导匹配构造函数template<class...Args>static HeapOnly* CreateObj(Args&&...args){return new HeapOnly(args...);}//写成静态方法创建对象，可以通过类域直接访问，创建对象并且返回对象指针//防止拷贝构造在静态区创建对象HeapOnly(const HeapOnly& obj) = delete;HeapOnly& operator=(const HeapOnly& obj) = delete;private://构造私有化，堆上，栈上都创建不了对象，要开小门HeapOnly(){}HeapOnly(int x, int y):_x(x),_y(y){}int _x=0;int _y=0;vector<int> v;
};//int main()
//{
//	//HeapOnly ho1;
//	//HeapOnly* ho2 = new HeapOnly;
//
//	HeapOnly* ho3 = HeapOnly::CreateObj();
//	HeapOnly* ho4 = HeapOnly::CreateObj(1,1);
//
//	//禁用拷贝构造
//	//HeapOnly copy(*ho3);
//
//	return 0;
//}

三、只能在栈上创建对象

class StackOnly 
{
public://写成可变参数，自动推导匹配构造函数template<class...Args>static StackOnly CreateObj(Args&&...args){return StackOnly(args...);}//和上面逻辑一样，只是不再用new构造对象，而是直接创建对象//不能禁用拷贝构造，创建的对象是局部变量，传值返回//虽然编译器直接优化为构造，但是实在拷贝构造+构造的前提下进行的，//所以不能没有拷贝构造//如果有拷贝构造的话，就有可能将拷贝得到的对象放在堆上，与需求不符合，//所以采用杜绝new的这种方式//直接重载一个类的专属operator new//StackOnly(const StackOnly&) = delete;//StackOnly& operator=(const StackOnly& obj) = delete;//直接重载一个类的专属operator newvoid* operator new(size_t n) = delete;private://构造私有化，堆上，栈上都创建不了对象，要开小门StackOnly(){}StackOnly(int x, int y):_x(x), _y(y){}int _x = 0;int _y = 0;vector<int> v;
};//int main()
//{
//	StackOnly so1 = StackOnly::CreateObj();
//	StackOnly so2 = StackOnly::CreateObj(1,1);
//
//	//StackOnly* so3 = new StackOnly(so1);
//
//	return 0;
//}

四、只能在堆上创建对象（其他方法）

class HeapOnly2
{
public:HeapOnly2():_x(0), _y(0){}HeapOnly2(int x, int y):_x(x), _y(y){}void Destroy(){delete this;}private://将析构函数写为私有成员，在静态区创建的对象是自动调用析构函数的//但他无法从类外面调用析构函数//导致无法将对象析构，最终导致不能在静态区创建对象；//对于创建在堆上的对象，显示的调用destory释放函数，在成员函数内部通过delete，调用析构函数释放对象//即只有new出来的对象才能调用到析构~HeapOnly2(){cout << "~HeapOnly" << endl;}int _x = 0;int _y = 0;vector<int> v;
};//int main()
//{
//	//HeapOnly ho1;
//	HeapOnly2* ptr = new HeapOnly2;
//	//delete ptr;
//	ptr->Destroy();
//
//	//如果忘记显示调用怎么办
//	//结合智能指针，定制删除器，调用对象的成员函数destory，自动释放空间
//	shared_ptr<HeapOnly2> ptr1(new HeapOnly2, [](HeapOnly2* ptr) {ptr->Destroy(); });
//
//
//	//shared_ptr<HeapOnly2> ptr2(new HeapOnly2);//同样找不到析构，不能这么写
//
//	//shared_ptr<HeapOnly2> ptr(new HeapOnly2, [](HeapOnly2* ptr) {ptr->Destroy(); });
//
//	return 0;
//}

五、单例模式

饿汉模式

//1、饿汉模式
namespace hunger 
{//一开始就创建对象，再main（）之前就创建对象//创建一个类内的静态成员变量（对象）//类内定义，类外声明，它可以调用到私有的构造函数class Singleton{public://提供获取对象指针的函数，允许通过类域访问获得，写成静态static Singleton* GetobjPtr(){return &_single;}void Print(){cout << _x << endl;cout << _y << endl;for (auto& e : _vstr){cout << e << " ";}cout << endl;}void AddStr(const string& s){_vstr.push_back(s);}Singleton(const Singleton& s) = delete;Singleton& operator=(const Singleton& s) =delete;private:Singleton(int x=0,int y=0, const vector<string>& vstr = { "yyyyy","xxxx" }):_x(x),_y(y),_vstr(vstr){cout << "Singleton" << endl;}int _x;int _y;vector<string> _vstr;//创建一个类内的静态成员变量（对象），一开始再main（）之前就会创建//静态成员对象，不存在对象中，存在静态区，相当于全局的，定义在类中，受类域限制static Singleton _single;};Singleton Singleton:: _single(1, 1, { "zwb","yjy" });
}
//int main()
//{
//	/*hunger::Singleton *ptr= hunger::Singleton::GetobjPtr();
//	ptr->Print();
//	ptr->AddStr("wcl");
//	ptr->Print();*/
//
//	cout << "xxxxxxxxxxx" << endl;
//	hunger::Singleton::GetobjPtr()->Print();
//	hunger::Singleton::GetobjPtr()->AddStr("zwh");
//	hunger::Singleton::GetobjPtr()->Print();
//	return 0;
//}

懒汉模式

//2、懒汉模式(解决饿汉的问题)
namespace lazy
{//把创建静态对象，改为静态的对象指针成员//在第一次调用获取对象指针的静态函数时，new创建对象并且返回对象指针。//即指针为空才用new创建对象class Singleton{public://提供获取对象指针的函数，允许通过类域访问获得，写成静态static Singleton* GetobjPtr(){if (_single == nullptr){_single=new Singleton();}return _single;}void Print(){cout << _x << endl;cout << _y << endl;for (auto& e : _vstr){cout << e << " ";}cout << endl;}void AddStr(const string& s){_vstr.push_back(s);}//可以释放空间的静态成员函数static void Destroy(){delete _single;}Singleton(const Singleton& s) = delete;Singleton& operator=(const Singleton& s) = delete;private:Singleton(int x = 0, int y = 0, const vector<string>& vstr = { "zwb","yjy" }):_x(x), _y(y), _vstr(vstr){cout << "Singleton" << endl;}~Singleton(){//写入日志cout << "~Singleton" << endl;}int _x;int _y;vector<string> _vstr;static Singleton* _single;// 建静态成员对象改为建静态对象指针，在第一次获取对象指针时创建对象//设计一个GC类专门为释放单例做准备；class GC{public:~GC(){Destroy();}};static GC gc;//写为静态成员变量，生命周期作用域为整个静态区，说明最后才会程序最后才会调用它的析构，//即最后才会释放单例空间（写到日志）};//静态成员类外初始化Singleton::GC Singleton::gc;Singleton* Singleton::_single=nullptr;
}//int main()
//{
//
//	lazy::Singleton *ptr= lazy::Singleton::GetobjPtr();
//	ptr->Print();
//	ptr->AddStr("wcl");
//	ptr->Print();
//
//
//	//cout << "xxxxxxxx" << endl;
//	//lazy::Singleton::GetobjPtr()->Print();
//	//lazy::Singleton::GetobjPtr()->AddStr("zwh");
//	//lazy::Singleton::GetobjPtr()->Print();
//
//	//对象释放问题：
//	//本来就希望只要进程存在，对象就一直存在，代码一直可以跑，进程结束代码随之结束。
//	//一般不需要提前释放，但有的时候希望把数据写到日志记录或腾出空间，通过析构函数把数据写到日志，释放原来的对象
//	//由于不能随意的释放单例空间，所以我们也要将析构函数写为私有，防止类外删除这个对象
//	//但同时要提供可以释放空间的静态成员函数，能够通过类域显示调用，在类内调用析构函数
//
//	//lazy::Singleton::Destroy();
//	//有的时候难免存在忘记，忘记显示调用静态的释放函数，
//	//设计一个GC类来解决，在GC的析构中显示的调用静态的释放函数
//	//构建一个静态的GC对象，出了作用域会自动释放，那么就会自动的调用释放函数，释放单例空间；
//	//专门为释放单例做准备；
//	//注意：一般将GC类写为单例类的内部类，定义其类的静态对象为单例类的静态成员变量。
//
//
//	return 0;
//}

简单懒汉

//简单懒汉
namespace lazy
{class Singleton{public://提供获取对象指针的函数，允许通过类域访问获得，写成静态static Singleton* GetobjPtr(){// 局部的静态对象，第一次调用函数时构造初始化// C++11及之后这样写才可以// C++11之前无法保证这里的构造初始化是线程安全static Singleton _sinst;return &_sinst;}void Print(){cout << _x << endl;cout << _y << endl;for (auto& e : _vstr){cout << e << " ";}cout << endl;}void AddStr(const string& s){_vstr.push_back(s);}Singleton(const Singleton& s) = delete;Singleton& operator=(const Singleton& s) = delete;private:Singleton(int x = 0, int y = 0, const vector<string>& vstr = { "zwb","yjy" }):_x(x), _y(y), _vstr(vstr){cout << "Singleton" << endl;}~Singleton(){//写入日志cout << "~Singleton" << endl;}int _x;int _y;vector<string> _vstr;};
}