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。

使用示例:

1
2
3
4
5
6
/*申请一个动态数组 存储图像矩阵*/
char **bufarray;
bufarray = (char**)malloc(sizeof(char*) * infoHeader->biHeight); // 分配所有行的首地址
for (i = 0; i < infoHeader->biHeight; i++) { // 按行分配每一列
bufarray[i] = (char*)malloc(sizeof(char) * infoHeader->biWidth);
}
1
2
3
4
5
// 释放开辟的二维数组空间
for (i = 0; i < infoHeader->biWidth; ++i)
{
free(*(bufarray + i));
}
1
2
3
4
5
6
/*申请一个动态数组 存储去除白边后的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));
}
1
2
3
4
5
// 释放开辟的二维数组空间
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++中动态数组的使用

  1. 动态开辟一维数组

    动态开辟一维数组简单,代码实现:

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    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更

  2. 动态开辟二维数组

    • 已知二维数组列数,未知行数。假设建立一个n行4列的动态数组(列已知):

      1
      2
      3
      4
      5
      6
      7
      8
      9
      10
      11
      12
      13
      14
      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; //动态数组使用完一定要释放
    • 二维数组行数、列数均未知

      1
      2
      3
      4
      5
      6
      7
      8
      9
      10
      11
      12
      13
      14
      15
      16
      17
      18
      19
      20
      21
      22
      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

      输出:

      7

      No

      代码:

      1
      2
      3
      4
      5
      6
      7
      8
      9
      10
      11
      12
      13
      14
      15
      16
      17
      18
      19
      20
      21
      22
      23
      24
      25
      26
      27
      28
      29
      30
      31
      32
      33
      34
      35
      36
      37
      38
      39
      40
      41
      42
      43
      44
      45
      46
      47
      48
      49
      50
      51
      52
      53
      54
      55
      56
      57
      58
      59
      60
      61
      62
      63
      64
      65
      66
      67
      68
      69
      70
      71
      72
      73
      74
      75
      76
      77
      78
      79
      80
      81
      82
      83
      84
      85
      86
      87
      88
      89
      90
      /*----机器人走迷宫----*/
      #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;
      ```
      }
Author: wnxy
Link: https://wnxy.github.io/2020/01/10/C-or-C++_dynamic-array/
Copyright Notice: All articles in this blog are licensed under CC BY-NC-SA 4.0 unless stating additionally.