C/C++动态开辟数组【C++：new/delete(推荐)：int *arr = new int[m]；】【C++：vector】【C：malloc() & free()】

- 日理万妓 2023-09-28 10:48 40阅读 0赞

## 一、C++的new/delete（推荐） ##

### 1、动态开辟一维数组 ###

#include<iostream>
    #include<stdio.h>
    
    using namespace std;
    
    int main() {
        
        int m = 3;
        int *arr = new int[m]; // m为大小
    
        // 控制台输入
        for (int i = 0; i < m; i++) {
        
            cin >> arr[i];
        }
    
        // 打印输出
        for (int i = 0; i < m; i++) {
        
            printf("打印输出：%d\n", arr[i]);
        }
    
        //空间释放：
        delete[] arr;
        arr = NULL;  //可在释放空间后将arr置为NULL，以防继续访问已被释放的空间。这句可以不要。
    
        return 0;
    }

打印结果：

3
    5
    6
    打印输出：3
    打印输出：5
    打印输出：6
    
    Process finished with exit code 0

### 2、动态开辟二维数组 ###

#include<iostream>
    
    using namespace std;
    
    int main() {
        
        int n = 2, m = 3;
        int **arr = new int *[n]; // 创建了一个包含2个整型指针的数组, 即确立了数组的行数
        // 为每一个指针指向的位置开辟3个整型空间, 即确立了数组的列数
        for (int i = 0; i < n; i++) {
        
            arr[i] = new int[m];
        }
    
        // 控制台输入
        for (int i = 0; i < n; i++) {
        
            for (int j = 0; j < m; j++) {
        
                cin >> arr[i][j];
            }
        }
    
        // 打印输出
        for (int i = 0; i < n; i++) {
        
            for (int j = 0; j < m; j++) {
        
                cout << arr[i][j] << ' ';
            }
            cout << endl;
        }
    
        //二维空间释放：
        for (int i = 0; i < n; i++) {
        
            delete[] arr[i];
        }
        delete[] arr;
        arr = NULL;  //可在释放空间后将arr置为NULL，以防继续访问已被释放的空间。这句可以不要。
    
        return 0;
    }

### 3、动态开辟数组、释放空间 ###

#### 3.1 动态开辟数组 ####

//一维数组动态申请，c数组大小为： n
    int *c=new int[n];
    
    //二维数组动态申请，b数组大小为： n*p
    int **b=new int*[n];
    for(int i=0;i<n;i++){
        
        b[i]=new int[p];
    }
    
    //三维数组动态申请, a数组大小为： m*n*p:
    int ***a = new int **[m];
    for (int i = 0; i < m; i++) {
        
        a[i] = new int *[n];
        for (int j = 0; j < n; j++) {
        
            a[i][j] = new int[p];
        }
    }

#### 3.2 释放空间 ####

当不再需要一个动态分配的多维数组时，可按以下步骤释放它所占用的空间。

*  首先释放在for循环中为每一行所分配的空间；
 *  然后释放为行指针分配的空间；

//一维空间释放：
        delete[] c;
        c = NULL;  //可在释放空间后将c置为NULL，以防继续访问已被释放的空间。这句可以不要。
    
    //二维空间释放：
        for (int i = 0; i < n; i++) {
        
            delete[] b[i];
        }
        delete[] b;
        b = NULL;  //可在释放空间后将b置为NULL，以防继续访问已被释放的空间。这句可以不要。
    
    //三维空间释放：
        for (int i = 0; i < m; i++) {
        
            for (j = 0; j < n; j++) {
        
                delete[] a[i][j];
            }
            delete[] a[i];
        }
        delete[] a;
        a = NULL;   //可在释放空间后将a置为NULL，以防继续访问已被释放的空间。这句可以不要。

#### 3.3 案例 ####

#include<iostream>
    #include<stdio.h>
    
    using namespace std;
    
    int main() {
        
        int *a;
        int *b;
        char *c;
        a = new int;//分配一个整形空间，若成功则a指向该空间，否则a为null
        b = new int(10);//分配一个整形空间且给这个整形空间附上初值10
        c = new char[10];//分配一个字符数组（字符串）空间，即c为字符串指针
    
        printf("a = %X, *a = %d\n", a, *a);
        printf("b = %X, *b = %d\n", b, *b);
        printf("c = %X, *c = %d\n", c, *c);
    
        delete a;//释放a所指的整形空间
        delete[]c;//释放c所指向的字符串空间，若不加【】则只是释放首地址的空间
        return 0;
    }

