目录
前言
本篇文章我们重点要讲解的内容为单例模式，单例模式有什么特点？有什么好处？下面就让我们一起进入学习吧！！
一、设计一个类，不能被拷贝
拷贝只会放生在两个场景中：拷贝构造函数以及赋值运算符重载，因此想要让一个类禁止拷贝，只需让该类不能调用拷贝构造函数以及赋值运算符重载即可。
C++ 98 的做法是将拷贝构造函数与赋值运算符重载只声明不定义，并且将其访问权限设置为私有即可。
class CopyBan
{
// ...
private:
CopyBan(const CopyBan&);
CopyBan& operator=(const CopyBan&);
//...
};
原因：
1.设置成私有：如果只声明没有设置成 private，用户自己如果在类外定义了，就可以不能禁止拷贝了。
2.只声明不定义：不定义是因为该函数根本不会调用，定义了其实也没有什么意义，不写反而还简单，而且如果定义了就不会防止成员函数内部拷贝了。
C++11 的做法是C++11 扩展了 delete 的用法，delete 除了释放 new 申请的资源外，如果在默认成员函数后跟上 = delete，表示让编译器删除掉该默认成员函数。
class CopyBan
{
// ...
CopyBan(const CopyBan&) = delete;
CopyBan& operator=(const CopyBan&) = delete;
//...
};
二、设计一个只能在堆上创建对象的类
实现方式：
-
思路一：将类的构造函数私有和拷贝构造声明成私有，防止别人调用拷贝在栈上生成对象。提供一个静态的成员函数，在该静态成员函数中完成堆对象的创建。
-
思路二：将类的析构函数私有，提供一个释放资源的接口即可。因为对象出了作用域，会调用对象的析构函数来完成资源的释放，而在栈区或者静态区上创建的对象无法调用析构函数，但是在堆上创建的对象提供了释放资源的接口来完成资源的释放。
思路一代码：
class HeapOnly
{
public:
static HeapOnly* CreateObject()
{
return new HeapOnly;
}
HeapOnly(const HeapOnly& hp) = delete;
HeapOnly operator=(const HeapOnly& hp) = delete;
private:
HeapOnly()
{}
int _x = 0;
};
int main()
{
HeapOnly* hp = HeapOnly::CreateObject();
delete hp;
/*HeapOnly a1;
static HeapOnly a2;
HeapOnly copy(*hp);*/
return 0;
}
思路二代码：
class HeapOnly
{
public:
HeapOnly()
{}
static void Delete1(HeapOnly* p)
{
delete p;
}
void Delete2()
{
delete this;
}
HeapOnly(const HeapOnly& hp) = delete;
HeapOnly operator=(const HeapOnly& hp) = delete;
private:
~HeapOnly()
{}
int _x = 0;
};
int main()
{
HeapOnly* p = new HeapOnly;
HeapOnly::Delete1(p); // 静态成员函数
HeapOnly* s = new HeapOnly;
s->Delete2(); // 普通成员函数
//HeapOnly copy(*s); //
//HeapOnly s;
return 0;
}
三、设计一个只能在栈上创建对象的类
思路：与上述方法相同，我们将构造函数私有化，提供一个静态成员函数来返回匿名对象，但其实我们返回的不是匿名对象而是匿名对象的临时拷贝变量，因此我们需要提供拷贝构造，提供了拷贝构造那么就不能限制对象在栈区/静态区上进行拷贝构造了，不能在堆上创建对象我们可以通过删除operator new 函数来实现。
class StackOnly
{
public:
static StackOnly CreateObject()
{
return StackOnly();
}
// // 不能防拷贝
// StackOnly(const StackOnly& hp) = delete;
// StackOnly& operator=(const StackOnly& hp) = delete;
// 限制在堆上创建对象
void* operator new(size_t n) = delete;
private:
StackOnly()
{}
int _x = 0;
};
int main()
{
StackOnly s = StackOnly::CreateObject();
static StackOnly copy(s);
// StackOnly ps* = new StackOnly;
//static StackOnly ps = new StackOnly;
return 0;
}
四、设计一个类，不能被继承
C++98 的做法是将构造函数私有化，派生类中调不到基类的构造函数，则无法继承。
class NonInherit
{
public:
static NonInherit GetInstance()
{
return NonInherit();
}
private:
NonInherit()
{}
};
而 C++ 11 的做法是 final 关键字修饰类，表示该类不能被继承。
class A final
{
// ....
};
五、设计一个类，只能创建一个对象(单例模式)
设计模式：设计模式（Design Pattern）是一套被反复使用、多数人知晓的、经过分类的、代码设计经验的总结。为什么会产生设计模式这样的东西呢？就像人类历史发展会产生兵法。最开始部落之间打仗时都是人拼人的对砍。后来春秋战国时期，七国之间经常打仗，就发现打仗也是有套路的，后来孙子就总结出了《孙子兵法》。孙子兵法也是类似。
使用设计模式的目的：为了代码可重用性、让代码更容易被他人理解、保证代码可靠性。 设计模式使代码编写真正工程化；设计模式是软件工程的基石脉络，如同大厦的结构一样。
单例模式： 一个类只能创建一个对象，即单例模式，该模式可以保证系统中该类只有一个实例，并提供一个访问它的全局访问点，该实例被所有程序模块共享。比如在某个服务器程序中，该服务器的配置信息存放在一个文件中，这些配置数据由一个单例对象统一读取，然后服务进程中的其他对象再通过这个单例对象获取这些配置信息，这种方式简化了在复杂环境下的配置管理。
单例模式有两种实现模式，饿汉模式和懒汉模式。
5.1 饿汉模式
不管你将来用不用，程序启动时就创建一个唯一的实例对象，在进入main函数之前就已经实例化出一个对象。
整体思路：
- 把数据放进一个类里面，将这个类设计成单例类
- 把构造函数私有化，防止其随意创建对象，提供一个静态成员函数来返回单例对象
- 根据性质设计为饿汉或懒汉模式
饿汉模式的简化代码如下：
class Singleton
{
public:
static Singleton* GetInstance()
{
return _ins; // 每次返回的对象都是指向同一块空间的
}
// 插入数据需要保证线程安全问题
void Add(const string& str)
{
_mtx.lock();
_v.emplace_back(str);
_mtx.unlock();
}
void Print()
{
_mtx.lock();
for (auto& e : _v)
{
cout << e << endl;
}
cout << endl;
_mtx.unlock();
}
private:
Singleton() // 构造函数私有化，不能随意创建对象
{}
mutex _mtx;
vector<string> _v;
static Singleton* _ins;
};
Singleton* Singleton::_ins = new Singleton; // 在未进入main函数之前就已经实例化出来了
int main()
{
srand(time(0));
int n = 100;
thread t1([n]() {
for (size_t i = 0; i < n; i++)
{
Singleton::GetInstance()->Add("t1线程，第" + to_string(i) + "个" + to_string(rand()));
}
});
thread t2([n]() {
for (size_t i = 0; i < n; i++)
{
Singleton::GetInstance()->Add("t2线程，第" + to_string(i) + "个" + to_string(rand()));
}
});
t1.join();
t2.join();
Singleton::GetInstance()->Print();
return 0;
}
如果这个单例对象在多线程高并发环境下频繁使用，性能要求较高，那么显然使用饿汉模式来避免资源竞争，提高响应速度更好。
5.2 懒汉模式
如果单例对象构造十分耗时或者占用很多资源，比如加载插件啊， 初始化网络连接啊，读取文件啊等等，而有可能该对象程序运行时不会用到，那么也要在程序一开始就进行初始化，就会导致程序启动时非常的缓慢。 所以这种情况使用懒汉模式（延迟加载）更好。
懒汉模式的简化代码：
class Singleton
{
public:
static Singleton* GetInstance()
{
// 这里的判断是为了提高效率，假设对象已经创建出来了，那么我们就直接返回原来的对象即可
if (_ins == nullptr)
{
_imtx.lock();
// 这里的判断是为了保证线程安全，假设没有这个条件判断，当t1获得锁然后new一个对象后解锁，此时t1时间片到了，t2获得了锁，如果此时不加判断的话那么就会覆盖掉t1 new的对象
if (_ins == nullptr)
{
_ins = new Singleton;
}
_imtx.unlock();
}
return _ins;
}
void Add(const string& str)
{
_mtx.lock();
_v.emplace_back(str);
_mtx.unlock();
}
void Print()
{
_mtx.lock();
for (auto& e : _v)
{
cout << e << endl;
}
cout << endl;
_mtx.unlock();
}
static void DelInstance()
{
_imtx.lock();
if (_ins)
{
delete _ins;
_ins = nullptr;
}
_imtx.unlock();
}
// 单例对象回收 —— Singleton析构之前先析构成员变量GC的资源，GC析构又会调用DelInstance隐式回收单例对象
class GC
{
public:
~GC()
{
DelInstance();
}
};
private:
Singleton()
{}
mutex _mtx;
vector<string> _v;
static Singleton* _ins;
static mutex _imtx;
static GC _gc;
};
mutex Singleton::_imtx; // 非对象成员函数中需要添加同一把锁来保证线程安全
Singleton* Singleton::_ins = nullptr;
Singleton::GC Singleton::_gc;
int main()
{
srand(time(0));
int n = 100;
thread t1([n]() {
for (size_t i = 0; i < n; i++)
{
Singleton::GetInstance()->Add("t1线程，第" + to_string(i) + "个" + to_string(rand()));
}
});
thread t2([n]() {
for (size_t i = 0; i < n; i++)
{
Singleton::GetInstance()->Add("t2线程，第" + to_string(i) + "个" + to_string(rand()));
}
});
t1.join();
t2.join();
Singleton::GetInstance()->Print();
return 0;
}
5.3 饿汉模式VS懒汉模式
饿汉模式
- 优点：简单(相较懒汉模式)。
- 缺点：一个程序中有多个单例，并且有先后创建初始化顺序要求时，饿汉模式无法控制单例对象初始化的先后顺序；饿汉单例类对象初始化时任务多，会影响程序启动速度，并且当暂时用不到时却占用了资源！！
懒汉模式
- 优点： 多个单例实例启动顺序可以自由控制；当需要时才将资源加载到程序中来，不影响启动速度。
- 缺点：相对复杂，需要处理好线程安全问题。
单例对象的释放问题
一般情况下，单例对象是不需要释放的。因为整个程序运行期间都可能使用它，单例对象在进程正常结束后，也会释放资源。
有些特殊场景需要释放，比如：单例对象析构时，要进行一些持久化（往文件、数据库写数据等）操作。
466
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
