一、C/C++内存分布

C/C++内存被分为6个区域：
（1） 内核空间：存放内核代码和环境变量。

（2）栈区：向下增长（存放非静态局部变量，函数参数，返回值等等）

（3）内存映射段：文件映射，匿名映射，动态库。

（4）堆区：向上增长（用于程序运行时动态内存的分配）

（5）数据段：也叫，静态区/全局域，（存放全局变量和静态变量）

（6）代码段：也叫常量区，（存放可读代码和只读常量）

看看下面代码的例题：

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
2. A A A D A B
3.40 5 4 4或8 4 4或8

3.sizeof和strlen的区别：
（1）char ch2[ ]=“abcd”; // sizeof(ch2)=5 （因为末尾还有一个’\0’）
// strlen(ch2)=4 （因为strlen其他都不管，遇到’\0’就结束，‘\0’不计入）
（2）sizeof（）内部要看变量是否为指针，若是指针==4/8
strlen不看变量是否为指针，只看’\0’ ，遇到’\0’结束为止！！！

4.对char2，pchar3，ptr1的解释：
（1）字符串存在于常量区，当拿来初始化char2的时候，char2会在栈区开辟一个空间，然后再把字符串拷贝给char2，char2就在栈区。

（2）char2是数组名，对地址解引用，*char2仍然在栈区！

（3） 被const的修饰变量不一定在常量区，有可能const修饰的是常变量，存放在栈区！

（4）pchar3是在栈上的指针变量，*pchar3=='‘abcd\0’'是：指向的字符串“abcd\0”存放在常量区

（5）ptr1是在栈上的指针变量，ptr1由于是由malloc出来的，所以ptr1指向的空间（即：*ptr1）在堆区

二、C/C++使用new和delete的原因

new和delete是C++向内存申请空间和释放空间的操作符， C++为什么要使用new和delete？

1.C语言使用malloc、calloc、realloc、free管理的不便之处在于：

（1）需要手动申请空间，手动计算申请的字节大小。

（2）对返回值void*需要进行强转，否则无法进行解引用。

（3）内存申请是否成功还需要进行判断。

（4）需要include头文件<stdlib.h>

2.new和delete对自定义类型也会进行处理：

（1）new会调用构造函数对类对象进行初始化

（2）delete会调用析构函数进行资源清理

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

1.new和delete

（1）new/delete和malloc/free对内置类型的操作没有区别
注意：
①申请和释放单个空间，需要用new和delete。
②申请和释放多个空间，需要用new [ ]和delete [ ]

（2）new的特点：

#define _CRT_SECURE_NO_WARNINGS 1 
#include <stdio.h>
#include <stdlib.h>
#include <iostream>
using namespace std;


int main()
{
	// 1.C语言申请空间
	int* p0 = (int*)malloc(sizeof(int) * 4);
	if (p0 == NULL)
	{
		perror("malloc fail");
		return 1;
	}

	free(p0);

	// 2.new 1个int整型的元素
	int* p1 = new int;

	delete p1;

	// 3.new 10个int整型元素，(即：数组)
	int* p2 = new int[10];

	// 申请的时候为：new[ ] ,释放的时候，必须要用delete[ ] 
	delete[] p2;

	// 4.可以控制初始化
	int* p3 = new int(10); // new一个int整型 并且初始化为10
	delete p3;
	// 5.new失败后会抛异常，不必手动检查
}

C++11开始支持new初始化数组：
如果没有初始化到的，默认为0

int* p4 = new int[10] {1, 2, 3, 4, 5};
delete[] p4;

（3）new/delete和malloc/free对自定义类型的操作有区别：

①malloc/free对自定义类型的操作只会开空间/释放空间

②new操作自定义类型会开空间+构造函数初始化，delete操作自定义类型会调用析构函数清理+释放空间

class ListNode
{
public:
	ListNode* _prev;
	ListNode* _next;
	int _val ;

	ListNode()
		:_prev(nullptr)
		,_next(nullptr)
		,_val(0)
	{
		cout << "this _val=" << _val << endl;
	}
	~ListNode()
	{
		cout << "~ListNode()" << endl;
	}
};

int main()
{
	ListNode* p1 = (ListNode*)malloc(sizeof(ListNode) * 4);
	ListNode* p2 = new ListNode;

	free(p1);
	delete(p2);

	return 0;
}

当程序走完第94行之后，那么p2里面的值都被初始化了。然而对于93行malloc出来的值都是随机值。从调试的界面可以看出，它也调用了构造函数，所以打印出:this _val=0

这就是new和malloc的区别，new对自定义类型会调用构造函数（delete会调用析构函数），对对象进行初始化和空间清理，而C语言之前的malloc和free不会这样做，他们只会开辟空间和释放空间。

2.operator new和operator delete

（1）定义：operator new 和operator delete是系统提供的全局函数，new在底层调用operator new全局函数来申请空间，（operator new是对malloc的封装），delete在底层通过operator delete全局函数来释放空间，（operator delete是对free的封装）它们不是new和delete的重载。
（2）与malloc区别：operator new、operator delete的用法和malloc、free的用法是一样的，功能都是在堆上申请释放空间，但是失败了的处理方式不一样，malloc失败返回NULL，operator new失败以后抛异常。
使用new为自定义类型ListNode申请空间并初始化：new会调用operator new函数和构造函数，operator new会调用malloc和失败抛异常机制，因此new和operator new申请失败都会抛异常：

从上图可以看出，new并不直接调用 malloc，而是调用了operator new，因为operator new被封装了，malloc申请失败直接报返回值，但operator new申请失败会抛异常

总结：
对于自定义类型来说：（只有自定义类型才有构造和析构，内置类型不存在的）
（1）new—>operator new<—>malloc+构造函数
（2）delete—>析构函数+operator delete<—>free 注意两者的顺序不同

3.总结

malloc/free和new/delete总结：
（1）malloc/free是函数，new/delete是操作符

（2）malloc申请的空间不会初始化，new可以初始化

（3）malloc申请的空间需要手动计算并传递过去，而new只需要在后面跟上空间类型即可。

（4）new不需要强转，而malloc需要

（5）malloc申请空间之后需要判断是否申请失败，new不需要，但是new需要捕获异常

（6）申请自定义类型对象时，malloc/free只会开辟空间，而new在申请空间 后会调用构造函数完成对象的初始化，delete在释放空间 前 会调用析构函数完成空间中资源的清理。

五、内存泄漏

1.定义：内存泄漏的概念：一块已经不用的空间，没有释放

2.危害：长期运行的程序出现内存泄漏，影响很大，如操作系统、后台服务等等，出现内存泄漏会 导致响应越来越慢，最终卡死。

3.有关内存泄漏的例题

class A
{
public:
	A()
	{
		cout << "A()" << endl;
	}
	~A()
	{
		cout << "~A()" << endl;
	}
};

int main()
{
	A* a = new A[5];

	//delete a;  内存泄漏，只释放了1次
	delete[] a;

	return 0;
}

关键点：（记住：一定要匹配使用，如若违背结果将不确定！）

new—>delete
new[ ] —>delete[ ]

---

好了，今天的分享就到这里了
如果对你有帮助，记得点赞👍+关注哦！
我的主页还有其他文章，欢迎学习指点。关注我，让我们一起学习，一起成长吧！