打印结果：

a = 99CA12A0, *a = -1714782304
    b = 99CA7FA0, *b = 10
    c = 99CA15E0, *c = -112
    
    Process finished with exit code 0

![在这里插入图片描述][afe6742ea88b4703901390e9ae1960e5.png_pic_center]  
![在这里插入图片描述][646accd8065740f78ef09336ac3f0d78.png_pic_center]  
![在这里插入图片描述][d2b5aa7bee3e4b2189d5090211b4f9ab.png_pic_center]  
![在这里插入图片描述][bc17c820ebc046feb685abddfbcb4870.png_pic_center]

## 二、C语言：malloc() & free() ##

C语言 中malloc（）函数的标准形式

void* malloc (size_t size);
    //size_t size 为所需要开辟的内存空间大小，单位为字节，常使用sizeof（）**关键字**获得

C++ 中free（）函数的标准形式

void free (void* ptr);
    //与malloc（），calloc（），realloc（）等函数搭配使用，参数为指向上述三函数使用时申请空间的指针

注意引用头文件stdlib.h

### 1、动态开辟一维数组 ###

#### 1.1 常见使用情况 ####

因为数组中必须为常量表达式，如果不是，则此时无法成功创建数组

#include<stdio.h>
    
    int main() {
        
        int input = 1;
        scanf("%d", &input);
        int arr[input] = {
        0}; //因为数组中必须为常量表达式, 所以此时无法成功创建数组
    
        return 0;
    }

这时便可以使用动态开辟的方法解决该问题。

#### 1.2 动态创建数组 ####

#include<stdio.h>
    #include <stdlib.h>
    
    int main() {
        
        int input = 0;
        scanf("%d", &input);
        int size_all = sizeof(int) * input;
        int *p = (int *) malloc(size_all); //在内存的动态存储区(堆区)中分配一块长度为size_all字节的连续区域，用来存放类型说明符指定的类型【注意对malloc()函数的返回值进行强制类型转换】
        for (int i = 0; i < input; i++) {
        
            scanf("%d", &p[i]);
        }
        for (int i = 0; i < input; i++) {
        
            printf("\n%d", p[i]);
        }
        free(p); //牢记malloc（）等函数与free（）函数搭配使用，有开辟就有释放
        p = NULL;
    
        return 0;
    }

补充说明

1.  动态开辟的空间位于堆区，由程序员进行申请和释放，但如果程序结束前，我们并没有使用free（）函数释放，系统会自动进行释放；
2.  使用free（）函数释放p所指向的空间后，我们仍然要讲p赋值为NULL！
3.  这是因为虽然p所指向的空间已被释放，但p指针仍然存在，为了防止接下来无意间引用了P指针造成错误，我们必须将其设为NULL。

### 2、动态开辟二维数组 ###

#### 2.1 使用创建一维数组的思想进行动态开辟 ####

#include<stdio.h>
    #include<stdlib.h>
    
    #define Row 2
    #define Column 3
    
    int main() {
        
        int *p = (int *) malloc(sizeof(int) * Row * Column);
        for (int i = 0; i < Row; i++) {
        
            for (int j = 0; j < Column; j++) {
        
                scanf("%d", &p[i * Row + j]); //注意下标访问符中的参数形式
            }
        }
        for (int i = 0; i < Row; i++) {
        
            for (int j = 0; j < Column; j++) {
        
                printf("\n所申请的地址：%d", &p[i * Row + j]); //注意下标访问符中的参数形式
            }
        }
        for (int i = 0; i < Row; i++) {
        
            for (int j = 0; j < Column; j++) {
        
                printf("\n输出：%d", p[i * Row + j]); //注意下标访问符中的参数形式
            }
        }
        free(p);
        p = NULL;
        return 0;
    }

打印结果：

6
    3
    9
    4
    1
    8
    
    所申请的地址：735804256
    所申请的地址：735804260
    所申请的地址：735804264
    所申请的地址：735804264
    所申请的地址：735804268
    所申请的地址：735804272
    输出：6
    输出：3
    输出：4
    输出：4
    输出：1
    输出：8
    Process finished with exit code 0

特点

1.  所申请空间连续；
2.  释放空间简单；
3.  思路最为简单，便于想我一样的小白理解；

#### 2.2 使用指针数组进行动态开辟 ####

