一、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
二、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;
}
补充说明
- 动态开辟的空间位于堆区,由程序员进行申请和释放,但如果程序结束前,我们并没有使用free()函数释放,系统会自动进行释放;
- 使用free()函数释放p所指向的空间后,我们仍然要讲p赋值为NULL!
- 这是因为虽然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
特点
- 所申请空间连续;
- 释放空间简单;
- 思路最为简单,便于想我一样的小白理解;
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
特点
- 每一行元素所占空间连续,但行与行间并不连续;
- 释放步骤繁琐,易造成漏释放。
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
特点
- 所申请的空间全部连续;
- 释放空间简便。
参考资料:
c语言动态开辟数组(一维与二维)
动态申请数组(c)
关于c++的动态申请(持续更新)
C++基础:动态申请二维数组