C++:C/C++内存管理

最新推荐文章于 2022-11-29 11:10:53 发布

黑米姐姐

最新推荐文章于 2022-11-29 11:10:53 发布

阅读量171

点赞数

分类专栏： # C++

本文链接：https://blog.csdn.net/qq_41809901/article/details/98766389

版权

C++ 专栏收录该内容

25 篇文章 1 订阅

订阅专栏

C/C++内存分布
首先看图：

以下代码：

int GlobalVar = 1;
static int staticGlobalVar = 1;
void Test()
{
	static int staticVar = 1;
	int localVar = 1;
	int num1[10] = { 1, 2, 3, 4 };
	char char2[] = "abcd";
	char* pchar3 = "abcd";
	int* ptr1 = (int*)malloc(sizeof(int)* 4);
	int* ptr2 = (int*)calloc(4, sizeof(int));
	int* ptr3 = (int*)realloc(ptr2, sizeof(int)* 4);
	free(ptr1);
	free(ptr3);
}

分析：GlobalVar、staticGlobalVar、staticVar位于数据段，localVar、num1,、char2位于栈上，*char2位于栈上，因为数组中所有的元素都位于栈上，pchar3位于栈上，而 *pchar3位于代码段上，因为它表示的是指针所指的第一个常量，ptr1、ptr2、ptr3都位于栈上， *ptr1位于堆上。

C语言中动态内存管理方式
运用malloc/calloc/realloc等来申请空间，使用free来销毁,那么malloc、calloc、realloc有什么区别？
1、malloc的函数原型是void* malloc(size_t size)；它实现的功能是在内存的动态存储区分配一块长度为size字节的连续区域，参数size为需要的内存空间的长度，返回该区域的地址，它不能初始化所分配的内存空间，需要用memset，但函数calloc可以，若这部分空间曾经被分配过，可能产生遗留问题。
2、calloc的函数原型是void* calloc(size_t num,size_t size)；它实现的功能与malloc类似，参数num为参数个数，size为申请的地址的单位元素长度；它会将所分配的空间中的每一位都初始化为0；
3、realloc的函数原型是void* realloc(void* ptr,size_t size)；它实现的功能是给一个已经分配地址的指针重新分配空间，参数ptr为原有的空间地址，size是重新申请的地址空间大小，realloc不保持调整后的内存空间和原来的内存空间保持同一内存地址，返回的指针很可能指向新的地址
这几个函数的实现原理：
malloc和calloc是将一块可用的内存连接成一个链表，调用malloc函数时，它沿连接表寻找一个大到足以满足用户请求所需要的内存块，然后将该内存块一分为二（一块与用户申请的大小一样，另一块是剩下的字节），将分配给用户的内存地址传给用户，调用free函数，将用户释放的内存块连接到空链上，最后空闲链表会被分成很多小内存片段。
reallo是如果size小于原本的size，就是缩小内存空间，而相反如果扩大内存空间realloc所做的事是重新申请内存块，将原空间内容拷贝到新空间，释放旧空间，返回新空间。
C++内存管理方式
C语言内存管理方式在C++中可以继续使用，但有些地方就无能为力而且使用起来比较麻烦，因此C++又提出了自己的内存管理方式：通过new和delete操作符进行动态内存管理。

class Test
{
public:
   Test()
   {
   	cout << "Test():" << this << endl;
   }
   ~Test()
   {
   	cout << "~Test():" << this << endl;
   }
   void TestNewDelete()
   {
   	//new申请空间调用构造函数
   	Test* t1 = new Test;
   	delete t1;//delete销毁空间调用析构函数
   	Test* t2 = (Test*)malloc(sizeof(Test));//malloc申请的空间没有调用构造函数，没有创造对象
   	if (nullptr == t2)
   		;
   	free(t2);//没有调用析构函数
   	Test* t3 = new Test[10];//调用了10次构造函数
   	delete[]t3;//调用了10次析构函数
   }
private:
   int _t;
};
int main()
{
   Test t;
   t.TestNewDelete();
   return 0;
}

