内存的静态分配和动态分配的区别主要是 两个：

一是时间不同。静态分配发生在程序编译和连接的时候。动态分配则发生在程序调入和执行的时候。

二是空间不同。堆都是动态分配的，没有静态分配的堆。栈有2种分配方式：静态分配和动态分配。静态分配是编译器完成的，比如局部变量的分配。动态分配由函数malloc进行分配。不过栈的动态分配和堆不同，他的动态分配是由编译器进行释放，无需我们手工实现。

C/C++内存分布

栈区：就是那些由编译器在需要的时候分配，在不需要的时候自动清除的变量的存储区。函数调用建立栈帧，参数、函数中局部变量都存在栈帧中，栈是向下增长的，向下增长的意思是：从栈申请的内存地址会越来越小，在栈区当中是先使用高地址再使用低地址：

void f()
{
    int b = 0;
    cout << &b << endl;
}
int main( )
{
    int a = 0;
    cout << &a << endl;
    f();
    return 0;
}

可以看到先使用高地址再使用低地址。

堆区：

一般由程序员分配释放，若程序员不释放，程序结束时可能由OS回收。理论上而言，后malloc的内存地址比先malloc的要大，但是也不一定，但是不一定，因为有可能下一次申请的是之前其他空间释放回来的。

数据段(全局数据，静态数据)：

全局变量和静态变量被分配到同一块内存中，在以前的C语言中，全局变量又分为初始化的(DATA段)和未初始化的(BSS段)，在C++里面没有这个区分了，它们共同占用同一块内存区。

代码段：

可执行代码其实就是二进制指令，这里是存放二进制代码的。通常是指用来存放程序执行代码的一块内存区域。这部分区域的大小在程序运行前就已经确定，并且内存区域通常属于只读, 某些架构也允许代码段为可写，即允许修改程序。 在代码段中，也有可能包含一些只读的常数变量，例如字符串常量等。

内核空间：

是给操作系统用的

这几个区域划分的特点：

1、这几个区域中堆是很大的，比如有32位-4G空间，内核空间占用1G，而堆差不多就占用了快3G

2、实际上，栈是很小的，Linux下一般只有8M，所以递归调用深度太深会导致栈溢出

3、数据段和代码段也不是很大，因为没有多少数据

下面我们来看一下下面代码的数据是分别存储在哪里的？

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

数据段 数据段 数据段 栈区 栈区 栈区 栈区 栈区 代码段 栈区 堆区

1、选择题
选项: A.栈 B.堆 C.数据段 D.代码段
globalVar在哪里？____ staticGlobalVar在哪里？____
staticVar在哪里？____ localVar在哪里？____
num1 在哪里？____
char2在哪里？____ *char2在哪里？___
pChar3在哪里？____ *pChar3在哪里？____
ptr1在哪里？____ *ptr1在哪里？____

globalVar在哪里？

globalVar是全局变量所以它在数据段

staticGlobalVar在哪里？

staticGlobalVar是静态变量所以它在数据段

staticVar在哪里？

staticVar是静态变量所以它在数据段

localVar在哪里？

localVar创建在test函数栈帧中，它是局部变量，在栈区

num1 在哪里？

num1是数组，在函数栈帧中创建，存储在栈区

char2在哪里？

char2是数组，在函数栈帧中创建，存储在栈区

/*char2在哪里？

**/char2拿到的是字符a的地址，因为char2是数组，里面的元素也是存储在栈帧里面的，所以/char2也在栈区

pchar3在哪里？

pchar3是指针变量，存储在栈区，它指向字符串的首字符地址

