C语言目录

C/C++学习资源（百度云盘链接）
计算机二级资料（过级专用）
C语言学习路线（从入门到实战）
编写C语言程序的7个步骤和编程机制
C语言基础-第一个C程序
C语言基础-简单程序分析
VS2019编写简单的C程序示例
简单示例，VS2019调试C语言程序
C语言基础-基本算法
C语言基础-数据类型
C语言中的输入输出函数
C语言流程控制语句
C语言数组——一维数组

二维数组

前面介绍了一维数组，接下来介绍如何定义和使用二维数组。

二维数组定义的一般形式如下：

类型说明符 数组名[常量表达式1][常量表达式2]

与一维数组的定义唯一的不同是多了一个常量表达式2，其中，常量表达式1为第一维的长度，常量表达式2为第二维的长度。通常在处理二维数组的时候，为了便于理解，都将数组视为一个矩阵，常量表达式1表示矩阵的行数，而常量表达式2表示矩阵的列数。与一维数组一样，在定义二维数组时，常量表达式同样不能为变量。下面先通过一段代码来看二维数组的定义。

#include<stdio.h>

#define M 4
#define N 3


int main() {
  int arr[M][N];
  for (int i = 0; i < M; i++)
  {
    for (int j = 0; j < N; j++)
    {
      printf("&arr[%d][%d]=%d\t", i, j, &arr[i][j]);
    }
    printf("\n");
  }
  return 0;
}

运行结果：

将二维数组arr视为一个矩阵，下图显示了数组中每个元素在矩阵中的存放位置。

数组中各个元素在矩阵中对应的位置由二维数组的两个下标决定。我们可以将定义的二维数组int arr[4][3]视为由arr[4]和int [3] 两部分构成，将arr[4]视为一个整型一维数组，其中含有4个元素arr[0]、arr[1]、arr[2]、arr[3]，每个元素都是int[3]类型的，也就是说，每个元素又是一个一维数组，每个一维数组含有3个元素，如arr[0]含有arr[0][1]、arr[0][1]、arr[0][2]三个元素。

知道了二维数组的这种特殊结构之后，接下来通过下图来了解二维数组在内存中的存储结构。

通过上述二维数组在内存中的存储结构图可以发现，二维数组中的所有元素都存储在一片连续的内存单元中，所占用的内存大小为元素类型所占用的内存大小乘以第一维及第二维的长度。如果以矩阵的方式来分析二维数组的存储方式，那么先从矩阵第一行从左往右依次存储完所有元素，然后按照同样的方法存储第二行的所有元素，直到存储完所有数组元素为止。

接下来再看一个二维数组的示例：

任意输入一个3行3列的二维数组，求对角元素之和

#define _CRT_SECURE_NO_WARNINGS
#include<stdio.h>

int main() {
  int arr[3][3];
  int i, j, sum = 0;
  printf("please input:\n");
  for (i = 0; i < 3; i++)
  {
    for (j = 0; j < 3; j++)
    {
      scanf("%d", &arr[i][j]);
    }
  }
  for (i = 0; i < 3; i++)
  {
    for ( j = 0; j < 3; j++)
    {
      if (i==j)
      {
        sum += arr[i][j];
      }
    }
  }
  printf("the result is: %d\n", sum);
  return 0;
}

运行结果如下：

关于以为数组就介绍到这，后面继续更新。。。

如果您觉得本篇文章对您有帮助，请转发给更多的人
【C语言中文社区】是一个C语言视频教程、学习笔记、电子书、计算机二级资料等专注于C语言编程学习者的干货知识分享平台，精选深度文章，分享优秀干货类、技能类的学习资源，帮助学习中的你。

在编程中有时需要使用二维数组作为buffer，下面是我写的一个二维数组的demo。

这里面涉及到几个内存操作的知识点，一个一个的来讲。

1. 创建两个1维数组，用于给二维数组填充值的时候使用。

/*2行27列，一维数组长度为27*/
#define BUFF_SIZE_ROW 2
#define BUFF_SIZE_COL 27