注意：在申请自定义类型的空间时，new会调用构造函数，delete会调用析构函数，而malloc与free不会。
建议malloc与free配合使用，new和delete配合使用，否则可能会产生一些问题，例如：内存泄漏，代码崩溃等。
例如：
类中管理资源时：

class Test
{
public:
	Test()
	{
		ptr = new int;
	}
	~Test()
	{
		delete ptr;
		ptr = nullptr;
	}
private:
	int* ptr;
};
void testfunc()
{
	//代码崩溃,malloc没有构造对象，无法使用delete调用析构函数来释放
	/*Test* p1 = (Test*)malloc(sizeof(Test));
	delete p1;*/
	//代码崩溃,因为malloc没有调用构造函数，而delete要调用析构函数，而这时候没有对象，无法释放
	Test* p2 = (Test*)malloc(sizeof(Test));
	delete[]p2;
	//p3在栈上，Test在堆上，堆里面ptr申请的空间，释放的是ptr申请的空间，因此存在内存泄漏
	Test* p3 = new Test;
	free(p3);//free不会调用析构函数
	//代码崩溃
	Test* p4 = new Test;
	delete[]p4;
	//代码崩溃，内存泄漏
	Test* p5 = new Test[10];
	free(p5);
	//代码崩溃
	Test* p6 = new Test[10];
	delete p6;
}
int main()
{
	testfunc();
	return 0;
}

类中不管理资源时：

class Test
{
public:
	Test()
	{
		cout << "Test()" << endl;
	}
	~Test()
	{
		cout << "~Test()" << this <<endl;
	}
private:
	int* data;
};
void testfunc()
{
	//代码没有问题，因为类里面没有管理资源
	Test* p1 = (Test*)malloc(sizeof(Test));
	delete p1;
	//代码崩溃
	Test* p2 = (Test*)malloc(sizeof(Test));
	delete[]p2;
	//没有影响，因为类中没有管理资源	
	Test* p3 = new Test;
	free(p3);
	//代码崩溃
	Test* p4 = new Test;
	delete[]p4;
	//代码崩溃
	Test* p5 = new Test[10];
	free(p5);
	//代码崩溃
	Test* p6 = new Test[10];
	delete p6;
}

int main()
{
	testfunc();
	return 0;
}

得出结论：当类中管理资源时，new+delete、new[]+delete[]必须配合使用，若malloc+delete代码会崩溃，malloc+delete[]代码会崩溃，new+free会存在内存泄漏，对象堆的空间释放，但是对象的资源没有销毁，new+delete[]代码崩溃，new[]+free代码崩溃，new[]+delete代码崩溃；当类中不管理资源时，malloc+delete代码没有问题，malloc+delete[]代码崩溃，new+free代码没有问题，new+delete[]代码崩溃，new[]+free代码崩溃，new[]+delete代码崩溃。
再比如：没有定义析构函数，类中没有管理资源：
例如：

class Test
{
public:
	Test()
	{
		cout << "Test()" << endl;
	}
private:
	int* data;
};
void testfunc()
{
	Test* p1 = (Test*)malloc(sizeof(Test));
	delete p1;

	Test* p2 = (Test*)malloc(sizeof(Test));
	delete[]p2;

	Test* p3 = new Test;
	free(p3);

	Test* p4 = new Test;
	delete[]p4;

	Test* p5 = new Test[10];
	free(p5);

	Test* p6 = new Test[10];
	delete p6;
}
int main()
{
	testfunc();
	return 0;
}

都没有崩溃

