C/C++内存管理

目录

一、c/c++内存分布

二、C语言中的动态内存管理方式

三、C++的动态内存管理

3.1  new/delete操作内置类型

3.2  new/delete操作自定义类型

四、operator new和operator delete函数

五、new和delete的实现原理

5.1  内置类型

5.2  自定义类型

六、定位new的表达式（了解）

---

一、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";
 const 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);
}


1. 选择题：
   选项: A.栈  B.堆  C.数据段(静态区)  D.代码段(常量区)
   globalVar在哪里？____   staticGlobalVar在哪里？____
   staticVar在哪里？____   localVar在哪里？____
   num1 在哪里？____
   
   char2在哪里？____   *char2在哪里？___
   pChar3在哪里？____      *pChar3在哪里？____
   ptr1在哪里？____        *ptr1在哪里？____
2. 填空题：
   sizeof(num1) = ____;   
   sizeof(char2) = ____;      strlen(char2) = ____;
   sizeof(pChar3) = ____;     strlen(pChar3) = ____;
   sizeof(ptr1) = ____;
3. sizeof 和 strlen 区别？

答案：

1、C  C  C  A  A

     A  A  A  D  A  B

2、40  5  4  4/8  4  4/8

3、sizeof是用来计算数据类型所占空间的大小，单位为字节；而strlen是一个函数，用来计算字符串长度。

 

注意事项：

• 栈又叫堆栈--非静态局部变量/函数参数/返回值等等，栈是向下增长的。
• 内存映射段是高效的I/O映射方式，用于装载一个共享的动态内存库。用户可使用系统接口 创建共享共享内存，做进程间通信。（Linux课程如果没学到这块，现在只需要了解一下）
• 堆用于程序运行时动态内存分配，堆是向上增长的。
• 数据段--存储全局数据和静态数据。
• 代码段--可执行的代码/只读常量。 

---

二、C语言中的动态内存管理方式

C语言中动态内存管理：malloc/calloc/realloc/free

malloc/calloc/realloc的区别是什么？

malloc是一个函数，原型：void *malloc(unsigned int num_bytes)，参数是在申请空间的大小，需要我们自己计算，用法：int *p = (int *)malloc(20*sizeof(int))，此时申请的内存值是不确定的。

