特殊类设计(C++面试常考)
Posted 雨轩(爵丶迹)
tags:
篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了特殊类设计(C++面试常考)相关的知识,希望对你有一定的参考价值。
特殊类设计
1、请设计一个类,只能在堆上创建对象
- 将类的构造函数私有,拷贝构造声明成私有。防止别人调用拷贝在栈上生成对象。
- 提供一个静态的成员函数,在该静态成员函数中完成堆对象的创建。
class HeapOnly
public:
static HeapOnly* CreateObject()
return new HeapOnly;
private:
HeapOnly()
// C++98
// 1.只声明,不实现。因为实现可能会很麻烦,而你本身不需要(没有人用)
// 2.声明成私有
HeapOnly(const HeapOnly&);
// or
// C++11 delete,表示禁止生成拷贝构造
HeapOnly(const HeapOnly&) = delete;
;
int main()
HeapOnly* p = HeapOnly::CreateObject();
return 0;
2、请设计一个类,只能在栈上创建对象
方法一:同上将构造函数私有化,然后设计静态方法创建对象返回即可。
class StackOnly
public:
static StackOnly CreateObject()
return StackOnly();
private:
StackOnly()
;
方法二:屏蔽new
因为new在底层调用void* operator new(size_t size)函数,只需将该函数屏蔽掉即可。
注意:也要防止定位new
class StackOnly
public:
StackOnly()
private:
//C++98
void* operator new(size_t size);
void operator delete(void* p);
//C++11
void* operator new(size_t size) = delete;
void operator delete(void* p) = delete;
;
int main()
StackOnly p;
static StackOnly s;//缺陷:没有禁掉在静态区的对象
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中构造函数私有化,派生类中调不到基类的构造函数,则无法继承(父类也就无法实例化对象)。
C++98中这个不能被继承的方式不够彻底,实际是可以继承,限制的是子类继承后不能实例化对象。
class NonInherit
public:
static NonInherit GetInstance()
return NonInherit();
private:
NonInherit()
;
C++11:final关键字,final修饰类,表示该类不能被继承(final意味是最后一个类,无法继承)。
class A final
// ....
;
5、请设计一个类,只能创建一个对象(单例模式)
我们先简单的介绍什么是设计模式:
- 设计模式(Design Pattern)是一套被反复使用、多数人知晓的、经过分类的、代码设计经验的总结。
为什么会产生设计模式这样的东西呢?就像人类历史发展会产生兵法。最开始部落之间打仗时都是人拼人的对砍。后来春秋战国时期,七国之间经常打仗,就发现打仗也是有套路的,后来孙子就总结出了《孙子兵法》。孙子兵法也是类似。
- 使用设计模式的目的:为了代码可重用性、让代码更容易被他人理解、保证代码可靠性。
- 设计模式使代码编写真正工程化;设计模式是软件工程的基石脉络,如同大厦的结构一样。
单例模式:一个类只能创建一个对象,即单例模式,该模式可以保证系统中该类只有一个实例,并提供一个访问它的全局访问点,该实例被所有程序模块共享。
- 单例模式有两种实现模式
比如在某个服务器程序中,该服务器的配置信息存放在一个文件中,这些配置数据由一个单例对象统一读取,然后服务进程中的其他对象再通过这个单例对象获取这些配置信息,这种方式简化了在复杂环境下的配置管理。
饿汉模式
定义:就是说不管你将来用不用,程序启动时就创建一个唯一的实例对象。
如何保证全局(一个进程中)只有一个唯一实例对象
- 构造函数私有定义。拷贝构造和赋值防拷贝禁掉
- 提供一个GetInstance获取单例对象
// 饿汉模式 -- 程序开始main执行之前就创建单例对象
// 提供一个静态指向单例对象的成员指针,初始化时new一个对象给它
// 优点:简单
// 缺点:可能会导致进程启动慢,且如果有多个单例类对象实例启动顺序不确定。
class Singleton
public:
static Singleton* GetInstance()
return &m_instance;//静态对象
//return m_instace2;//静态对象指针
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;//静态对象,也可以是指针
static Singleton* m_instance2;
;
Singleton Singleton::m_instance; // 在程序入口之前就完成单例对象的初始化
Singleton* Singleton::m_instance2 = new Singleton;
int main()
Singleton::GetInstance();
return 0;
饿汉模式适合场景:
- 如果这个单例对象在多线程高并发环境下频繁使用,性能要求较高,那么显然使用饿汉模式来避免资源竞争,提高响应速度更好。
饿汉模式不适合场景:
- 如果单例对象构造十分耗时或者占用很多资源,比如加载插件啊, 初始化网络连接啊,读取文件啊等等,而有可能该对象程序运行时不会用到,那么也要在程序一开始就进行初始化,就会导致程序启动时非常的缓慢。
比如开机,我们希望一直卡在启动界面嘛?还是先进界面,后加载其他插件?当然是先启动后加载,不然一直等待,速度非常缓慢,体验非常不好。对于这种情况,使用懒汉模式(延迟加载)更好。
懒汉模式
// 懒汉
// 优点:第一次使用实例对象时,创建对象。进程启动无负载。多个单例实例启动顺序自由控制。
// 缺点:复杂
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(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;
关于为什么要加锁:
- 假设线程1和线程2都在调用
getInstance()
方法,此时m_pInstance
对象为空,线程1和线程2都能通过 if 判断进入同步代码块,只是线程1进入锁定的代码中执行创建实例的代码时,线程2处于等待状态,当线程1执行完成后,线程2并不知道实例已经创建完成,因此线程2将继续创建新的实例,这时将导致产生两个实例对象,违背了单例模式的设计思想。
关于为什么是double check:
- 线程1此时去调用getInstance() 方法,此时
m_pInstance
对象为空,那么线程1就创建对象,线程2等待线程1执行完毕,如果此时m_pInstance
对象不为空,说明已经被使用了,也就不用再进去解锁加锁,这样的好处是不用频繁切换线程,提高效率。
其他版本的懒汉模式:局部静态对象
class Singleton
public:
static Singleton* GetInstance()
//局部静态
static Singleton inst;
return &inst;
void Print()
cout << "Print()" << _a << endl;
private:
Singleton()
:_a(0)
// 假设单例类构造函数中,要做很多配置初始化
~Singleton()
// 程序结束时,需要处理一下,持久化保存一些数据
Singleton(const Singleton&) = delete;
Singleton& operator=(const Singleton&) = delete;
int _a;
;
这种模式了解就好,缺点:1、单例对象在静态区,如果单例对象太大,不太好,不合适。2、想主动释放单例对象,无法主动控制。
懒汉模式和饿汉模式的对比
饿汉
-
优点:简单
-
缺点:
1、如果单例对象构造函数工作比较多,会导致程序启动慢,迟迟进不了入口main函数
2、如果有多个单例对象,他们之间有初始化依赖关系,饿汉模式也会有问题。比如有A和B两个单例类,要求A单例先初始化,B必须在A之后初始化。那么饿汉无法保证 这种场景下面用懒汉就可以,懒汉可以先调用A::GetInstance(),再调用B::GetInstance().
懒汉
- 优点:解决上面饿汉的缺点。因为他是第一次调用GetInstance时创建初始化单例对象。
- 缺点:相对饿汉,复杂一点点。
以上是关于特殊类设计(C++面试常考)的主要内容,如果未能解决你的问题,请参考以下文章