new和delete的实现原理
如果申请的是内置类型的空间，new和malloc，delete和free基本类似，不同的地方是：new/delete申请和释放的是单个元素的空间，new[]和delete[]申请的是连续空间，而且new在申请空间失败时会抛异常，malloc会返回NULL。
如果是自定义类型，则：
operator new与operator delete函数：
new是先申请空间（operator new）循环使用malloc（count）来申请空间，再调用构造函数，构造对象中的资源
例如：

void *__CRTDECL operator new(size_t count) 
{
	// try to allocate size bytes
	void *p;
	while ((p = malloc(count)) == 0)
	if (_callnewh(count) == 0)
	{
		// report no memory
		// 如果申请内存失败了，这里会抛出bad_alloc 类型异常
		static const std::bad_alloc nomem;
		_RAISE(nomem);
	}
	return (p);
}

分析：operator new首先执行malloc申请空间如果malloc申请空间，成功就直接返回，否则执行用户提供的空间不足应对措施，如果用户提供该措施就继续申请，否则就抛异常。
delete是先调用析构函数释放对象中的资源，再释放空间（operator delete）
例如：

void operator delete(void *pUserData) {
	_CrtMemBlockHeader * pHead;
	RTCCALLBACK(_RTC_Free_hook, (pUserData, 0));
	if (pUserData == NULL)
		return;
	_mlock(_HEAP_LOCK); /* block other threads */
	__TRY
		/* get a pointer to memory block header */
		pHead = pHdr(pUserData);
	/* verify block type */
	_ASSERTE(_BLOCK_TYPE_IS_VALID(pHead->nBlockUse));
	_free_dbg(pUserData, pHead->nBlockUse);
	__FINALLY
		_munlock(_HEAP_LOCK); /* release other threads */
	__END_TRY_FINALLY
		return;
}

