特殊类设计(C++面试常考)

Posted 雨轩(爵丶迹)

tags:

篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了特殊类设计(C++面试常考)相关的知识,希望对你有一定的参考价值。

特殊类设计

1、请设计一个类,只能在堆上创建对象

  1. 将类的构造函数私有,拷贝构造声明成私有。防止别人调用拷贝在栈上生成对象。
  2. 提供一个静态的成员函数,在该静态成员函数中完成堆对象的创建。
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&);
	//...
;

原因:

  1. 设置成私有:如果只声明没有设置成private,用户自己如果在类外定义了,就不能禁止拷贝了。
  2. 只声明不定义:不定义是因为该函数根本不会调用,定义了其实也没有什么意义,不写反而还简单,而且如果定义了就不会防止成员函数内部拷贝了。

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)是一套被反复使用、多数人知晓的、经过分类的、代码设计经验的总结。

为什么会产生设计模式这样的东西呢?就像人类历史发展会产生兵法。最开始部落之间打仗时都是人拼人的对砍。后来春秋战国时期,七国之间经常打仗,就发现打仗也是有套路的,后来孙子就总结出了《孙子兵法》。孙子兵法也是类似。

  • 使用设计模式的目的:为了代码可重用性、让代码更容易被他人理解、保证代码可靠性
  • 设计模式使代码编写真正工程化;设计模式是软件工程的基石脉络,如同大厦的结构一样。

单例模式:一个类只能创建一个对象,即单例模式,该模式可以保证系统中该类只有一个实例,并提供一个访问它的全局访问点,该实例被所有程序模块共享。

  • 单例模式有两种实现模式

比如在某个服务器程序中,该服务器的配置信息存放在一个文件中,这些配置数据由一个单例对象统一读取,然后服务进程中的其他对象再通过这个单例对象获取这些配置信息,这种方式简化了在复杂环境下的配置管理。

饿汉模式

定义:就是说不管你将来用不用,程序启动时就创建一个唯一的实例对象。

如何保证全局(一个进程中)只有一个唯一实例对象

  1. 构造函数私有定义。拷贝构造和赋值防拷贝禁掉
  2. 提供一个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++面试常考)的主要内容,如果未能解决你的问题,请参考以下文章

特殊类设计(C++面试常考)

:设计模式第28节:面试常考设计模式 (上)

Java常考面试题

mysql面试常考知识点

mysql面试常考知识点

Java常考面试题