特殊类设计
特殊类设计
- 请设计一个类，不能被拷贝
- 请设计一个类，只能在堆上创建对象
- 请设计一个类，只能在栈上创建对象
- 请设计一个类，不能被继承
- 请设计一个类，只能创建一个对象（单例模式）
-
- 饿汉模式
- 懒汉模式
- 饿汉模式和懒汉模式对比
- 其他版本的懒汉
- 单例对象的释放
请设计一个类，不能被拷贝
拷贝只会放生在两个场景中：拷贝构造函数以及赋值运算符重载，因此想要让一个类禁止拷贝，只需让该类不能调用拷贝构造函数以及赋值运算符重载即可。
- C++98
将拷贝构造函数与赋值运算符重载只声明不定义，并且将其访问权限设置为私有即可。
class CopyBan
{
public:
//....
private:
CopyBan(const CopyBan&);
CopyBan& operator=(const CopyBan&);
};
- 设置成私有：如果只声明没有设置成private，用户自己如果在类外定义了，就可以不能禁止拷贝了；
- 只声明不定义：不定义是因为该函数根本不会调用，定义了其实也没有什么意义，不写反而还简单，而且如果定义了就不会防止成员函数内部拷贝了。
- C++11
C++11扩展delete的用法，delete除了释放new申请的资源外，如果在默认成员函数后跟上=delete，表示让编译器删除掉该默认成员函数。
class CopyBan
{
public:
CopyBan(const CopyBan&) = delete;
CopyBan& operator=(const CopyBan&) = delete;
//....
};
请设计一个类，只能在堆上创建对象
实现方式：
- 将类的构造函数私有，拷贝构造声明成私有。防止别人调用拷贝在栈上生成对象；
- 提供一个静态的成员函数，在该静态成员函数中完成堆对象的创建。
class HeapOnly
{
public:
static HeapOnly* CreateObject()
{
return new HeapOnly;
}
private:
HeapOnly()
{}
//1.C++98
HeapOnly(const HeapOnly&);
//2.C++11
HeapOnly(const HeapOnly&) = delete;
};
- 向外部提供的CreateObj函数必须设置为静态成员函数，因为外部调用该接口就是为了获取对象的，而非静态成员函数必须通过对象才能调用，这就变成鸡生蛋蛋生鸡的问题了。
- C++98通过将拷贝构造函数声明为私有以达到防拷贝的目的，C++11可以在拷贝构造函数后面加上=delete，表示让编译器将拷贝构造函数删除，此时也能达到防拷贝的目的。
请设计一个类，只能在栈上创建对象
方法一
- 将构造函数设置为私有，防止外部直接调用构造函数在堆上创建对象。
- 向外部提供一个获取对象的static接口，该接口在栈上创建一个对象并返回。
class StackOnly
{
public:
static StackOnly CreateObject()
{
return StackOnly();
}
private:
StackOnly()
{}
};
但该方法有一个缺陷就是，无法防止外部调用拷贝构造函数创建对象。
int main()
{
StackOnly obj1 = StackOnly::CreateObject();
static StackOnly obj2(obj1);在静态区拷贝构造对象
StackOnly* ptr = new StackOnly(obj1);//在堆上拷贝构造对象
return 0;
}
但是我们不能将构造函数设置为私有，也不能用=delete的方式将拷贝构造函数删除，因为CreateObj函数当中创建的是局部对象，返回局部对象的过程中势必需要调用拷贝构造函数。
方法二
- 屏蔽operator new函数和operator delete函数。
class StackOnly
{
public:
StackOnly()
{}
private:
//1.C++98
void* operator()(size_t size);
void operator delete(void* p);
//2.C++11
void* operator()(size_t size) = delete;
void operator delete(void* p) = delete;
};
new和delete的原理：
- new在堆上申请空间实际分为两步，第一步是调用operator new函数申请空间，第二步是在申请的空间上执行构造函数，完成对象的初始化工作。
- delete在释放堆空间也分为两步，第一步是在该空间上执行析构函数，完成对象中资源的清理工作，第二步是调用operator delete函数释放对象的空间。
new和delete默认调用的是全局的operator new函数和operator delete函数，但如果一个类重载了专属的operator new函数和operator delete函数，那么new和delete就会调用这个专属的函数。所以只要把operator new函数和operator delete函数屏蔽掉，那么就无法再使用new在堆上创建对象了。
但该方法也有一个缺陷，就是无法防止外部在静态区创建对象。
static StackOnly obj; //在静态区创建对象
请设计一个类，不能被继承
- C++98方式
C++98中构造函数私有化，派生类中调不到基类的构造函数，则无法继承，因为子类的构造函数被调用时，必须调用父类的构造函数初始化父类的那一部分成员，但父类的私有成员在子类当中是不可见的，所以在创建子类对象时子类无法调用父类的构造函数对父类的成员进行初始化，因此该类被继承后子类无法创建出对象。
class NonInherit
{
public:
static NonInherit GetInstance()
{
return NonInherit();
}
private:
//将构造函数设置为私有
NonInherit()
{}
};
- C++11方式
final关键字，final修饰类，表示该类不能被继承；
class NonInherit final
{
//.....
};
请设计一个类，只能创建一个对象（单例模式）
什么是单例模式？
- 单例模式是一种设计模式（Design Pattern），设计模式就是一套被反复使用、多数人知晓的、经过分类编目的、代码设计经验的总结。使用设计模式的目的就是为了可重用代码、让代码更容易被他人理解、保证代码可靠性程序的重用性。
- 单例模式指的就是一个类只能创建一个对象，该模式可以保证系统中该类只有一个实例，并提供一个访问它的全局访问点，该实例被所有程序模块共享。
- 比如在某个服务器程序中，该服务器的配置信息存放在一个文件中，这些配置数据由一个单例对象同一读取，然后服务进程中的其他对象再通过这个单例对象获取这些配置信息，这种方式简化了在复杂环境下的配置管理。
单例模式有两种实现方式，分别是饿汉模式和懒汉模式：
饿汉模式
单例模式的饿汉实现方式如下：
- 将构造函数设置为私有，并将拷贝构造函数和赋值运算符重载函数设置为私有或删除，防止外部创建或拷贝对象。
- 提供一个指向单例对象的static指针，并在程序入口之前完成单例对象的初始化。
- 提供一个全局访问点获取单例对象。
class SingleTon
{
public:
//提供一个全局的访问点获取单例对象
static SingleTon* GetInstance()
{
return _inst;
}
private:
//构造函数私有
SingleTon()
{}
//防拷贝
SingleTon(const SingleTon&) = delete;
SingleTon& operator=(const SingleTon&) = delete;
//提供一个指向单例对象的static指针
static SingleTon* _inst;
};
//在程序入口之前完成单例对象的初始化
SingleTon* SingleTon::_inst = new SingleTon;
线程安全相关问题：
- 饿汉模式在程序运行主函数之前就完成了单例对象的创建，由于main函数之前是不存在多线程的，因此饿汉模式下单例对象的创建过程是线程安全的。
- 后续所有多线程要访问这个单例对象，都需要通过调用GetInstance函数来获取，这个获取过程是不需要加锁的，因为这是一个读操作。
- 当然，如果线程通过GetInstance获取到单例对象后，要用这个单例对象进行一些线程不安全的操作，那么这时就需要加锁了。
懒汉模式
单例模式的懒汉实现方式如下：
- 将构造函数设置为私有，并将拷贝构造函数和赋值运算符重载函数设置为私有或删除，防止外部创建或拷贝对象。
- 提供一个指向单例对象的static指针，并在程序入口之前先将其初始化为空。
- 提供一个全局访问点获取单例对象。
class SingleTon
{
public:
//提供一个全局的访问点获取单例对象
static SingleTon* GetInstance()
{
//双重检查
if(_inst == nullptr)
{
_mtx.lock();
if (_inst == nullptr)
{
_inst = new SingleTon;
}
_mtx.unlock();
}
return _inst;
}
private:
//构造函数私有
SingleTon()
{}
//防拷贝
SingleTon(const SingleTon&) = delete;
SingleTon& operator=(const SingleTon&) = delete;
//提供一个指向单例对象的static指针
static SingleTon* _inst;
//互斥锁
static mutex _mtx;
};
//在程序入口之前完成单例对象的初始化为空
SingleTon* SingleTon::_inst = nullptr;
//互斥锁初始化
mutex SingleTon::_mtx;
线程安全相关问题：
- 懒汉模式在程序运行之前没有进行单例对象的创建，而是等到某个线程需要使用这个单例对象时再进行创建，也就是GetInstance函数第一次被调用时创建单例对象。
- 因此在调用GetInstance函数获取单例对象时，需要先判断这个static指针是否为空，如果为空则说明这个单例对象还没有创建，此时需要先创建这个单例对象然后再将单例对象返回。
- GetInstance函数第一次调用时需要对static指针进行写入操作，这个过程不是线程安全的，因为多个线程可能同时调用GetInstance函数，如果不对这个过程进行保护，此时这多个线程就会各自创建出一个对象。
双检查加锁：
- 对GetInstance函数中创建单例对象的过程进行保护，本质就是需要引入互斥锁，最简单的加锁方式就是在进行if判断之前加锁，在整个if语句之后进行解锁。
- 但实际只有GetInstance函数第一次被调用，创建单例对象时需要使用互斥锁进行保护，而后续调用GetInstance函数获取单例对象只是一个读操作，是不需要使用互斥锁进行保护的。
- 如果简单的将加锁解锁操作放到if语句前后，那么在后续调用GetInstance函数获取已经创建好的单例对象时，就会进行大量无意义的加锁解锁操作，导致线程不断切入切出，进而影响程序运行效率。
- 对于这种只有第一次需要加锁保护的场景可以使用双检查加锁，双检查就是在当前加锁和解锁的外面再进行一次if判断，判断static指针是否为空。
- 这样一来，后续调用GetInstance函数获取已经创建好的单例对象时，外层新加的if判断就会起作用，这样就避免了后续无意义的加锁解锁操作。
饿汉模式和懒汉模式对比
- 饿汉模式的优点就是简单，但是它的缺点也比较明显。饿汉模式在程序运行主函数之前就会创建单例对象，如果单例类的构造函数中所做的工作比较多（初始化动作多，还会伴随这一些IO行为，如读取配置文件），就会导致程序迟迟无法进入主函数，在外部看来就好像是程序卡住了。
- 此外，如果有多个单例类需要创建单例对象，并且它们之间的初始化存在某种依赖关系，比如单例对象A的创建必须在单例对象B之后，此时饿汉模式也会存在问题，因为我们无法保证这多个单例对象中的哪个对象先创建。
- 而懒汉模式就能很好的解决上述饿汉模式的缺点，因为懒汉模式并不是一开始就完成单例对象的创建，因此不会导致程序迟迟无法进入主函数，并且懒汉模式中各个单例对象创建的顺序是由各个单例类中的GetInstance函数第一次被调用的顺序决定，因此是可控制的。
- 懒汉模式的缺点就是，在编码上比饿汉模式复杂，在创建单例对象时需要考虑线程安全的问题。
其他版本的懒汉
懒汉模式还有一种比较经典的实现方式：
- 将构造函数设置为私有，并将拷贝构造函数和赋值运算符重载函数设置为私有或删除，防止外部创建或拷贝对象。
- 提供一个全局访问点获取单例对象。
class SingleTon
{
public:
//提供一个全局的访问点获取单例对象
static SingleTon* GetInstance()
{
static SingleTon inst;
return &inst;
}
private:
//构造函数私有
SingleTon()
{}
//防拷贝
SingleTon(const SingleTon&) = delete;
SingleTon& operator=(const SingleTon&) = delete;
};
- 由于实际只有第一次调用GetInstance函数时才会定义这个静态的单例对象，这也就保证了全局只有这一个唯一实例。
- 并且这里单例对象的定义过程是线程安全的，因为现在的C++标准保证多线程初始化static变量不会发生数据竞争，可以视为原子操作。
- 该方法属于懒汉模式，因为局部静态变量不是在程序运行主函数之前初始化的，而是在第一次调用GetInstance函数时初始化的。
但是他也有以下缺点：
- 单例对象定义在静态区，因此太大的单例对象不适合使用这种方式。
- 单例对象创建在静态区后没办法主动释放。
单例对象的释放
单例对象创建后一般在整个程序运行期间都可能会使用，所以我们可以不考虑单例对象的释放，程序正常结束时会自动将资源归还给操作系统。
如果要考虑单例对象的释放，可以参考以下两种方式：
- 在单例类中编写一个DelInstance函数，在该函数中进行单例对象的释放动作，当不再需要该单例对象时就可以主动调用DelInstance释放单例对象。
static void DelInstance()
{
_mtx.lock();
if (_inst)
{
delete _inst;
_inst = nullptr;
}
_mtx.unlock();
}
- 在单例类中实现一个内部类，在内部类的析构函数中完成单例对象的释放。在单例类中定义一个静态的内部类对象，当该对象被消耗时就会调用其析构函数，这时便对单例对象进行了释放；
class SingleTon
{
public:
//提供一个全局的访问点获取单例对象
static SingleTon* GetInstance()
{
//双重检查
if(_inst == nullptr)
{
_mtx.lock();
if (_inst == nullptr)
{
_inst = new SingleTon;
}
_mtx.unlock();
}
return _inst;
}
class GC
{
public:
~GC()
{
if (_inst)
{
delete _inst;
_inst = nullptr;
}
}
};
static GC _gc;
private:
//构造函数私有
SingleTon()
{}
//防拷贝
SingleTon(const SingleTon&) = delete;
SingleTon& operator=(const SingleTon&) = delete;
//提供一个指向单例对象的static指针
static SingleTon* _inst;
//互斥锁
static mutex _mtx;
};
//在程序入口之前完成单例对象的初始化为空
SingleTon* SingleTon::_inst = nullptr;
//互斥锁初始化
mutex SingleTon::_mtx;
SingleTon::GC _gc;