C++ 指针进阶：动态分配内存

C++ 动态实例化（new 和 malloc)

malloc 是 stdlib.h 库中的函数，声明为 void *__cdecl malloc(size_t _Size);

原理：

malloc 函数沿空闲链表（位于内存 堆空间 中）申请一块满足需求的内存块，将所需大小的内存块分配给用户剩下的返回到链表上；

并返回指向该内存区的首地址的指针，意该指针的类型为 void *，因此我们需要强制转换指针类型；
参数：_Size 为要申请的空间大小，即需要显式填入申请内存的大小，如 n * sizeof(int)；
返回值：malloc 分配内存失败时返回 NULL 指针，可以通过返回值判断是否分配成功；
malloc 并不会初始化所申请的空间；

free 也是 stdlib.h 库中的函数，声明为 void __cdecl free(void *_Memory);

size_t element_cnt = 10;
int *arr = (int *)malloc(element_cnt * sizeof(int));
free(arr)

size_t m = 10, n = 10;
int **arr = (int **)malloc(m * sizeof(int *));
for (int i = 0; i < m; i ++)
    arr[i] = (int *)malloc(n * sizeof(int));

需要注意，这样获得的二维数组，不能保证其空间是连续的。

calloc 定义在 stdlib.h 库中，声明为 void *__cdecl calloc(size_t _NumOfElements,size_t _SizeOfElements);

calloc 与 malloc 的主要区别有：

realloc 定义在 stdlib.h 库中，声明为 void *__cdecl realloc(void *_Memory,size_t _NewSize);，用于对动态内容进行扩容

参数：

_Memory 为指向原来空间的指针；

_NewSize 为扩容后空间大小
返回值：

如果 _Memory 后有足够的连续空间，则扩大 _Memory 指向的地址，并返回 _Memory；

如果空间不够，则按照 _NewSize 分配空间，拷贝原有数据到新分配的内存空间，并释放 _Memory 所指的内存区（自动释放，不需要 free），同时返回新分配的内存区域的首地址；
分配失败时返回空指针 NULL；
若 _NewSize 小于原大小，原数据末尾可能会丢失；

new 和 delete 是 C++ 中的关键字，若要使用，需要编译器支持。

返回值：

内存分配成功时，new 返回对象类型的指针，类型严格与对象匹配；

new 内存分配失败时，会抛出 bac_alloc 异常，如果不捕捉异常，那么程序就会异常退出；
new 无需显式填入申请的内存大小，new 会根据 new 的类型分配内存；
new 分配的内存空间在自由存储区；
new 和 delete 支持重载；
不能对一块内存释放两次或以上；

对空指针 nullptr 使用 delete 操作是合法的；

// 动态创建变量
int *p = new int(1234);
/* ... */
delete p;

new 动态创建对象时会经历三个步骤：

delete 释放对象内存时会经历两个步骤：

// 开辟新的对象
class A {
    int a;
public:
    A(int a_) : a(a_) {}
};

int main() {
    A *p = new A(1234);
    /* ... */
    delete p;
}

{} 运算符可以用来初始化没有构造函数的结构。初次以外，使用 {} 运算符可以使得变量的初始化形式变得同意。

struct ThreeInt {
  int a;
  int b;
  int c;
};

int main() {
  ThreeInt* p = new ThreeInt{1, 2, 3};
  /* ... */
  delete p;
}

创建和释放数组需要使用 new[] 和 delete[]，new[] 运算符会返回数组的首地址。

size_t element_cnt = 5;
int *p = new int[element_cnt];
/* ... */
delete[] p;

动态创建二维数组有以下三种方式：

声明一个长度为 N * M 的一维数组，通过下标 r * M + c 访问二维数组中小标为 (r, c) 的元素：
```
int *arr = new int[N * M];
```
这种方法可以保证二维数组的物理空间是 连续的。
通过变量存储 数组的数组 的首地址——指向一个一维数组的指针的地址。这个变量即 二重指针：
```
int **arr = new int*[M];
for (int i = 0; i < M; i ++)
    a[i] = new int[N];
```
需要注意，这样获得的二维数组，不能保证其空间是连续的。

对于这样获得的内存的释放，需要进行一个逆向操作：想释放每一个一维数组，再释放存储一维数组首地址的地址：
```
for (int i = 0; i < M; i ++)
    delete[] arr[i];
delete[] arr;
```
第三种方法用到 指向数组的指针：
```
int (*arr)[N] = new int[M][N];
/* ... */
delete[] arr;
```
这种方式得到的也是连续的内存，但与第一种方式相比，可以直接使用 arr[n] 的形式得到数组第 n + 1 行的首地址，使用 arr[r][c] 的形式访问到下标为 (r, c) 的元素。

由于指向数组的指针也是一种确定的数据类型，因此除数组的第一维外，其他维度的长度均须为一个能在编译器确定的常量。