calloc函数原型void *calloc(size_t n, size_t size)，有两个参数，参数n是需要开辟空间的个数，size则是开辟空间类型的大小，用法：int *p = (int *)calloc(20, sizeof(int)），不需要我们手动计算空间大小。

realloc原型：void realloc(void *ptr, size_t new_Size)，用于对动态内存进行扩容(及已申请的动态空间不够使用，需要进行空间扩容操作)，ptr为指向原来空间基址的指针， new_size为接下来需要扩充容量的大小。

void Test ()
{
int* p1 = (int*) malloc(sizeof(int));
free(p1);

int* p2 = (int*)calloc(4, sizeof (int));
int* p3 = (int*)realloc(p2, sizeof(int)*10);
// 这里需要free(p2)吗？

free(p3);
}

 上面的代码不需要写free(p2)，因为realloc扩容的时候有两种情况，一种是该空间后面的空间足够，就在原地开空间，返回一样的地址，另一种是后面没有足够的空间，realloc将会在异地寻找足够的空间，然后再把值赋值到新空间，释放久空间，返回新地址。

---

三、C++的动态内存管理

3.1  new/delete操作内置类型

C++提出了自己的内存管理方式：通过new和delete操作符进行动态内存管理。

void Test()
{
	//动态申请一个int类型空间
	int* ptr1 = new int;
	delete ptr1;//new和delete是操作符

	//动态申请一个int类型空间并初始化10
	int* ptr2 = new int(10);
	delete ptr2;

	//动态申请10个int类型空间
	int* ptr3 = new int[10];//此处的10是对象个数
	delete[] ptr3;
}

注意：动态申请和释放多个空间要用new[]和delete[], 申请和释放单个空间要用new和delete,不能不匹配的使用，否则会出现很多问题。

3.2  new/delete操作自定义类型

在内置类型中，C++中malloc/free和new/delete除了用法上，其他都是一样的，而new/delete最大的区别是在自定义类型中。

class A
{
public:
	A(int a = 0)
		:_a(a)
	{
		cout << "A(int a)" << endl;
	}

	~A()
	{
		cout << "~A()" << endl;
	}

private:
	int _a;
};

int main()
{
	//申请一个A类的对象
	A* p1 = (A*)malloc(sizeof(A));
	A* p2 = new A;
	free(p1);
	delete p2;
	//申请一个A类的对象，初始化10
	A* p3 = new A(10);
	delete p3;
	//申请10个A类的对象
	A* p4 = (A*)malloc(sizeof(A) * 10);
	A* p5 = new A[10];
	free(p4);
	delete[] p5;//申请了多个也要释放多个，配对使用

	return 0;
}

运行结果：

A(int a)
~A()
A(int a)
~A()
A(int a)
A(int a)
A(int a)
A(int a)
A(int a)
A(int a)
A(int a)
A(int a)
A(int a)
A(int a)
~A()
~A()
~A()
~A()
~A()
~A()
~A()
~A()
~A()
~A()

通过上面代码运行结果可以看出，在申请自定义类型的空间时，new会调用构造函数，delete会调用析构函数，而malloc与 free不会。

---

四、operator new和operator delete函数

new和delete是用户进行动态内存申请和释放的操作符，operator new 和operator delete是 系统提供的全局函数，new在底层调用operator new全局函数来申请空间，delete在底层通过 operator delete全局函数来释放空间。

反汇编：

注意：call是调用函数的指令

C语言中的malloc申请空间会存在空间申请失败，申请失败时会返回值为空指针，所以我们需要检查返回值。

int main()
{
	while (1)
	{
		//malloc失败返回值是空指针，需要检查返回值
        //此处为了能更好的演示，一次申请的空间很大
		int* p1 = (int*)malloc(1024*1024*1024);
		if (p1)
		{
			cout << p1 << endl;
		}
		else
		{
			cout << "malloc fail" << endl;
			break;
		}
	}

	return 0;
}

运行结果：

00D59040
malloc fail

可以看出，当返回值为空指针时，malloc开空间失败。

而new申请空间失败不会返回空指针，而是直接抛异常

int main()
{
	try
	{
		while (1)
		{
			//new失败，抛异常
			int* p1 = new int[1024 * 1024];
			if (p1)
			{
				cout << p1 << endl;
			}
		}
	}
	catch (exception& e)
	{
		cout << e.what() << endl;
	}
		

	return 0;
}

运行结果： 

 注意，这里的异常只用看用法，因为还没学习到。

看operator new和operator delete源码：

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


/*
operator delete: 该函数最终是通过free来释放空间的
*/
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;
}
/*
free的实现
*/
#define   free(p)               _free_dbg(p, _NORMAL_BLOCK)

通过上述两个全局函数的实现知道，operator new 实际也是通过malloc来申请空间，如果 malloc申请空间成功就直接返回，否则执行用户提供的空间不足应对措施，如果用户提供该措施 就继续申请，否则就抛异常。operator delete 最终是通过free来释放空间的。 

---

五、new和delete的实现原理

5.1  内置类型

申请内置类型空间，new/delete和malloc/free基本上一样，不同点在于：new/delete在申请单个和多个的时候分别用new/delete和new[]/delete[]，而且new在申 请空间失败时会抛异常，malloc会返回NULL。

5.2  自定义类型

• new的原理

1. 调用operator new函数申请空间（实际上还是用malloc申请空间）
2. 在申请的空间上执行构造函数，完成对象构造

• delete的原理

1. 在空间上执行析构函数，完成对象中资源清理的工作
2. 调用operator delete函数释放对象的空间

• new[]的原理

1. 调用operator new[]函数，在operator new[]中实际调用operator new函数完成N个对 象空间的申请
2. 在申请的空间上执行N次构造函数

• delete[]的原理

1. 在释放的对象空间上执行N次析构函数，完成N个对象中资源的清理
2. 调用operator delete[]释放空间，实际在operator delete[]中调用operator delete来释放空间。

---

六、定位new的表达式（了解）

定位new表达式是在已分配的原始内存空间中调用构造函数初始化一个对象。

class A
{
public:
	A(int a = 0)
		: _a(a)
	{
		cout << "A():" << this << endl;
	}
	~A()
	{
		cout << "~A():" << this << endl;
	}
private:
	int _a;
};


int main()
{
	A* p1 = (A*)malloc(sizeof(A));
	//使用定位new表达式，将已存在的空间p1进行显示调用构造函数进行初始化
	new(p1)A;//如果A类的构造函数有参数时，此处需要传参  //new(p1)A(10);
	p1->~A();

	free(p1);

	return 0;
}

---

最后，谢谢您的阅读！！！

您的点赞、关注和评论就是我写文章的最大动力嗷，让我们一起共同进步！！！！