动态内存管理

malloc函数

void* malloc (size_t size); malloc和free都声明在 stdlib.h 头文件
向内存申请一块连续可用的空间，并返回这块空间的指针

• 如果开辟成功，则返回一个指向开辟好空间的指针。
• 如果开辟失败，则返回一个NULL指针，因此malloc的返回值一定要做检查。
• 返回值的类型是 void* ，所以malloc函数并不知道开辟空间的类型，具体在使用的时候使用者自己来决定。

#include <stdio.h>
int main()
{
 int* ptr = NULL;
 ptr = (int*)malloc(num*sizeof(int));
 if(NULL != ptr)//判断ptr指针是否为空
 {
 int i = 0;
 for(i=0; i<num; i++)
 {
 *(ptr+i) = 0；
 }
 }
 free(ptr);//释放ptr所指向的动态内存
 ptr = NULL;
 return 0;
}

calloc

void* calloc (size_t num, size_t size);
函数的功能是为 num 个大小为 size 的元素开辟一块空间，并且把空间的每个字节初始化为0。与函数 malloc 的区别只在于 calloc 会在返回地址之前把申请的空间的每个字节初始化为全0。

#include <stdio.h>
#include <stdlib.h>
int main()
{
 int *p = (int*)calloc(10, sizeof(int));
 if(NULL != p)
 {
 printf("创建成功");
 }
 free(p);
 p = NULL;
 return 0;
}

realloc

void* realloc (void* ptr,sizr_t size);
ptr 是要调整的内存地 size 调整之后新大小 返回值为调整之后的内存起始位置。
这个函数调整原内存空间大小的基础上，还会将原来内存中的数据移动到 新 的空间。
realloc在调整内存空间的是存在两种情况：
情况1：原有空间之后有足够大的空间
情况2：原有空间之后没有足够大的空间

#include <stdio.h>
int main()
{
 int *ptr = (int*)malloc(100);
 if(ptr != NULL)
 {
     //业务处理
 }
 else
 {
     exit(EXIT_FAILURE);    
 }
 //扩展容量
 //代码1
 ptr = (int*)realloc(ptr, 1000);//这样可以吗？(如果申请失败会如何？)
 
 //代码2
 int*p = NULL;
 p = realloc(ptr, 1000);
 if(p != NULL)
 {
 ptr = p;
 }
 //业务处理
 free(ptr);
 return 0;
}

常见的动态内存错误

1.对NULL指针的解引用操作

void test()
{
 int *p = (int *)malloc(INT_MAX/4);
 *p = 20;//如果p的值是NULL，就会有问题
 free(p);
}

2.对动态开辟空间的越界访问

void test()
{
 int i = 0;
 int *p = (int *)malloc(10*sizeof(int));
 if(NULL == p)
 {
 exit(EXIT_FAILURE);
 }
 for(i=0; i<=10; i++)
 {
 *(p+i) = i;//当i是10的时候越界访问
 }
 free(p);
}

3.对非动态开辟内存使用free释放

void test()
{
 int a = 10;
 int *p = &a;
 free(p);//ok?
}

4.使用free释放一块动态开辟内存的一部分

void test()
{
 int *p = (int *)malloc(100);
 p++;
 free(p);//p不再指向动态内存的起始位置
}

5.对同一块动态内存多次释放

void test()
{
 int *p = (int *)malloc(100);
 free(p);
 free(p);//重复释放
}

6.动态开辟内存忘记释放（内存泄漏）
忘记释放不再使用的动态开辟的空间会造成内存泄漏

void test()
{
 int *p = (int *)malloc(100);
 if(NULL != p)
 {
 *p = 20;
 }
}
int main()
{
 test();
 while(1);
}

C++内存分配开辟

C++中的内存分为四个区域：栈（stack）、堆（heap）、全局/静态存储区（global/static storage）、常量存储区（constant storage）。下面对这四个区域进行简要的介绍：

1. 栈（stack）
   栈是一种自动分配和释放的内存空间，其大小有限制，由编译器在编译时自动分配和管理。栈中的内存空间主要用于存储函数的局部变量、函数参数等。当函数执行结束时，栈上的内存会自动被释放。

2. 堆（heap）
   堆是由程序员分配和释放的内存空间，其大小没有限制。在堆中分配内存需要使用特定的语句（如 new 和
   malloc），并在使用结束后手动释放（如 delete 和free）。由于堆的管理需要由程序员来进行，因此在堆中分配的内存空间需要程序员手动释放，否则会出现内存泄漏等问题。

3. 全局/静态存储区（global/static storage）
   全局/静态存储区主要用于存储全局变量和静态变量，在程序运行期间一直存在。全局变量在程序启动时就被分配好内存空间，静态变量在第一次使用时被分配内存空间，且在程序运行期间一直占用该内存空间。

4. 常量存储区（constant storage）
   常量存储区用于存储常量，如字符串常量等，其大小也是固定的。常量存储区的内存由编译器分配和管理，其内容在程序运行期间不可修改。

柔性数组

C99 中，结构中的最后一个元素允许是未知大小的数组，这就叫做『柔性数组』成员。

typedef struct st_type
{
 int i;
 int a[];//柔性数组成员
}type_a;

