C++ 特殊类的设计(单例模式)
1.请设计一个类，只能在堆上创建对象
实现方法：
- 将类的构造私有，拷贝构造声明成私有。防止别人调用拷贝在栈上生成对象。
- 提供一个静态的成员函数，在该静态成员函数中完成堆对象的创建
class HeapOnly
{
public:
//在堆上创建对象
static HeapOnly* HeapCreate()
{
return new HeapOnly;
}
private:
//构造函数私有
HeapOnly()
{}
//防拷贝
HeapOnly(const HeapOnly&) = delete;
};
构造函数私有：若不将构造函数私有，调用构造函数也可以在栈上创建对象
防拷贝：是因为拷贝是在栈上进行
2.请设计一个类，只能在栈上创建对象
实现方法：
方法一：同上将构造函数私有化，然后设计静态方法创建对象返回即可。
class StackOnly
{
public:
static StackOnly CreateObj()
{
return StackOnly();
}
private:
//构造函数私有
StackOnly()
{}
};
方法二：屏蔽new。 因为new在底层调用void* operator new(size_t size)函数，只需将该函数屏蔽掉即可。new屏蔽掉，delete也要屏蔽掉。
class StackOnly
{
public:
StackOnly()
{}
private:
void* operator new(size_t size) = delete;
void operator delete(void *p) = delete;
};
3.设计一个类，不能被拷贝
拷贝只会发生在两个场景中：拷贝构造函数以及赋值运算符重载，因此想要让一个类禁止拷贝，只需让该类不能调用拷贝构造函数以及赋值运算符重载即可。
- c++98
将拷贝构造函数与赋值运算符重载只声明不定义，并且将其访问权限设置为私有即可。
class CopyBan
{
// ...
private:
CopyBan(const CopyBan&);
CopyBan& operator=(const CopyBan&);
//...
};
原因：
- 设置成私有：如果只声明没有设置成private，用户自己如果在类外定义了，就可以不能禁止拷贝了
- 只声明不定义：不定义是因为该函数根本不会调用，定义了其实也没有什么意义，不写反而还简单，而且如果定义了就不会防止成员函数内部拷贝了。
- C++11
C++11扩展delete的用法，delete除了释放new申请的资源外，如果在默认成员函数后跟上=delete，表示让编译器删除掉该默认成员函数。
class CopyBan
{
// ...
CopyBan(const CopyBan&)=delete;
CopyBan& operator=(const CopyBan&)=delete;
//...
};
4.请设计一个类，不能被继承
- c++98
在c++98中构造函数私有化，派生类继承基类，会调用基类的构造函数，若基类的构造函数无法调用，就无法继承。
class NonIn
{
public:
static NonIn CreateObj()
{
return NonIn();
}
private:
NonIn()
{}
};
示例：
- C++11 final关键字，final修饰类，表示该类不能被继承。
class NonIn final
{
public:
NonIn()
{
cout << "NonIn" << endl;
}
};
示例：
5.设计一个类，只能创建一个对象(单例模式)
设计模式：
设计模式（Design Pattern）是一套被反复使用、多数人知晓的、经过分类的、代码设计经验的总结。
使用设计模式的目的：为了代码可重用性、让代码更容易被他人理解、保证代码可靠性。
单例模式：
一个类只能创建一个对象，即单例模式，该模式可以保证系统中该类只有一个实例，并提供一个访问它的全局访问点，该实例被所有程序模块共享。
单例模式有两种实现方式：
1.饿汉模式：就是说不管你将来用不用，程序启动时就创建一个唯一的实例对象。
实现方法：
- 构造函数私有，因为只能创建一个实例
- 公有的获取对象方法，通过static静态成员函数，获取已经创建好的对象的地址
- 防拷贝
- 创建的唯一一个对象是static类型，一方面是静态变量在启动主函数之前就已经创建好；另一方面，如果唯一对象是普通成员，不能在类中构造自己，因为这样就不能知道类的大小了，类中包含自己，就构成无限循环，若是static类型就可以，因为static放在静态区中，不属于类的大小。
具体实现
class SingleIeton
{
public:
//公有的获取方法
static SingleIeton* getObj()
{
return &sigle;
}
private:
//构造函数私有化
SingleIeton()
{}
//防拷贝
SingleIeton(const SingleIeton&) = delete;
SingleIeton& operator=(const SingleIeton&) = delete;
static SingleIeton sigle;
};
SingleIeton SingleIeton::sigle;
饿汉模式优缺点：
优点：
- 线程安全
- 在类加载的同时已经创建好一个静态对象，调用时反应速度快
缺点：
- 可能会导致进程启动慢，且如果有多个单例类对象实例启动顺序不确定。
2.懒汉模式
如果单例对象构造十分耗时或者占用很多资源，比如加载插件啊， 初始化网络连接啊，读取文件啊等等，而有可能该对象程序运行时不会用到，那么也要在程序一开始就进行初始化，就会导致程序启动时非常的缓慢。 所以这种情况使用懒汉模式（延迟加载） 更好。
实现方法：
- 构造函数私有
- 防拷贝
- 公有的方法获取对象。在类中设置一个指针，调用方法获取对象时，若指针为空，说明之前没有创建过对象，则创建对象；若指针不为空，则直接返回已创建的对象地址。类中的指针是static类型，static变量在程序运行之前就会初始化好；若不是static成员变量，成员变量的初始化是在构造函数的初始化列表中，而判断有没有创建对象时，成员变量指针还没有初始化，还是一堆乱码，所以不能使用成员变量指针。
具体实现：
class SingleIeton
{
public:
static SingleIeton* getObj()
{
if (single == nullptr)
{
single = new SingleIeton;
}
return single;
}
private:
//构造函数私有化
SingleIeton()
{}
//防拷贝
SingleIeton(const SingleIeton&) = delete;
SingleIeton& operator=(const SingleIeton&) = delete;
static SingleIeton* single;
};
SingleIeton* SingleIeton::single = nullptr;
上面代码存在线程安全问题，若多个线程同时进入if (single == nullptr)语句中，就会创建多个对象，而single只能保存最后一次创建的对象地址，前面创建的对象都丢失了，所以判断指针是否为空之前需要加锁保护。
static SingleIeton* getObj()
{
_mutex.lock();
if (single == nullptr)
{
single = new SingleIeton;
}
_mutex.unlock();
return single;
}
加锁的开销是比较大的，这样每次获取对象时都需要进行加锁，开销就更大了。
在这里我们使用双重判断，若对象已经创建了，就直接返回对象的地址；若没有创建(single==nullptr)，则再去加锁，创建对象。
class SingleIeton
{
public:
static SingleIeton* getObj()
{
if (single == nullptr)
{
_mutex.lock();
if (single == nullptr)
{
single = new SingleIeton;
}
_mutex.unlock();
}
return single;
}
private:
//构造函数私有化
SingleIeton()
{}
//防拷贝
SingleIeton(const SingleIeton&) = delete;
SingleIeton& operator=(const SingleIeton&) = delete;
static SingleIeton* single;
static mutex _mutex;
};
SingleIeton* SingleIeton::single = nullptr;
mutex SingleIeton::_mutex;