/*pchar3在哪里？

/*pchar3是常量字符a，常量字符串是存储在常量区的，就是在代码段

ptr1在哪里？

ptr1是指针变量，他存储在栈区

/*ptr1在哪里？

*ptr1指向的内存空间是malloc出来的，所以/ptr1是在堆区

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

void Test ()
{
    int* p1 = (int*) malloc(sizeof(int));
    free(p1);
    // 1.malloc/calloc/realloc的区别是什么？
    int* p2 = (int*)calloc(4, sizeof (int));
    int* p3 = (int*)realloc(p2, sizeof(int)*10);
    // 这里需要free(p2)吗？
    free(p3);
}

calloc等价于malloc+memest(0)，开空间+初始化为0

realloc是对malloc或calloc的空间进行扩容

C兼容C，c语言这一套动态内存申请与释放在C中都可以用

C++中动态内存管理

C语言内存管理方式在C中可以继续使用，但有些地方就无能为力而且使用起来比较麻烦，因此C又提出了自己的内存管理方式：通过new和delete操作符进行动态内存管理。

注意：

malloc/free是库函数，而new/delete是操作符

void Test()
{
    //C语言 malloc等是库函数
    int* p1 = (int*)malloc(sizeof(int));
    free(p1);
    
    //C++ new/delete是操作符
    // 动态申请一个int类型的空间
    int* ptr4 = new int;
    // 动态申请一个int类型的空间并初始化为10
    int* ptr5 = new int(10);
    delete ptr4;
    delete ptr5;
}

这里new/delete和malloc/free有没有什么区别呢？

如果动态申请的对象是内置类型，用malloc和new没有区别，如果动态申请的对象是自定义类型，有区别，例如：

class A
{
public:
    A(int a=0)
        :_a(a)
    {
        cout<<"A()"<<endl;
    }
    ~A()
    {
        cout<<"~A()"<<endl;
    }
private:
    int _a;
};
int main()
{   
    //C语言自定义类型开辟空间
    A* p3 = (A*)malloc(sizeof(A));//没有初始化
    free(p3);
    
    //C++自定义类型开辟空间
    A* p4 = new A;//调用构造函数初始化
    delete p4;//调用析构函数
    
}

new和delete不仅仅会开空间/释放空间，还会调用构造函数和析构函数

使用malloc没有初始化：

使用new进行了初始化：

这里其实是调用默认的构造函数进行了初始化，并且delete时调用了析构函数：

那我们想给new的对象传参怎么写呢？这样写：

A* p4 = new A(10);//调用构造函数初始化

我们还可以new数组：

int *ptr = new int[10];
delete[] ptr;

A *ptr1 = new A[10];//new了10个对象，调用了10次构造函数
delete[] ptr1;

注意在new数组时，delete时需要加[]

对于内置类型用malloc和new没什么区别，但是自定义类型，用malloc和new有区别，new和delete还会调用构造函数和析构函数，一定要匹配使用，否则可能会崩溃，在C++中，建议使用new和delete，malloc和free能做到的，new和delete都能做到，new和delete能做到的，malloc和free不一定能做到，并且new和delete更方便一些，为什么使用new和delete更方便呢？例如我们在写链表时：

struct ListNode
{
    int _val;
    ListNode* _next;
    
    ListNode(int val):_val(val),_next(nullptr)
    {}
};

用C创建节点并初始化它：

//C
ListNode* n1 = (ListNode*)malloc(sizeof(ListNode));
n1->val = 1;
n1->next = nullptr;

用C++创建节点并初始化它：

//C++
ListNode* n2 = new ListNode(1);//一次性完成了开辟空间和初始化

C++一次性就完成了开辟空间和初始化，所以new和delete更方便。

接下来我们来看一下new和delete到底时怎么样的原理：

operator new与operator delete函数

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

注意：

它们两个只是全局的库函数，它们并不是new和delete的重载

我们在new一个对象T时，其实编译器会这样做：

1、申请内存，调用operator new(底层其实是将malloc的封装实现)

2、调用构造函数

在delete时，编译器会这么做：

1、调用T的析构函数

2、调用operator delete(底层其实是将free的封装实现)

我们之前在使用malloc时，malloc失败会返回NULL：

int main()
{
    //malloc失败，返回NULL
    char* p1 = (char*)malloc((size_t)2*1024*1024*1024);
    if(p1==NULL)
    {
        printf("malloc fail\n");
    }
    else
    {
        printf("malloc success\n");
        
    }
   
    return 0;
}

那么new操作符在new失败时会做什么处理呢？

int main()
{
    char* p2 = new char[0x7fffffff];
    //并没有执行
    if(p2==NULL)
    {
        printf("new fail\n");
    }
    else
    {
        printf("new success\n");
        
    }
    return 0;
}

我们可以看到new失败时，并没有执行if语句就出错了，为什么呢？是因为new和malloc不一样，申请空间失败了，它会抛异常，下面我们用一段捕获异常的代码来说明：

int main()
{
    //new和malloc不一样，申请空间失败了，会抛异常
    try
    {
    	char* p2 = new char[0x7fffffff];//如果出错抛异常，跳到捕获异常的位置，没有捕获会报错 
    }
    catch(const exception& e)
    {
        cout<<e.what()<<endl;
    }
}

operator new其实就是对malloc的封装，如果申请内存失败了，抛异常，封装malloc+抛异常，我们进行调试反汇编可以看到执行new时，他要调用operator new函数和A的构造函数：

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

我们也可以直接用operator new和operator delete函数：

int* p3 = (int*)operator new(sizeof(int)*10);
operator delete(p3);

operator new与operator delete的类专属重载

假设我们写了一个链表的程序，怎么检测一下有没有ListNode的节点没有释放？

我们可以重载一个类ListNode专属的operator new和operator delete成员函数

我们在new一个ListNode时，那么申请空间就会调用专属的operator new，delete时，释放空间调用专属的operator delete，我们可以定义一个静态变量_count来记录，申请时_count++，释放_count–：

struct ListNode
{
	int val;
	struct ListNode* next;

	static int _count;

	ListNode(int x)
		:val(x)
		, next(nullptr)
	{
		cout << "ListNode()" << endl;
	}

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

	void* operator new(size_t n)
	{
		++_count;
		return ::operator new(n);
		// 去内存池
	}

	void operator delete(void* p)
	{
		--_count;
		return ::operator delete(p);
		// 释放去内存池
	}
};

int ListNode::_count = 0;
struct ListNode* removeElements(struct ListNode* head, int val) 
{
	struct ListNode* prev = NULL, *cur = head;
	while (cur)
	{
		if (cur->val == val)
		{
			// 1、头删
			// 2、中间删除
			prev->next = cur->next;
			delete cur;
			cur = prev->next;
		}
		else
		{
			// 迭代往后走
			prev = cur;
			cur = cur->next;
		}
	}
	return head;
}

// 检测一下有没有ListNode的节点没有释放
int main()
{
	ListNode* n1 = new ListNode(1);
	ListNode* n2 = new ListNode(2);
	ListNode* n3 = new ListNode(2);
	ListNode* n4 = new ListNode(3);
	ListNode* n5 = new ListNode(4);
	ListNode* n6 = new ListNode(2);
	n1->next = n2;
	n2->next = n3;
	n3->next = n4;
	n4->next = n5;
	n5->next = n6;
	n6->next = nullptr;

	ListNode* list = removeElements(n1, 2);

	cout <<"没有释放节点数量：" <<ListNode::_count << endl;

	return 0;
}

这个在实际中并不常用，了解一下即可。

new和delete的实现原理

内置类型

如果申请的是内置类型的空间，new和malloc，delete和free基本类似，不同的地方是：new/delete申请和释放的是单个元素的空间，new[]和delete[]申请的是连续空间，而且new在申请空间失败时会抛异常，malloc会返回NULL。

自定义类型

• new的原理

1. 调用operator new函数申请空间
2. 在申请的空间上执行构造函数，完成对象的构造

• delete的原理

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

• new T[N]的原理

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

• delete[]的原理

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

int main()
{
    Stack st;
    Stack* ps = new Stack;
    delete ps;
    retunr 0;
}

直接创建对象和new对象有什么区别呢？下面我们画图讲解：

定位new表达式(placement-new)

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

使用格式：
new (place_address) type或者new (place_address) type(initializer-list)
place_address必须是一个指针，initializer-list是类型的初始化列表
使用场景：
定位new表达式在实际中一般是配合内存池使用。因为内存池分配出的内存没有初始化，所以如果是自定义类型的对象，需要使用new的定义表达式进行显示调构造函数进行初始化。

构造函数调用什么时候自动调用呢？

1、创建对象时

2、new一个对象时

//显式对一块空间调用构造函数初始化
class Test
{
public:
    Test()
    : _data(0)
    {
        cout<<"Test():"<<this<<endl;
    }
    ~Test()
    {
        cout<<"~Test():"<<this<<endl;
    }
private:
	int _data;
};
void Test()
{
    // pt现在指向的只不过是与Test对象相同大小的一段空间，还不能算是一个对象，因为构造函数没有执行
    Test* pt = (Test*)malloc(sizeof(Test));
    new(pt) Test; // 注意：如果Test类的构造函数有参数时，此处需要传参
}

pt现在指向的只不过是与Test对象相同大小的一段空间，还不能算是一个对象，因为构造函数没有执行，显式对一块空间调用构造函数初始化，new(pt) Test;

如果我们复制一份a数组到另外一块空间b数组，怎么复制呢？

也许你想的是这样，通过一个循环来拷贝：

int main()
{
    A a[5];
    //复制一份a数组到另外一块空间b
    A* pb1 = new A[5];
    for(int i =0;i<5;++i)
    {
        b[i]=a[i];
    }
    cout<<endl;
    //代价大 构造+赋值 
    return 0;
}

但是这样代价大，经过了构造+赋值重载，那么能不能直接构造呢？通过定位new表达式就可以直接构造：

int main()
{
    A a[5];
    //能不能直接构造？
    A *pb = (A*)malloc(sizeof(A)*5);
    for(int i =0;i<5;++i)
    {
        new(pb+i)A(a[i]);
    }//只有构造
    return 0;
}

常见面试题

malloc/free和new/delete的区别

1、特点和用法
malloc和free是函数，new和delete是操作符；malloc申请空间时，需要手动计算空间大小并传递，new只需在后面跟上空间的类型即可，如果是多个对象，[]中指定对象个数即可；malloc的返回值是void/*，在使用时需要强转，new不需要，因为new后面跟的是空间的类型

2、底层原理区别

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

3、处理错误的方式

malloc申请空间失败时，返回NULL，因为使用时需要判空，new不需要，但是new需要捕获异常

内存泄漏

什么是内存泄漏呢？

在堆上申请了的空间，在我们不用了以后也没有释放，就存在内存泄漏，因为你不用了，也没有还给系统，别人也用不了。俗话说：占着茅坑不拉屎

int main()
{
    char* p = new char[1024*1024*1024];
    return 0;
}

运行结束后：

上面程序存在内存泄漏，一次泄漏1G，但是程序运行结束后，对我们系统也好像没有影响，好像会将我们申请的内存自动还回去，实际上一个进程正常结束后，会把映射的内存都会释放掉，所以上面的程序，我们没有主动释放，但是进程结束也释放，那么内存泄漏好像也没啥事，因为进程正常结束都会释放。

其实并不是，你在看看下面的场景：

1、要是进程没有正常结束呢！僵尸进程，就可能存在一些资源没有释放

2、长期运行的服务器程序。比如王者荣耀后台服务，长期运行，只有维护升级的时候才会停，内存泄漏会导致可用内存越来越少，程序越来越慢，甚至挂掉。事故

3、物联网设备：扫地机器人、冰箱等等，内存很小，也会经不起内存泄漏折腾

在C++中我们需要主动释放内存，而Java不需要主动释放内存，Java后台有垃圾回收器，接管了内存释放

那么我们如何预防内存泄漏呢？

1、智能指针

2、内存泄漏的检测工具

如何申请4G的内存呢？将操作系统换为64位就可以了：

int main()
{
	try
	{
		char* p = new char[0x7fffffff];
		//char* p = new char[0xffffffff];
		printf("%p\n", p);
	}
	catch (const exception& e)
	{
		cout << "内存申请失败" << endl;
	}

	return 0;
}

我们在32位的操作系统上申请，会申请失败：

将他改为64位就能申请成功：

可以看到申请成功了

欢迎大家学习交流！