内存管理常见面试题--C++

内存管理常见面试题–C++

在内存管理部分总结四个常见的面试题：malloc/free和new/delete的区别、设计一个类只能在堆上创建对象、计一个类只能在栈上创建对象、单例模式

1. malloc/free和new/delete的区别

共同点：malloc/free和new/delete的共同点是：都是重堆上申请空间，并且需要用户手动释放。
不同点：1.malloc和free是函数，new和delete是操作符
2.malloc申请的空间不会初始化，new可以初始化（自定义类型）
3.malloc申请空间时，需要手动计算大小并传递，new只需在其后跟上空间的类型即可
4.malloc的返回值为void*,在使用时必须使用强转；new不需要，因为new后面跟的是空间的类型
5.malloc申请空间失败时，返回的是NULL，因此必须使用判空，new不需要，但是new需要捕获异常
6.申请自定义类型对象时，malloc/free只会开辟空间，不会调用构造函数与析构函数；而new在申请空间后会调用构造函数完成对象的初始化，delete在释放空间前会调用析构函数完成空间中资源得清理
7.new/delete比malloc/free的效率要低一点，因为new/delete的底层封装了malloc/free

2.请设计一个类，该类只能在堆上创建

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

class HeapOnly
{
public:
	static HeapOnly* CreatObject()
	{
		return new HeapOnly;
	}
private:
	HeapOnly(){}
	
	//C++98 
	//1.只声明，不实现。因为实现可能会很麻烦，而本身不需要
	//2.声明成私有
	HeapOnly(const HeapOnly&);
};

3.请设计一个类，该类只能在栈上创建

只能在展上创建对象，因此只要将new的空能屏蔽掉即可（即屏蔽掉operator new和定位new表达式，屏蔽掉operator new，实际上也将定位new表达式屏蔽掉了）

class StackOnly
{
public:
	StackOnly()
	{}
private:
	void* operator new(size_t size);
	void operator delete(void* p);
};

4.单例模式

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

• 饿汉模式
  不管你将来用不用，程序启动时就创建一个唯一的实例对象

class Singleton
{
public:
	static Singleton* GetInstance()
	{
		return &m_instance;
	}
private:
	//构造函数私有
	Singleton()
	{}

	//C++98 防拷贝
	Singleton(Singleton const&);
	Singleton& operator=(Singleton const&);

	//C++11
	/*Singleton(Singleton const&)=delete;
	Singleton& operator=(Singleton const&) = delete;*/

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

• 懒汉模式
  如果单例对象构造十分耗时或者占用很多资源，比如加载插件啊， 初始化网络连接啊，读取文件啊等等，而有可能该对象程序运行时不会用到，那么也要在程序一开始就进行初始化，就会导致程序启动时非常的缓慢。 所以这种情况使用懒汉模式（延迟加载）更好

#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;
		}
	};

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;
}

int main()
{
	thread t1(func, 10);
	thread t2(func, 10);

	t1.join();
	t2.join();

	cout << Singleton::GetInstance() << endl;
	cout << Singleton::GetInstance() << endl;
	return 0;
}