柔性数组的特点：
1.结构中的柔性数组成员前面必须至少一个其他成员。
2.sizeof 返回的这种结构大小不包括柔性数组的内存。
3.包含柔性数组成员的结构用malloc ()函数进行内存的动态分配，并且分配的内存应该大于结构的大小，以适应柔性数组的预期大小。

C++内存管理方式

new/delete操作内置类型

通过new和delete操作符进行动态内存管理。

void Test()
{
  // 动态申请一个int类型的空间
  int* ptr4 = new int;
  
  // 动态申请一个int类型的空间并初始化为10
  int* ptr5 = new int(10);
  
  // 动态申请3个int类型的空间
  int* ptr6 = new int[3];
  
  delete ptr4;
  delete ptr5;
  delete[] ptr6;
}

new/delete操作自定义类型

在申请自定义类型的空间时，new会调用构造函数，delete会调用析构函数，而malloc与
free不会。

class A
{
public:
 A(int a = 0)
 : _a(a)
 {
 cout << "A():" << this << endl;
//注意：在申请自定义类型的空间时，new会调用构造函数，delete会调用析构函数，而malloc与
//free不会。
//4. operator new与operator delete函数（重要点进行讲解）
//4.1 operator new与operator delete函数（重点）
//new和delete是用户进行动态内存申请和释放的操作符，operator new 和operator delete是
//系统提供的全局函数，new在底层调用operator new全局函数来申请空间，delete在底层通过
//operator delete全局函数来释放空间。
 }
 ~A()
 {
 cout << "~A():" << this << endl;
 }
private:
 int _a;
};
int main()
{
 // new/delete 和 malloc/free最大区别是 new/delete对于【自定义类型】除了开空间
//还会调用构造函数和析构函数
 A* p1 = (A*)malloc(sizeof(A));
 A* p2 = new A(1);
 free(p1);
 delete p2;
 // 内置类型是几乎是一样的
 int* p3 = (int*)malloc(sizeof(int)); // C
 int* p4 = new int;
free(p3);
delete p4;
 A* p5 = (A*)malloc(sizeof(A)*10);
 A* p6 = new A[10];
 free(p5);
 delete[] p6;
 return 0;
}

定位new表达式(placement-new) （了解）

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

placement new是一种C++中的内存分配方式，它允许程序员在已有的内存上创建对象，而不是从堆或栈中分配新内存。这在某些场景下很有用，例如在嵌入式系统中的硬件寄存器上创建对象。

下面是一个使用定位new表达式的例子：

#include <iostream>

class MyClass {
public:
    MyClass(int a, int b) : x(a), y(b) {}
    void print() { std::cout << "x=" << x << ", y=" << y << std::endl; }

private:
    int x;
    int y;
};

int main() {
    char buffer[sizeof(MyClass)];
    MyClass* obj = new (buffer) MyClass(1, 2);
    obj->print();
    obj->~MyClass(); // 需要手动调用析构函数
    return 0;
}

这个程序创建了一个MyClass类型的对象，但是并没有从堆或栈中分配新内存。相反，程序在一个已经分配好的char数组上创建了这个对象，这个数组的大小正好可以容纳MyClass对象。这样做的好处是可以在自己分配的内存上控制对象的生命周期，手动调用析构函数和释放内存。

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在释放空间前会调用析构函数完成
   空间中资源的清理

什么是内存泄漏，内存泄漏的危害

什么是内存泄漏：内存泄漏指因为疏忽或错误造成程序未能释放已经不再使用的内存的情况。内
存泄漏并不是指内存在物理上的消失，而是应用程序分配某段内存后，因为设计错误，失去了对
该段内存的控制，因而造成了内存的浪费。
内存泄漏的危害：长期运行的程序出现内存泄漏，影响很大，如操作系统、后台服务等等，出现
内存泄漏会导致响应越来越慢，最终卡死。

内存泄漏分类（了解）

C/C++程序中一般我们关心两种方面的内存泄漏：

堆内存泄漏(Heap leak)

堆内存指的是程序执行中依据须要分配通过malloc / calloc / realloc / new等从堆中分配的一
块内存，用完后必须通过调用相应的 free或者delete 删掉。假设程序的设计错误导致这部分
内存没有被释放，那么以后这部分空间将无法再被使用，就会产生Heap Leak。

系统资源泄漏

指程序使用系统分配的资源，比方套接字、文件描述符、管道等没有使用对应的函数释放
掉，导致系统资源的浪费，严重可导致系统效能减少，系统执行不稳定。

如何避免内存泄漏

1. 工程前期良好的设计规范，养成良好的编码规范，申请的内存空间记着匹配的去释放。ps：
   这个理想状态。但是如果碰上异常时，就算注意释放了，还是可能会出问题。需要下一条智
   能指针来管理才有保证。
2. 采用RAII思想或者智能指针来管理资源。
3. 有些公司内部规范使用内部实现的私有内存管理库。这套库自带内存泄漏检测的功能选项。
4. 出问题了使用内存泄漏工具检测。ps：不过很多工具都不够靠谱，或者收费昂贵。
   总结一下:
   内存泄漏非常常见，解决方案分为两种：1、事前预防型。如智能指针等。2、事后查错型。如泄
   漏检测工具。