目录
1. 设计一个类,不能被拷贝
拷贝只会放生在两个场景中:拷贝构造函数以及赋值运算符重载,因此想要让一个类禁止拷贝, 只需让该类不能调用拷贝构造函数以及赋值运算符重载即可。
C++98的方式: 只声明不定义,并且将其访问权限设置为私有。
class CopyBan
{
// ...
private:
CopyBan(const CopyBan&);
CopyBan& operator=(const CopyBan&);
//...
};
因为:如果不声明,编译器会自动生成,内置类型浅拷贝,自定义类型调用其自己的拷贝构造 或 赋值重载;其次,不定义是为了防止即使类内可以调用这两个函数,也无法完成实质上的拷贝;最后,设为私有,防止即使用户在类外定义,也无法调用。
C++11的方式:扩展delete的用法,delete除了释放new申请的资源外,如果在默认成员函数后跟上 =delete,表示让编译器删除掉该默认成员函数。
class CopyBan
{
// ...
CopyBan(const CopyBan&)=delete;
CopyBan& operator=(const CopyBan&)=delete;
//...
};
2. 设计一个类,只能在堆上创建对象
实现方式: 先 将构造和拷贝构造只声明不定义,且为私有(C++98)或 =delete删除(C++11),然后,提供一个静态的成员函数,在该静态成员函数中完成堆对象的创建。
class HeapOnly
{
public:
static HeapOnly* CreateObject()
{
return new HeapOnly;
}
private:
HeapOnly() {}
HeapOnly(const HeapOnly&);
// or
HeapOnly() = delete;
HeapOnly(const HeapOnly&) = delete;
};
3. 设计一个类,只能在栈上创建对象
将构造函数私有化,让类外不能用new,然后设计静态方法创建对象返回; 类内删除operator new函数,让类内也不能new。
class StackOnly
{
public:
static StackOnly CreateObj()
{
return StackOnly();
}
// 禁掉operator new可以把下面用new 调用拷贝构造申请对象给禁掉
// StackOnly obj = StackOnly::CreateObj();
// StackOnly* ptr3 = new StackOnly(obj);
void* operator new(size_t size) = delete;
private:
StackOnly()
:_a(0)
{}
int _a;
};
4. 设计一个类,不能被继承
C++98的方式:构造函数私有化,派生类中调不到基类的构造函数,则无法继承,另外提供一个静态函数,保证可以创建对象。
class NonInherit
{
public:
static NonInherit GetInstance()
{
return NonInherit();
}
private:
NonInherit()
{}
};
C++11的方式:final修饰类,表示该类不能被继承。
class NonInherit final
{
// ....
};
5. 设计一个类,只能创建一个对象(单例模式)
首先是 设计模式:套被反复使用、多数人知晓的、经过分类的、代码设计经验的 总结,目的是为了 代码可重用性、让代码更容易被他人理解、保证代码可靠性。 设计模式使代码编写真正工具化,并且设计模式是软件工程的基石脉络,如同大厦的结构一样。
然后是具体的 单例模式:一个类只能创建一个对象,该模式可以保证系统中该类只有一个实例,并提供一个访问它的全局访问点,该实例被所有程序模块共享。比如在某个服务器程序中,该服务器的配置信息存放在一个文件中,这些配置数据由一个单例对象统一读取,然后服务进程中的其他对象再通过这个单例对象获取这些配置信息,这种方式简化了在复杂环境下的配置管理。
单例模式有两种实现模式:
饿汉模式: 就是说不管你将来用不用,程序启动时就创建一个唯一的实例对象。
// 优点:简单
// 缺点:可能会导致进程启动慢,且如果有多个单例类对象时实例启动顺序不确定。
class Singleton
{
public:
static Singleton* GetInstance()
{
return &m_instance;
}
private:
// 构造函数私有
Singleton() {};
// C++98 防拷贝
Singleton(Singleton const&);
Singleton& operator=(Singleton const&);
// or
// C++11
Singleton(Singleton const&) = delete;
Singleton& operator=(Singleton const&) = delete;
static Singleton m_instance;//单例对象,静态成员:类内声明,类外定义
};
Singleton Singleton::m_instance; // 在程序入口之前就完成单例对象的初始化
如果这个单例对象在多线程高并发环境下频繁使用,性能要求较高,那么显然使用饿汉模式来避 免资源竞争,提高响应速度更好。
懒汉模式:如果单例对象构造十分耗时或者占用很多资源,比如加载插件啊, 初始化网络连接啊,读取 文件啊等等,而有可能该对象程序运行时不会用到,那么也要在程序一开始就进行初始化, 就会导致程序启动时非常的缓慢。 所以这种情况使用懒汉模式(延迟加载)更好。
// 优点:第一次使用实例对象时,创建对象,进程启动无负载;多个单例实例启动顺序自由控制。
// 缺点:复杂
using namespace std;
#include <iostream>
#include <mutex>
#include <thread>
class Singleton
{
public:
static Singleton* GetInstance() {
// 注意这里一定要使用Double-Check的方式加锁,才能保证效率和线程安全
if (nullptr == m_pInstance) {
m_mtx.lock();
if (nullptr == m_pInstance) {
m_pInstance = new Singleton();
}
m_mtx.unlock();
}
return m_pInstance;
}
// 实现一个内嵌垃圾回收类
class CGarbo {
public:
~CGarbo() {
if (Singleton::m_pInstance)
delete Singleton::m_pInstance;
}
};
// 定义一个静态成员变量,程序结束时,系统会自动调用它的析构函数从而释放单例对象
static CGarbo Garbo;
private:
// 构造函数私有
Singleton() {};
// 防拷贝
Singleton(Singleton const&);
Singleton& operator=(Singleton const&);
static Singleton* m_pInstance; // 单例对象指针
static mutex m_mtx; //互斥锁
};
Singleton* Singleton::m_pInstance = nullptr;
Singleton::CGarbo Garbo;
mutex Singleton::m_mtx;
int main()
{
thread t1([] {cout << Singleton::GetInstance() << endl; });
thread t2([] {cout << Singleton::GetInstance() << endl; });
t1.join();
t2.join();
cout << Singleton::GetInstance() << endl;
cout << Singleton::GetInstance() << endl;
return 0;
}