int main()
{
    
    /*初始化两个原子数据，全1和全2*/
    unsigned char data[BUFF_SIZE_COL];
    unsigned char data1[BUFF_SIZE_COL];

    /*memset整体为数组赋值某个值*/
    memset(data, 1, BUFF_SIZE_COL);
    memset(data1, 2, BUFF_SIZE_COL);

这一段包含两个知识点，一个是一位数字的创建，和一维数组的一个整体一次性赋值。用到的重点函数的memset。

2.动态创建二维数组，用法如下

unsigned char **buffer_a = (unsigned char **)malloc(BUFF_SIZE_ROW * sizeof(unsigned char *));
    for(int i = 0; i < BUFF_SIZE_ROW; i++)
    {
        buffer_a[i] = (unsigned char *)malloc(BUFF_SIZE_COL * sizeof(unsigned char));
    }

 3.将原子一维数组填充到动态创建的二维数组中

/*将原子数据赋值给buffer_a*/
    memcpy(buffer_a[0], data1, BUFF_SIZE_COL);
    memcpy(buffer_a[1], data1, BUFF_SIZE_COL);

这部分用到的知识点是memcpy，这里一定要注意copy的内存大小。

4.将一个动态创建的二维数组赋值给另外一个动态创建的二维数组

/*将buffer_a循环赋值给buffer_b*/
    for (size_t i = 0; i < BUFF_SIZE_ROW; i++)
    {
        memcpy(buffer_b[i], buffer_a[i], BUFF_SIZE_COL);
    }

这里注意buffer_b的创建方式与buffer_a一致。 

5.释放二维数组

/*释放buffer，先释放行，再释放列*/
    for(int i = 0; i < BUFF_SIZE_ROW; i++)
        free(buffer_a[i]);

    free(buffer_a);
    buffer_a = NULL; 

这里注意要先free掉列，再释放行，与创建时相反 

下面是完整的测试代码：

#include <stdio.h>
#include <windows.h>

/*2行27列，一维数组长度为27*/
#define BUFF_SIZE_ROW 2
#define BUFF_SIZE_COL 27

int main()
{
    
    /*初始化两个原子数据，全1和全2*/
    unsigned char data[BUFF_SIZE_COL];
    unsigned char data1[BUFF_SIZE_COL];

    /*memset整体为数组赋值某个值*/
    memset(data, 1, BUFF_SIZE_COL);
    memset(data1, 2, BUFF_SIZE_COL);

    /*创建二维动态数组buffer_a和buffer_b*/
    unsigned char **buffer_a = (unsigned char **)malloc(BUFF_SIZE_ROW * sizeof(unsigned char *));
    for(int i = 0; i < BUFF_SIZE_ROW; i++)
    {
        buffer_a[i] = (unsigned char *)malloc(BUFF_SIZE_COL * sizeof(unsigned char));
    }

    unsigned char **buffer_b = (unsigned char **)malloc(BUFF_SIZE_ROW * sizeof(unsigned char *));
    for(int i = 0; i < BUFF_SIZE_ROW; i++)
    {
        buffer_b[i] = (unsigned char *)malloc(BUFF_SIZE_COL * sizeof(unsigned char));
    }

    /*将原子数据赋值给buffer_a*/
    memcpy(buffer_a[0], data1, BUFF_SIZE_COL);
    memcpy(buffer_a[1], data1, BUFF_SIZE_COL);

    /*将buffer_a循环赋值给buffer_b*/
    for (size_t i = 0; i < BUFF_SIZE_ROW; i++)
    {
        memcpy(buffer_b[i], buffer_a[i], BUFF_SIZE_COL);
    }

    /*输出A B的第一行数据，验证是否等于data*/
    for (size_t i = 0; i < BUFF_SIZE_COL; i++)
    {
        printf("a %d, %d\r\n", i, buffer_a[0][i]);
    }
       
    for (size_t i = 0; i < BUFF_SIZE_COL; i++)
    {
        printf("b %d, %d\r\n", i, buffer_b[0][i]);
    }
    /*释放buffer，先释放列，再释放行*/
    for(int i = 0; i < BUFF_SIZE_ROW; i++)
        free(buffer_a[i]);

    free(buffer_a);
    buffer_a = NULL; 

    for(int i = 0; i < BUFF_SIZE_ROW; i++)
        free(buffer_b[i]);
    free(buffer_b);
    buffer_b = NULL; 

    system("pause");
	return 0;
}
 

linux kernel

    int i, j;
    
    uint8_t **buffer_a = (uint8_t **)kmalloc(BUFF_SIZE * sizeof(uint8_t *), GFP_KERNEL);
    uint8_t **buffer_b = (uint8_t **)kmalloc(BUFF_SIZE * sizeof(uint8_t *), GFP_KERNEL);
    uint8_t data[SAMP_SIZE];

    memset(data, 0xff, SAMP_SIZE);

    for (i = 0; i < BUFF_SIZE; i++)
    {
        buffer_a[i] = (uint8_t *)kmalloc(SAMP_SIZE * sizeof(uint8_t), GFP_KERNEL);
    }
    
    for (i = 0; i < BUFF_SIZE; i++)
    {
        buffer_b[i] = (uint8_t *)kmalloc(SAMP_SIZE * sizeof(uint8_t), GFP_KERNEL);
    }
    calltime = ktime_get();
    for (i = 0; i < BUFF_SIZE; i++)
    {
        memcpy(buffer_a[i], data, SAMP_SIZE);
    }
    

    for (j = 0; j < 100; j++)
    {
        /* code */
        for (i = 0; i < BUFF_SIZE; i++)
        {
            memcpy(buffer_b[i], buffer_a[i], SAMP_SIZE);
        }
    }
    

    rettime = ktime_get();
    delta = ktime_sub(rettime, calltime);
    duration = (unsigned long long )ktime_to_ns(delta) >> 10;
    printk("buffer copy use %lld us\r\n", duration);

    /*free buffer*/
    for (i = 0; i < BUFF_SIZE; i++)
    {
        kfree(buffer_a[i]);
    }
    kfree(buffer_a);
    buffer_a = NULL; 
 
    for(i = 0; i < BUFF_SIZE; i++)
    {
        kfree(buffer_b[i]);
    }   
    kfree(buffer_b);
    buffer_b = NULL;