面试官最爱问的特殊类到底是怎么肥四

目录

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

2、请设计一个类，只能在栈上创建对象

3、请设计一个类，不能被拷贝

4、请设计一个类，不能被继承

5、请设计一个类，只能创建一个对象（单例模式）

饿汉模式

懒汉模式

---

面试官：请设计一个类...

我：

然后，我就想到一句话

让我康康还有谁跟我一样“死鱼安乐”，扶我起来，我还能学！！

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

实现方式：

• 将类的构造函数私有，拷贝构造声明成私有，防止别人调用拷贝构造在栈上生成对象
• 提供一个静态成员函数，在该静态成员函数中完成堆对象的创建

//只能在堆上创建对象
class HeapOnly
{
public:
	//公有的方法，创建对象
	static HeapOnly* getOBJ()
	{
		//堆上创建对象
		return new HeapOnly;
	}
private:
	//构造函数私有化
	HeapOnly()
	{}

	//防拷贝
	//C++ 98
	//拷贝构造私有化,只声明不实现
	HeapOnly(const HeapOnly& ho);

	//C++ 11
	//直接定义成delete函数
	//HeapOnly(const HeapOnly& ho) = delete;
};

2、请设计一个类，只能在栈上创建对象

方法一：将构造函数私有化，设计静态方法创建对象

//只能在栈上创建对象
class StackOnly
{
public:
	//公有的方法,在栈上创建对象
	static StackOnly getOBJ()
	{
		StackOnly so;
		return so;
	}

private:
	//构造函数私有化
	StackOnly()
	{}
};

方法二：屏蔽掉new

//只能在栈上创建对象
class StackOnly
{
public:
	static StackOnly getOBJ()
	{
		StackOnly so;
		return so;
	}
private:
	//C++ 98
	void* operator new(size_t n);
	void operator delete(void* ptr);

	//C++ 11
	//void* operator new(size_t n) = delete;
	//void operator delete(void* ptr) = delete;

	StackOnly()
	{}
};

3、请设计一个类，不能被拷贝

拷贝只会发生在两个场景：拷贝构造函数和赋值运算符重载，想让一个类进制拷贝，只需要让该类不能调用拷贝构造函数和赋值运算符重载

• C++ 98

将拷贝构造函数和赋值运算符重载只声明不定义，将其访问权限设置为私有

原因：

只声明不定义：该函数根本不会调用，定义了也没什么意义

设置成私有：如果只声明没有设置成private，用户如果自己在类外定义了，就不能禁止拷贝了

class CopyBan{
public:
	//...
private:
	CopyBan(const CopyBan&);
	CopyBan& operator=(const CopyBan&);

	CopyBan()
	{}
};

• C++ 11

delete的使用， 在默认成员函数后加上=delete，声明为delete的函数不能被调用

class CopyBan{
	//...
	CopyBan(const CopyBan&) = delete;
	CopyBan& operator=(const CopyBan&) = delete;

	CopyBan()
	{}
	//...
};

4、请设计一个类，不能被继承

• C++ 98

构造函数私有化，派生类调不到基类的构造函数，无法继承

class A{
public:
	static A getInstance(){
		return A();
	}
private:
	A()
	{}
};

• C++ 11

final关键字，final修饰类表示该类不能被继承

class A final{
	//...
};

5、请设计一个类，只能创建一个对象（单例模式）

• 饿汉模式

在程序初始化阶段完成资源的申请加载初始化，对象的实例化（思想：以空间换时间）不涉及线程安全问题

饿汉方式实现单例模式：

成员变量静态化（资源共享）；构造函数私有化

//饿汉模式
class Singleton
{
public:
	//公有的static方法
	static Singleton& getOBJ()
	{
		return _singleton;
	}
private:
	//构造函数私有化
	Singleton()
	{}

	//防拷贝
	Singleton(const Singleton&) = delete;
	Singleton& operator=(const Singleton&) = delete;

	//static成员
	static Singleton _singleton;
};

Singleton Singleton::_singleton; //在程序入口之前就完成单例对象的初始化

• 懒汉模式

资源在使用时才加载、初始化（思想：“延时加载”）

懒汉方式实现单例模式：

资源使用静态指针——资源共享，延迟加载

加锁保护——线程安全

二次检测——减少锁冲突，提高效率

class Singleton
{
public:
	//static公有方法创建对象:第一次调用时创建对象
	static Singleton* getOBJ()
	{
		//提高效率
		if (_ptr == nullptr)
		{
			_mtx.lock();
			//创建对象:第一次调用时创建对象
			//保证单例
			if (_ptr == nullptr)
			{
				_ptr = new Singleton;
			}
			_mtx.unlock();
		}
		return _ptr;
	}

	class GarbageGC
	{
		~GarbageGC()
		{
			if (_ptr)
				delete _ptr;
		}
	};

private:
	//构造函数私有
	Singleton()
	{
		cout << "Singleton()" << endl;
	}

	//防拷贝
	Singleton(const Singleton&) = delete;
	Singleton& operator=(const Singleton&) = delete;

	static Singleton* _ptr;
	static mutex _mtx;
	static GarbageGC _gc;
};

Singleton* Singleton::_ptr = nullptr;
mutex Singleton::_mtx;
Singleton::GarbageGC Singleton::_gc;

都学废了吗？面试冲鸭！！