C/C++动态数组使用

近来刷题，遇到好几道题目需要动态数组解决，现在整理一下。C/C++中动态开辟一维、二维数组很常见，也很实用。

2021/3/18 更

C中动态数组的使用

C语言使用calloc()函数/malloc()函数分配内存空间，均可用来动态申请一维数组/二维数组。

头文件：#include<stdlib.h>

calloc()函数用来动态的分配内存空间并初始化为0，其原型为：

1	void * calloc(size_t num, size_t size);

calloc() 在内存中动态地分配 num 个长度为 size 的连续空间，并将每一个字节都初始化为 0。所以它的结果是分配了 num*size 个字节长度的内存空间，并且每个字节的值都是0。

【返回值】分配成功返回指向该内存的地址，失败则返回 NULL。

注意：函数的返回值类型是 void *，void 并不是说没有返回值或者返回空指针，而是返回的指针类型未知。所以在使用 calloc() 时通常需要进行强制类型转换，将 void 指针转换成我们希望的类型，例如：

1	char ptr = (char )calloc(10, 10); // 分配100个字节的内存空间

malloc()函数动态分配内存空间，不做初始化，其原型为：

1	void * malloc(size_t size);

【返回值】分配成功返回指向该内存的地址，失败则返回 NULL。

使用示例：

/*申请一个动态数组 存储图像矩阵*/
    char **bufarray;
    bufarray = (char**)malloc(sizeof(char*) * infoHeader->biHeight); // 分配所有行的首地址
    for (i = 0; i < infoHeader->biHeight; i++) { // 按行分配每一列
        bufarray[i] = (char*)malloc(sizeof(char) * infoHeader->biWidth);
    }

// 释放开辟的二维数组空间
    for (i = 0; i < infoHeader->biWidth; ++i)
    {
        free(*(bufarray + i));
    }

/*申请一个动态数组 存储去除白边后的GM码图片矩阵*/
    char** imgarray;
    imgarray = (char**)calloc(macroblock_num * macroblock_len, sizeof(char*)); // 分配所有行的首地址
    for (i = 0; i < macroblock_num * macroblock_len; i++) { // 按行分配每一列
        imgarray[i] = (char*)calloc(macroblock_num * macroblock_len, sizeof(char));
    }

// 释放开辟的二维数组空间
    for (i = 0; i < macroblock_num * macroblock_len; ++i)
    {
        free(*(imgarray + i));
    }

1
2
3

// 申请一个动态一维数组
char* data_stream;
data_stream = (char*)calloc(data_correct_num * 7, sizeof(char));

1 2	// 释放开辟的一维数组空间 free(data_stream);

C++中动态数组的使用

动态开辟一维数组

动态开辟一维数组简单，代码实现：

void DynamicCreate1Array()
{
    int len;
    cin>>len;
    int *p = new int[len];
    for(int i = 0; i < len; i++)
    {
        cin>>p[i];
    }	
}
delete[] p;         //动态数组使用完一定要释放

2020/1/10更

动态开辟二维数组

已知二维数组列数，未知行数。假设建立一个n行4列的动态数组（列已知）：

void DynamicCreate2Array()
{
	int n;
	cin >> n;
	int(*p)[4] = new int[n][4];
	for (int i = 0; i < n; i++)
	{
		for (int j = 0; j < 4; j++)
		{
			cin >> p[i][j];
		}
	}
}
delete[] p;         //动态数组使用完一定要释放

二维数组行数、列数均未知

void DynamicCreate2Array()
{
    int row, column;
	char **p = new char*[row];
    for (int i = 0; i < row; i++)
    {
        p[i] = new char[column];
    }
    for (int i = 0; i < row; i++)
    {
        for (int j = 0; j < column; j++)
        {
            cin >> p[i][j];
        }
    }
}
//动态数组释放
for (int i = 0; i < row; i++)
{
    delete[] p[i];
}
delete[]p;

例：机器人走迷宫

迷宫由N W S E组成，踩到N向上走一格，踩到W向左走一格，踩到S向下走一格，踩到E向右走一格。

输入迷宫行数、列数、机器人开始的初试列数（不大于10，列数从1开始数），判断能否走出迷宫。能走出输出步数，不能走出输出”NO”，多组输入，遇 0 0 0 结束输入。

例：

输入：

4 5 6

NNNNSN

NNNSWN

NNSWNN

NSWNNN

3 6 2

NSNNNN

NSWNNN

NENNNN

0 0 0

输出：

代码：

/*----机器人走迷宫----*/
#include<iostream>
using namespace std;
int main()
{
	int row, column, begin, step;
	while (cin >> row >> column >> begin)
	{
		if (row == 0 && column == 0 && begin == 0)
		{
			break;
		}
		else
		{
			step = 0;			
			char **p = new char*[row];
			for (int i = 0; i < row; i++)
			{
				p[i] = new char[column];
			}
			for (int i = 0; i < row; i++)
			{
				for (int j = 0; j < column; j++)
				{
					cin >> p[i][j];
				}
			}

```
		int i = 0;
		int j = begin - 1;
		while (i < row && i >= 0)
		{
			while (j < column && j >= 0)
			{
				if (p[i][j] == 'N')
				{
					p[i][j] = '0';
					step++;
					i--;
					break;
				}
				else if (p[i][j] == 'S')
				{
					p[i][j] = '0';
					step++;
					i++;
					break; 
				}
				else if (p[i][j] == 'W')
				{
					p[i][j] = '0';
					j--;
					step++;
				}
				else if (p[i][j] == 'E')
				{
					p[i][j] = '0';
					j++;
					step++;
				}
				else
				{
					step = -1;
					break;
				}
			}
			if (step == -1)
			{
				break;
			}
		}
		if (step != -1)
		{
			cout << step << endl;
		}
		else
		{
			cout << "No" << endl;
		}
		for (int i = 0; i < row; i++)
		{
			delete[] p[i];
		}
		delete[]p;
	}
}
return 0;
```
}