目录

new和delete

使用方法：

注意事项：

new申请不需要检查返回值

operator new和operator delete函数的讲解

c语言申请内存有哪些方法：

答：malloc  calloc realloc三种

#include
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(p3);
}

其中，malloc就是普通的动态内存申请

calloc相当于malloc加上memset把申请的空间全部初始化为0

realloc相当于内存扩容，分为异地扩容和原地扩容，当扩容的次数少，空间小时，会执行原地扩容，当扩容的次数多，空间大时，会执行异地扩容。

原地扩容和异地扩容的区别？

答：如上图代码所示，p2和p3指针指向同一块空间，而异地扩容则不然，异地扩容会先找一块新的空间，然后把原空间的内容拷贝到新空间位置，然后释放掉原空间，所以返回的就是p3.

new和delete

使用方法：

c++是通过什么申请内存的呢？

答：c++是通过两个关键字（操作符）来申请和释放空间的。

new和delete

int main()
{int *p1 = new int;delete p1;return 0;
}

相当于这里申请一个字节的空间，返回指向该空间的指针p1，然后delete表示释放空间。

注意：这里申请空间并不会对空间上的内容完成初始化：

例如：

 我们申请的空间并没有进行初始化。

我们如何申请空间的同时并初始化呢？

答：我们可以这样操作

例如：

int main()
{int *p1 = new int(0);delete p1;return 0;
}

 我们在后面加上0表示申请空间并把空间初始化为0.

我们如何申请多个空间呢？

答：

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

这里表示我们要申请十个整型空间，注意：我们在delete释放时，要和我们申请的空间进行一一对应。

 假如我们要对申请的多个空间进行初始化呢？

答：我们可以这样写：

int main()
{int *p1 = new int[10]{1, 2, 3, 4};delete[] p1;return 0;
}

这里表示我们对申请的十个空间中的前4个进行初始化：

 我们发现，对于内置类型，这里的new和delete和c语言的动态内存申请函数本质上没什么区别，那为什么++要定义这两个关键字呢？

答：对于内置类型，c语言和c++的动态内存申请本质是一样的，但是对于自定义类型，结果就不同了

例如：

我们写一个简单的类：

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

这个类中有两个成员函数，分别是构造函数和析构函数，函数的目的是当调用构造和析构函数，打印对应的提示并打印出this指针。

我们进行实验：

int main()
{/*int *p1 = new int[10]{1, 2, 3, 4};delete[] p1;return 0;*/A* p1 = new A;}

我们动态内存申请一个类的空间，返回指向该空间的指针p1

我们进行编译：

 这里表示我们的动态内存申请new调用了构造函数。

但是我们的malloc是不会调用构造函数的：

int main()
{/*int *p1 = new int[10]{1, 2, 3, 4};delete[] p1;return 0;*//*A* p1 = new A;*/A*p1 = (A*)malloc(sizeof(A));
}

我们进行编译：

 所以new相较于malloc对于自定义类型来说，new会调用自定义类型的构造函数，而malloc不会。

new会调用自定义类型的构造函数，那么delete是不是也会调用析构函数？

答：会：

int main()
{/*int *p1 = new int[10]{1, 2, 3, 4};delete[] p1;return 0;*/A* p1 = new A;/*A*p1 = (A*)malloc(sizeof(A));*/delete p1;
}

我们进行调用：

 所以delete也会调用自定义类型的析构函数。

我们举一个之前写的链表的例子：

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

我们现在可以这样写链表：

struct和class都是类关键字，struct当我们不处理时，类中的成员的默认用public修饰。

我们可以在类中写构造函数，相当于我们之前的创建新节点

int main()
{ListNode*n1 = new ListNode(1);ListNode*n2 = new ListNode(2);ListNode*n3 = new ListNode(3);ListNode*n4 = new ListNode(4);n1->_next = n2;
}

这样写链表就会方便很多。

注意事项：

注意：

new和delete一定要匹配，否则会产生意想不到的问题，我们就只举一个例子：

例如：

nt main()
{A*p1 = new A[10];delete p1;
}

我们写出这样的代码进行运行就会报错：

为什么会这样呢？

我们先写一个正常的进行分析：

int main()
{A*p1 = new A[10];delete[] p1;
}

我们的A的成员只有一个整型，所以A占四个字节的空间，十个A就占40个字节的空间。

 我们先进行编译：

 我们进行申请时或进行释放时，都会调用多次调用构造函数或析构函数。

我们在创建时，知道我们需要创建十个A类所占的空间

但是我们在析构的时候，并不清楚我们需要析构多少次，这时候，我们需要额外申请一个整型的空间：

 接下来，我们把p1往前置：

 这时候，我们就知道我们需要析构多少次，并且从这里可以把我们申请的空间全部释放。

我们返回来看之前报错的情况：

int main()
{A*p1 = new A[10];delete p1;
}

为什么会报错呢？

答： 因为我们释放没有写[]，所以我们构造了十次，但是我们不清楚析构了多少次，所以就会报错。

上面的这些都是关于编译器vs2013的一些情况，举这些例子只是为了说明一定要把申请的空间和delete释放的空间进行对应

new申请不需要检查返回值

我们知道malloc申请大的空间或者连续申请小的空间就会报错：

int main()
{while (1){int *p1 = (int*)malloc(1024 * 1024);if (p1){cout << p1 << endl;}else{cout << "申请失败" << endl;break;}}
}

并且我们知道，当malloc申请失败的时候，会返回空指针，所以我们可以写出以上代码来进行实验：

 申请多次的时候，报错

接下来，我们对new进行实验：

int main()
{while (1){int *p1 = new int[1024 * 1024];if (p1){cout << p1 << endl;}else{cout << "申请失败" << endl;break;}}
}

 运行很快就停止了，但是并没有打印出申请失败，说明我们new失败的返回值并不是0，或者说，new失败没有返回值。

new失败的话，就会抛异常，所以我们不需要对返回值进行检查，对于抛异常的问题，我们之后再进行详解。

operator new和operator delete函数的讲解

上述的两个函数是new和delete的底层实现：

 new的底层实现就是通过new调用operator new函数，operator函数中有malloc，调用完毕之后调用构造函数。

注意：operator new函数并不是new的重载。

operator new相当于是一个新的全局函数。

我们看一下operator函数的定义：

 我们可以发现，operator new函数就是malloc函数的封装，无非就是加上了当申请失败时，不反回，而是抛异常。

我们观察一下operator delete函数。

 相当于我们operator的主体部分也是调用了free函数。

我们是否可以使用operator new来申请空间呢？

答：可以：

例如：

int main()
{while (1){char*p1 = (char*)operator new(1024 * 1024 * 1024);cout << (void*)p1 << endl;}
}

operator new的使用方法和malloc相似。

不同点在于：operator new申请失败的话不需要报错，因为会抛异常。