#include<stdio.h>
    #include<stdlib.h>
    
    #define Row 2
    #define Column 3
    
    int main() {
        
        int i = 0, j = 0;
        int **p = (int **) malloc(sizeof(int *) * Row);
    
        //通俗的理解为创建了一个包含2个整型指针的数组, 即确立了数组的行数
        for (i = 0; i < Row; i++) {
        
            p[i] = (int *) malloc(sizeof(int) * Column);
        }
    
        //为每一个指针指向的位置开辟3个整型空间, 即确立了数组的列数
        for (i = 0; i < Row; i++) {
        
            for (j = 0; j < Column; j++) {
        
                scanf("%d", &p[i][j]);
            }
        }
    
        // 打印指针地址
        for (i = 0; i < Row; i++) {
        
            for (j = 0; j < Column; j++) {
        
                printf("\n所申请的地址：%d", &p[i][j]);
            }
        }
    
        // 打印
        for (i = 0; i < Row; i++) {
        
            for (j = 0; j < Column; j++) {
        
                printf("\n输出：%d", p[i][j]);
            }
        }
    
        //循环释放指向每一行数据的指针, 形式上类似于取二维数组的每一行的首地址时，arr【Row】
        for (i = 0; i < Row; i++) {
        
            free(p[i]);
            p[i] = NULL;
        }
        free(p); //释放指向储存有2个行指针的数组的指针
        p = NULL;
        return 0;
    }

打印结果：

9
    6
    5
    0
    2
    1
    
    所申请的地址：216431488
    所申请的地址：216431492
    所申请的地址：216431496
    所申请的地址：216431520
    所申请的地址：216431524
    所申请的地址：216431528
    输出：9
    输出：6
    输出：5
    输出：0
    输出：2
    输出：1
    Process finished with exit code 0

特点

1.  每一行元素所占空间连续，但行与行间并不连续；
2.  释放步骤繁琐，易造成漏释放。

#### 2.3 使用数组指针进行动态开辟 ####

#define _CRT_SECURE_NO_WARNINGS 1
    
    #include<stdio.h>
    #include<stdlib.h>
    
    #define Row 2
    #define Column 3
    
    int main() {
        
        int i = 0, j = 0;
        int(*p)[Column] = (int (*)[Column]) malloc(sizeof(int) * Row * Column); //一次性开辟所需的全部空间
    
        // 控制台输入元素
        for (i = 0; i < Row; i++) {
        
            for (j = 0; j < Column; j++) {
        
                scanf("%d", &p[i][j]);
            }
        }
    
        // 打印指针地址
        for (i = 0; i < Row; i++) {
        
            for (j = 0; j < Column; j++) {
        
                printf("\n所申请的地址：%d", &p[i][j]);
            }
        }
    
        // 打印
        for (i = 0; i < Row; i++) {
        
            for (j = 0; j < Column; j++) {
        
                printf("\n输出：%d", p[i][j]);
            }
        }
    
        free(p);
        p = NULL;
        return 0;
    }

打印结果：

5
    3
    8
    9
    1
    3
    
    所申请的地址：1626110816
    所申请的地址：1626110820
    所申请的地址：1626110824
    所申请的地址：1626110828
    所申请的地址：1626110832
    所申请的地址：1626110836
    输出：5
    输出：3
    输出：8
    输出：9
    输出：1
    输出：3
    Process finished with exit code 0

特点

1.  所申请的空间全部连续；
2.  释放空间简便。

--------------------

参考资料：  
[c语言动态开辟数组（一维与二维）][c]  
[动态申请数组（c）][c 1]  
[关于c++的动态申请（持续更新）][c 2]  
[C++基础：动态申请二维数组][C]

[afe6742ea88b4703901390e9ae1960e5.png_pic_center]: https://img-blog.csdnimg.cn/afe6742ea88b4703901390e9ae1960e5.png#pic_center
[646accd8065740f78ef09336ac3f0d78.png_pic_center]: https://img-blog.csdnimg.cn/646accd8065740f78ef09336ac3f0d78.png#pic_center
[d2b5aa7bee3e4b2189d5090211b4f9ab.png_pic_center]: https://img-blog.csdnimg.cn/d2b5aa7bee3e4b2189d5090211b4f9ab.png#pic_center
[bc17c820ebc046feb685abddfbcb4870.png_pic_center]: https://img-blog.csdnimg.cn/bc17c820ebc046feb685abddfbcb4870.png#pic_center
[c]: https://blog.csdn.net/AZ10000000/article/details/123823047
[c 1]: https://blog.csdn.net/weixin_51159944/article/details/122121313
[c 2]: https://blog.csdn.net/secant007/article/details/114849338
[C]: https://www.freesion.com/article/60481000547/