目录
前言
本篇博客针对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 new
void* 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;
};
}
