꧁ 大家好,我是 兔7 ,一位努力学习C++的博主~ ꧂
☙ 如果文章知识点有错误的地方,请指正!和大家一起学习,一起进步❧
🚀 如有不懂,可以随时向我提问,我会全力讲解~💬
🔥 如果感觉博主的文章还不错的话,希望大家关注、点赞、收藏三连支持一下博主哦~!👀
🔥 你们的支持是我创作的动力!⛅
🧸 我相信现在的努力的艰辛,都是为以后的美好最好的见证!⭐
🧸 人的心态决定姿态!⭐
🚀 本文章CSDN首发!✍
目录
0. 前言
此博客为博主以后复习的资料,所以大家放心学习,总结的很全面,每段代码都给大家发了出来,大家如果有疑问可以尝试去调试。
大家一定要认真看图,图里的文字都是精华,好多的细节都在图中展示、写出来了,所以大家一定要仔细哦~
感谢大家对我的支持,感谢大家的喜欢, 兔7 祝大家在学习的路上一路顺利,生活的路上顺心顺意~!
1. 设计一个类,只能在堆上创建对象
实现方式:
- 将类的构造函数私有,拷贝构造声明成私有。防止别人调用拷贝在栈上生成对象。
- 提供一个静态的成员函数,在该静态成员函数中完成堆对象的创建。
class HeapOnly
{
public:
static HeapOnly* CreateObj()
{
return new HeapOnly;
}
HeapOnly(const HeapOnly&) = delete;
private:
HeapOnly()
{}
//HeapOnly(const HeapOnly&);
};
//HeapOnly::HeapOnly(const HeapOnly&)
//{}
int main()
{
//HeapOnly ho;
//HeapOnly* p = new HeapOnly;
HeapOnly* p = HeapOnly::CreateObj();
HeapOnly copy(*p);
return 0;
}
我们可以看到,我们这里将构造函数放到 private 里面,那么类外面就不能调用构造函数,也就不能创建对象了,所以我们要想办法在类里设置一个接口可以调用构造函数,但是这个接口必须要是 static 的,因为如果不是静态的,那么类外必须要用实例化好的对象去调用,但是我们又不能在类外创建对象,我们调用这个接口就是为了创建对象。
所以这里就有了一个问题,那么这时就要设置为静态的,这样外面直接就可以调用这个接口在堆上创建对象了。
但是我们可以看到,虽然我们将构造函数设为私有不可以直接创建对象了,但是还是可以通过拷贝构造函数去在栈上创建对象!
所以还是老套路嘛,直接将拷贝构造在私有里声明一下就可以了。
当然这里为什么直接声明一下就可以了呢?
是因为我们没有必要去实现,因为也没有人去用它,所以就实现可以,不实现也是可以的。
那构造函数是需要实现的,不能够只声明又是为什么呢?
这是因为我们要用构造函数在堆上去创建对象,简单来说就是我们上面的 CreateObj 里要去使用这个构造函数。
虽然这个拷贝构造虽然没有实现,只是声明了一下,但是还是要将拷贝构造放到私有里面,原因:
就有人有可能会在类外去定义,那么拷贝构造就又可以使用了,所以做事做绝,直接在私有里去声明就可以了。
这个方法在 C++98 里叫做防拷贝。
在 C++11 中还有一种方法,就是用关键字 delete 。
我们可以看到,这个函数已经被删除了,所以不可以去调用了。而且如果我们将它放到公有里面,还是不可以使用的:
可以看到,是同样的效果。
2. 设计一个类,只能在栈上创建对象
方法一: 同上
class StackOnly
{
public:
static StackOnly CreateObject()
{
return StackOnly();
}
private:
StackOnly()
{}
};
还是和上面相同的做法,但是这里就不能禁用拷贝构造了,因为在返回的时候肯定是返回一个局部对象,所以 CreateObject 只能传值返回,但是只要是传值返回就肯定是要拷贝构造,那么如果把拷贝构造禁用了,那么返回的时候就会有问题。
方法二:屏蔽new
因为new在底层调用void* operator new(size_t size)函数,只需将该函数屏蔽掉即可。
注意:也要防止定位new
class StackOnly
{
public:
StackOnly() {}
private:
void* operator new(size_t size);
void operator delete(void* p);
};
int main()
{
StackOnly so;
StackOnly* p = new StackOnly;
static StackOnly sso;
return 0;
}
这里是因为 new 的时候是由两部分构成,第一部分是申请空间调用 operator new ,默认是调用全局的 operator new,再调它的构造函数。但是一个类可以重载专属的 operator new,所以这时肯定就会调用专属的 operator new ,所以我们将 operator new 设为私有,那么这时就调用不动了。
当然也可以用 C++11 的方法去实现。
但是这个方法有缺陷,虽然可以在栈上创建对象,不能在堆上创建对象了,但是:
但是可以在静态区去创建对象,所以这个方法是有一些缺陷的。
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中构造函数私有化,派生类中调不到基类的构造函数。则无法继承。
无法继承的原因是父类私有成员在子类不可见。
class NonInherit
{
public:
static NonInherit GetInstance()
{
return NonInherit();
}
private:
NonInherit()
{}
};
也就是说子类的构造函数想要初始化父类的那一部分,不能自己去对那一部分去初始化,而是要调用父类的构造函数去初始化,所以我们只要将父类的构造函数设为私有的,那么子类就看不到父类的构造函数,也就无法对其初始化,也就不能够被继承。
但是这里其实还是不够彻底的:
我们可以看到,其实是可以继承的,但是这里真正限制的是:
也就是子类继承后不能实例化出对象来,但是其实不能实例化出对象来,这个类就费了一半了,因为我们在使用类的时候基本都是实例化出对象,然后通过对象去进行一番操作。
但这也是不彻底的,所以才有了 C++11 的一个关键字 final。
- C++11方法
final关键字,final修饰类,表示该类不能被继承。
C++11 为了更直观彻底的实现不能被继承,增加了关键字 final。
5. 设计一个类,只能创建一个对象(单例模式)
在设计单例模式的时候会用到多线程的知识,我已经写过关于多线程的特特特详细博客了,下面就是链接,大家可以去看一看,多线程是非常重要的!
设计模式:
设计模式(Design Pattern)是一套被反复使用、多数人知晓的、经过分类的、代码设计经验的总结。为什么会产生设计模式这样的东西呢?就像人类历史发展会产生兵法。最开始部落之间打仗时都是人拼人的对砍。后来春秋战国时期,七国之间经常打仗,就发现打仗也是有套路的,后来孙子就总结出了《孙子兵法》。孙子兵法也是类似。
使用设计模式的目的:为了代码可重用性、让代码更容易被他人理解、保证代码可靠性。 设计模式使代码编写真正工程化;设计模式是软件工程的基石脉络,如同大厦的结构一样。
单例模式:
一个类只能创建一个对象,即单例模式,该模式可以保证系统中该类只有一个实例,并提供一个访问它的全局访问点,该实例被所有程序模块共享。比如在某个服务器程序中,该服务器的配置信息存放在一个文件中,这些配置数据由一个单例对象统一读取,然后服务进程中的其他对象再通过这个单例对象获取这些配置信息,这种方式简化了在复杂环境下的配置管理。
单例模式有两种实现模式:
- 饿汉模式
就是说不管你将来用不用,程序启动时就创建一个唯一的实例对象。
// 饿汉模式
// 优点:简单
// 缺点:可能会导致进程启动慢,且如果有多个单例类对象实例启动顺序不确定。
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 = new Singleton;
int main()
{
cout << Singleton::GetInstance() << endl;
cout << Singleton::GetInstance() << endl;
cout << Singleton::GetInstance() << endl;
return 0;
}
在自己类里不能定义自己的类型,但是自己类里定义自己类的指针是可以的,而且要定义成静态的,因为 GetInstance 也是静态的,因为静态的函数只能调用静态的成员函数。
然后因为是定义的静态的成员函数,所以需要在类外去初始化。
这个静态成员是在调用 main 函数之前就实例化了的。
然后我们可以通过在 main 函数中调用 GetInstance ,而且可以看到地址是一样的,也就是说这个进程只为这个类实例化了一个对象。
但是饿汉模式的缺点也很严重,就是如果这个项目的初始化很多,比如说加载数据库之类的配置初始化工作,那么这个配置初始化工作就要有很长时间,那么饿汉就很不合适了,因为启动进程非常慢。
- 懒汉模式
// 懒汉
// 优点:第一次使用实例对象时,创建对象。进程启动无负载。多个单例实例启动顺序自由控制。
// 缺点:复杂
#include <iostream>
#include <mutex>
#include <thread>
using namespace std;
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;
void func(int n)
{
cout << Singleton::GetInstance() << endl;
}
// 多线程环境下演示上面GetInstance()加锁和不加锁的区别。
int main()
{
thread t1(func, 10);
thread t2(func, 10);
t1.join();
t2.join();
cout << Singleton::GetInstance() << endl;
cout << Singleton::GetInstance() << endl;
}
我们可以看到,我们将静态成员初始化为空,当我们调用 GetInstance 的时候再进行初始化。
但是这里有一个问题,就是有线程安全的问题。
就是当多线程的时候,刚进行判断了为 nullptr ,然后进去,还没有调用 new ,然后当前线程就被切走了,然后下一个线程来了还是 nullptr 就又进去 new 了一个对象,然后恢复第一个线程的上下文后又 new 了一个对象,第二个 new 的就将第一个的给覆盖了,所以这样就有错误了!
所以这里我们就可以使用互斥锁~
因为加锁要加在一个锁上才有用,所以我们也要将锁设为静态的,然后在类外进行初始化,我们这样就保证了只实例化出一个对象来,但是这样实际上还是有些问题的。
问题就是当我们 new 出一个对象之后,我们在进行调用 GetInstance 的时候,还会不停的加锁解锁,我们知道,在我之前写的多线程的时候说过,加锁解锁是有性能消耗的,所以不断的加锁解锁是很不好的。
所以这里我们就要使用双检测加锁:
这样就减少加锁,获取了效率了。
那么这里有的小伙伴还是会有一点问题,那么就单例对象什么时候释放。
其实单例对象是不需要释放的,因为一般情况下单例在进程启动之后随时会被用,而且这个对象也不大,那么就可以不去释放。
那么会有内存泄漏?其实如果进程是正常结束的,因为 new 出来得到的进程地址空间是虚拟内存,当结束之后就会将地址通过页表取消映射,那么 new 出来的资源就会还给 OS 。
当然如果想要释放也是没有问题的:
我们就实现一个 DelInstance 去手动调用的去释放。
当然有大佬考虑到程序结束时,需要处理一下持久化保存一些数据,比方说要将数据写到硬盘上。那么就可以写一个析构函数,在析构函数中去处理。
然后如果担心自己会忘记手动调用 DelInstance ,那么就可以通过设计一个类,类中实现一个析构函数。
这个就是创建的时候创建一个 _gc,当 main 结束的时候 _gc 生命周期结束,然后调用它的析构函数,然后直接将单例对象进行析构。
下面是我写的整体的代码:
class Singleton
{
public:
static Singleton* GetInstance()
{
if (m_instance == nullptr)
{
_mtx.lock();
if (m_instance == nullptr)
{
m_instance = new Singleton;
}
_mtx.unlock();
}
return m_instance;
}
static void DelInstance()
{
//if (m_instance == nullptr)
//{
_mtx.lock();
if (m_instance == nullptr)
{
delete m_instance;
m_instance = nullptr;
}
_mtx.unlock();
//}
}
private:
Singleton()
{};
~Singleton()
{
// 程序结束时,需要处理一下持久化保存一些数据
}
Singleton(Singleton const&) = delete;
Singleton& operator=(Singleton const&) = delete;
// 实现一个内嵌垃圾回收类
class CGarbo {
public:
~CGarbo()
{
if (m_instance)
{
delete m_instance;
m_instance = nullptr;
}
}
};
static Singleton* m_instance;
static std::mutex _mtx;
static CGarbo _gc;
};
Singleton* Singleton::m_instance = nullptr;
std::mutex Singleton::_mtx;
Singleton::CGarbo Singleton::_gc;
int main()
{
cout << Singleton::GetInstance() << endl;
cout << Singleton::GetInstance() << endl;
cout << Singleton::GetInstance() << endl;
return 0;
}
上面的懒汉是标准的懒汉模式,当然还有大佬更绝,写了一个极致的懒汉:
class Singleton
{
public:
static Singleton* GetInstance()
{
static Singleton m_instance;
return &m_instance;
}
private:
Singleton()
{};
Singleton(Singleton const&) = delete;
Singleton& operator=(Singleton const&) = delete;
static Singleton* m_instance;
};
int main()
{
cout << Singleton::GetInstance() << endl;
cout << Singleton::GetInstance() << endl;
cout << Singleton::GetInstance() << endl;
return 0;
}
因为局部的静态成员函数初始化是在调用 GetInstance 的时候才会初始化,而且就算是多线程来了也不会有问题,可以认为 static Singleton m_instance; 是原子的。
如果说缺点,它也是有的,因为这个变量是在静态区的,如果单例对象太大,就不合适了,因为静态区的空间不适合太大的,而在堆上就没事,因为堆上的空间是很大的。
再有缺点就是想主动释放单例对象是无法控制的。
懒汉模式和饿汉模式的对比
饿汉
优点:简单
缺点:
- 如果单例对象构造函数工作比较多,会导致程序启动慢,迟迟进不了入口main函数
- 如果有多个单例对象,他们之间有初始化依赖关系,饿汉模式也会有问题。
比如有A和B两个单例类,要求A单例先初始化,B必须在A之后初始化。那么饿汉无法保证这种场景下面用懒汉就可以,懒汉可以先调用 A::GetInstance() ,再调用 B::GetInstance() 。
懒汉
优点:解决上面饿汉的缺点。因为他是第一次调用 GetInstance 时创建初始化单例对象
缺点:相对饿汉,复杂一点点。
如上就是 特殊类的设计 的所有知识,如果大家喜欢看此文章并且有收获,可以支持下 兔7 ,给 兔7 三连加关注,你的关注是对我最大的鼓励,也是我的创作动力~!
再次感谢大家观看,感谢大家支持!