operator delete 最终是通过free来释放空间的。
operator new[]与operator delete[]
operator T[N]是先申请空间–>void* operator new[](字节数）,实际上调用的是void* operator new(字节数）—>malloc申请空间，然后调用N次构造函数。

定位new表达式（place-new）
即在已经存在的空间上执行构造函数初始化一个对象，它的使用格式是new(place-address) 类名（参数列表），place-address是一个指针。
使用场景：定位new表达式在实际中一般是配合内存池使用，因为内存池分配出的内存没有初始化，因此若是自定义类型的对象，使用定义new表达式调用构造函数初始化。
例如：

class Test
{
public:
	Test()
		:_data(0)
	{
		cout << "Test():" << this << endl;
	}
	~Test()
	{
		cout << "~Test():" << this << endl;
	}
private:
	int _data;
};
int main()
{
	Test* pt = (Test*)malloc(sizeof(Test));
	new(pt)Test;//如果Test类的构造函数有参数时，此时应该传参
	return 0;
}

分析：先申请了一块内存空间，然后new了一个类的对象，即自动调用构造函数，定位new表达式初始化对象。

常见面试题
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
请设计一个类，该类只能在堆上创建对象：

class HeapOnly
{
public:
	static HeapOnly* GetObject()
	{
		return new HeapOnly;
	}
private:
	HeapOnly()
	{}
	//C++98
	//HeapOnly(const HeapOnly&);//拷贝构造函数,必须是私有的，如果不是私有的，在类外用户可能会定义拷贝构造函数，例如HeapOnly* o(*p),是在栈上申请空间因此不能实现只能在堆上申请空间的要求，所以必须是私有的
	//C++11
	HeapOnly(const HeapOnly&) = delete;//告诉编译器，删除拷贝构造函数
};
int main()
{
	HeapOnly* p = HeapOnly::GetObject();
	//HeapOnly* o(*p);//在栈上申请的空间，因此要将拷贝构造函数改成私有的
	return 0;
}

分析：只能在堆上创建对象，说明在全局作用域，局部作用域都创建不了，在构造对象时，编译器先开辟空间，然后调用构造函数，而开辟空间我们无法控制，只能从构造函数上下手，让构造函数调用不了，可以让构造函数设为私有的，而在外部想要在堆上创建对象，可以构造一个公有的成员函数，用于实现在堆上创建对象，又因为要在外部访问这个函数来构造对象，但是这时还要定义对象才能访问，可以用static修饰这个成员函数，通过类名：：成员函数来访问，这样就可以不用定义对象，而这时在外部可以调用拷贝构造函数，这还是在栈上申请空间，因此在C++98中可以将拷贝构造函数设为私有的，并只给声明，在C++11中将拷贝构造函数设为delete，即删除拷贝构造函数。
请设计一个类，该类只能在栈上创建对象
例如：

class StackOnly
{
public:
	static StackOnly GetObject()
	{
		return StackOnly();
	}
private:
	StackOnly()//将构造函数设为私有的
	{
		cout << "StackOnly():" << this << endl;
	}
};
int main()
{
	//StackOnly* s = new StackOnly;//不能实现
	//StackOnly::GetObject();
	StackOnly s = StackOnly::GetObject();//相当于StackOnly s(StackOnly::GetObject()),即拷贝构造函数
	//但这种方法不太好，在编译器没有优化的情况下，创建了3个对象
	return 0;
}

但这种方法存在缺陷，因此：

class StackOnly
{
public:
	StackOnly()
	{}
private:
	void* operator new(size_t size);
	void operator delete(void* p);
};
int main()
{
	//StackOnly* = new StackOnly;//错误
	//StackOnly* s=(StackOnly*)malloc(sizeof(StackOnly)); 
	//new(s)StackOnly;//错误，因为屏蔽了operator new，实际也将定位new屏蔽掉
	StackOnly s;
	return 0;
}

分析：只能在栈上创建对象，即不能在堆上创建，因此只要将new的功能屏蔽掉即可，即屏蔽掉operator new和定位new表达式,但是不能禁止全局作用域上的对象，即不能绝对地在栈上创建。
防止被拷贝

//防止被拷贝，只要将拷贝构造函数和赋值运算符重载屏蔽
class Test
{
public:
	Test()
	{}
public:
	//Test(const Test&);
	//Test& operator=(const Test&);
	//C++98
	Test(const Test&)=delete;
	Test& operator=(const Test&)=delete;//C++11
};
int main()
{
	Test t1;
	//Test t2(t1);//错误
	return 0;
}

分析：只需要将拷贝构造函数和赋值运算符重载屏蔽。
单例模式
即一个类只能创建一个对象，
单例模式有两种实现模式：
1、饿汉模式：不管你将来用不用，程序启动时就创建一个唯一的实例对象。
例如：

//饿汉模式,程序启动时，将对象创建好
class Singleton
{
public:
	static Singleton& GetInstrance()
	{
		return m_ins;
	}
private:
	Singleton()
	{}
	static Singleton m_ins;//程序启动时对象创建好
	Singleton(const Singleton&) = delete;
	Singleton& operator=(Singleton const&) = delete;
};
Singleton Singleton::m_ins;//初始化
int main()
{
	Singleton& s = Singleton::GetInstrance();
	return 0;
}

分析：如果这个单例对象在多线程高并发环境下频繁使用，性能要求较高，那么显然使用饿汉模式来避免资源竞争，提高响应速度更好。缺点是万一在创建对象期间比较耗费资源，将会影响程序启动速度；或者工程有两个单例的实例，当一个实例结束，不能保证开始下一个实例。
2、懒汉模式
如果单例对象构造十分耗时或者占用很多资源，比如加载插件啊，初始化网络连接啊，读取文件啊等等，而有可能该对象程序运行时不会用到，那么也要在程序一开始就进行初始化，就会导致程序启动时非常的缓慢。所以这种情况使用懒汉模式（延迟加载）更好。
优点是：第一次使用实例对象时，创建对象。进程启动无负载。多个单例实例启动顺序自由控制。
如：

#include <mutex>
#include <thread>
//懒汉模式,第一次使用时创建，延迟加载
//不是线程安全的，不能保证只能创建一个对象,因此实现加锁功能
//容易造成线程阻塞,利用双判断
//volatile作用是禁止编译器对代码发生指令重排
class Singleton
{
public:
	static volatile Singleton* GetInstrance()
	{
		if (nullptr == m_ins)//加一层检测，防止线程阻塞
		{
			m_mutex.lock();//加锁
			if (nullptr == m_ins)//若为空，说明是第一次调用
				m_ins = new Singleton;
			m_mutex.unlock();//解锁
		}
		return m_ins;
	}
	class GC
	{
	public:
		~GC()
		{
			if (m_ins)
			{
				delete m_ins;
				m_ins = nullptr;
			}
		}
	};//内嵌垃圾回收类
	
private:
	Singleton()
	{}

	Singleton(const Singleton&) = delete;
	static volatile Singleton* m_ins;
	static mutex m_mutex;
	static GC m_gc;
	
};
volatile Singleton*  Singleton::m_ins = nullptr;
mutex Singleton::m_mutex;
Singleton::GC m_gc;
void ThreadFunc()
{
	cout<<Singleton::GetInstrance()<<endl;
}
void TestSingleton()
{
	thread t1(ThreadFunc);
	thread t2(ThreadFunc);
	thread t3(ThreadFunc);
	thread t4(ThreadFunc);
	thread t5(ThreadFunc);
	thread t6(ThreadFunc);
	thread t7(ThreadFunc);
	thread t8(ThreadFunc);
	t1.join();
	t2.join();
	t3.join();
	t4.join();
	t5.join();
	t6.join();
	t7.join();
	t8.join();
}
int main()
{
	TestSingleton();
	return 0;
}

分析：懒汉模式是在第一次使用时创建对象，上述volatile的作用是禁止进行指令重排序，线程每次获取volatile变量的值都是最新的。
内存泄漏：
内存泄漏的危害：长期运行的程序出现内存泄漏，影响很大，如操作系统、后台服务等等，出现内存泄漏会导致响应越来越慢，最终卡死。
例如：

void testfunc()
{
	FILE* pf = fopen("111.txt", "rb");
	if (nullptr == pf)
	{
		throw 1;
	}
	fclose(pf);
}
void MemoryLeaks()
{
	// 1.内存申请了忘记释放
	int* p1 = (int*)malloc(sizeof(int));
	int* p2 = new int;
	// 2.异常安全问题
	int* p3 = new int[10];
	testfunc();//这里Func函数抛异常
	delete[] p3;
	delete p2;
	free(p1);
}
int main()
{
	try
	{
		MemoryLeaks();
	}
	catch (int err)
	{
		cout << err << endl;
	}
	return 0;
}

内存泄漏的分类：
堆内存泄漏(Heap leak)
堆内存指的是程序执行中依据须要分配通过malloc / calloc / realloc / new等从堆中分配的一块内存，用完后必须通过调用相应的 free或者delete 删掉。假设程序的设计错误导致这部分内存没有被释放，那么以后这部分空间将无法再被使用，就会产生Heap Leak。
系统资源泄漏
指程序使用系统分配的资源，比方套接字、文件描述符、管道等没有使用对应的函数释放掉，导致系统资源的浪费，严重可导致系统效能减少，系统执行不稳定。
如何一次在堆上申请4G的内存?
例如：

//如何一次在堆上申请4G的内存？
//在x64的环境下可以运行
int main()
{
   void* p = new char[0xfffffffful];
   cout << "new:" << p << endl;
   return 0;
}

运行结果是：
在这里插入图片描述
分析：在x64下可以运行（在64位系统下）
源代码：（github）
https://github.com/wangbiy/C-/tree/master/test_2019_8_6_1/test_2019_8_6_1

黑米姐姐

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
复制链接

分享到 QQ

分享到新浪微博

扫一扫

专栏目录