C语言基础之【数组和字符串】（上）

往期《C语言基础系列》回顾：
链接：
C语言基础之【C语言概述】
C语言基础之【数据类型】（上）
C语言基础之【数据类型】（下）
C语言基础之【运算符与表达式】
C语言基础之【程序流程结构】

---

概述

在程序设计中，为了方便处理数据把具有相同类型的若干变量按有序形式组织起来——称为数组。

数组 ：一组具有相同数据类型的元素的有序集合

• 同一个数组中的所有成员都是相同的数据类型
• 同一个数组中的所有成员在内存中的地址是连续的

数组可以根据维度、存储方式和使用场景进行分类。

---

按维度分类：

数组的维度是指数组的层次结构，常见的有一维数组、二维数组和多维数组

一维数组

• 一维数组是最简单的数组形式，元素按线性顺序排列。

  int numbers[5] = {1, 2, 3, 4, 5};
  

二维数组

• 二维数组是一个矩阵，可以看作是一维数组的数组。

  int matrix[3][3] = {{1, 2, 3},{4, 5, 6},{7, 8, 9}
  };
  

多维数组

• 多维数组是二维数组的扩展，可以有更多维度。

  int cube[2][3][4]; // 三维数组
  

---

按存储方式分类：

数组的存储方式可以分为静态数组和动态数组

静态数组

• 静态数组的大小在编译时确定，内存分配在栈上。

  int numbers[10]; // 静态数组
  

动态数组

• 动态数组的大小在运行时确定，内存分配在堆上。

  • 需要使用动态内存分配函数（如： malloc、calloc）

  int *numbers = (int *)malloc(10 * sizeof(int)); // 动态数组
  

---

按元素类型分类：

数组的元素类型决定了数组中存储的数据类型。

整型数组

• 存储整数类型的数据。

  int numbers[5] = {1, 2, 3, 4, 5};
  

浮点型数组

• 存储浮点数类型的数据。

  float scores[5] = {1.1, 2.2, 3.3, 4.4, 5.5};
  

字符数组

• 存储字符类型的数据，常用于存储字符串。

  char name[20] = "Hello";
  

指针数组

• 存储指针类型的数据。

  char *names[3] = {"Alice", "Bob", "Charlie"};
  

结构体数组

• 存储结构体类型的数据。

  struct Student {char name[20];int age;
  };
  struct Student students[3] = {{"Alice", 20},{"Bob", 21},{"Charlie", 22}
  };
  

---

按使用场景分类：

数组可以根据其使用场景进行分类。

普通数组

• 用于存储和处理一组数据。

  int numbers[5] = {1, 2, 3, 4, 5};
  

字符串数组

• 用于存储和处理字符串。

  char names[3][20] = {"Alice", "Bob", "Charlie"};
  

一维数组

一维数组的定义

一维数组的定义语法：数据类型 数组名[数组大小];

• 数据类型：数组中每个元素的类型。（例如： int、float、char 等）
• 数组名：数组的标识符。（用于访问数组）
• 数组大小：数组中元素的数量。（必须是一个常量）

int numbers[5]; // 定义一个包含5个整数的数组
float scores[10]; // 定义一个包含10个浮点数的数组
char name[20]; // 定义一个包含20个字符的数组

---

一维数组的注意事项：

数组大小必须是一个常量

• 数组大小必须是一个常量，不能是变量。
  • 例如：int n = 10; int numbers[n]; 在标准C中是不合法的（C99 支持变长数组）

数组名是常量指针

• 数组名表示数组的首地址，是一个常量指针，不能修改。
  • 例如：int numbers[5]; 中，numbers 是 &numbers[0] 的简写。

一维数组的初始化

数组可以在定义时初始化，也可以在定义后逐个赋值

---

定义时初始化：

一维数组定义时初始化的语法：数据类型 数组名[数组大小] = {初始值列表};

1.完全初始化

• 为数组的所有元素提供初始值。

  int numbers[5] = {1, 2, 3, 4, 5};
  

  • 数组 numbers 的元素为 1, 2, 3, 4, 5

2.部分初始化

• 只为数组的部分元素提供初始值，剩余元素会自动初始化为 0

  int numbers[5] = {1, 2};
  

  • 数组 numbers 的元素为 1, 2, 0, 0, 0

3.省略数组大小

• 如果提供了初始值列表，可以省略数组大小，编译器会根据初始值的数量自动确定数组大小。

  int numbers[] = {1, 2, 3, 4, 5};
  

  • 数组 numbers 的大小为 5，元素为 1, 2, 3, 4, 5

注：[]中不指定元素个数时，定义时必须初始化

---

定义后赋值：

int numbers[5];
numbers[0] = 1;
numbers[1] = 2;
numbers[2] = 3;
numbers[3] = 4;
numbers[4] = 5;

---

其他特殊的初始化：

在定义数组的同时进行赋值，称为 初始化

• 全局数组若不初始化，编译器将其数组元素初始化为零

• 局部数组若不初始化，数组元素为随机值

#include <stdio.h>int a[3];
int main()
{int b[3];//遍历数组，并输出每个成员的值for (int i = 0; i < 3; i++){printf("%d ", a[i]);}printf("\n");for (int i = 0; i < 3; i++){printf("%d ", b[i]);}printf("\n");return 0;
}

输出：

0 0 0
-858993460 -858993460 -858993460

---

一维数组的初始化总结：

#include <stdio.h>
#include <stdlib.h>int main()
{// 定义并初始化数组int arr1[10] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 }; // 完全初始化int arr2[10] = { 1, 2, 3, 4, 5 };                 // 部分初始化，剩余元素为0int arr3[10] = { 0 };                             // 全部初始化为0int arr4[] = { 1, 2, 3, 4, 5 };                   // 自动推断大小为5int arr5[] = { 0 };                               // 自动推断大小为1// 打印arr1printf("arr1= ");for (int i = 0; i < sizeof(arr1) / sizeof(arr1[0]); i++){printf("%d ", arr1[i]);}printf("\n");// 打印arr2printf("arr2= ");for (int i = 0; i < sizeof(arr2) / sizeof(arr2[0]); i++){printf("%d ", arr2[i]);}printf("\n");// 打印arr3printf("arr3= ");for (int i = 0; i < sizeof(arr3) / sizeof(arr3[0]); i++){printf("%d ", arr3[i]);}printf("\n");// 打印arr4printf("arr4= ");for (int i = 0; i < sizeof(arr4) / sizeof(arr4[0]); i++){printf("%d ", arr4[i]);}printf("\n");// 打印arr5printf("arr5= ");for (int i = 0; i < sizeof(arr5) / sizeof(arr5[0]); i++){printf("%d ", arr5[i]);}printf("\n");// 暂停程序（Windows特有）system("pause");// 返回成功状态return EXIT_SUCCESS;
}

输出：

arr1= 1 2 3 4 5 6 7 8 9 10
arr2= 1 2 3 4 5 0 0 0 0 0
arr3= 0 0 0 0 0 0 0 0 0 0
arr4= 1 2 3 4 5
arr5= 0

一维数组的访问

数组元素通过索引访问，索引从 0 开始，最大索引为 数组大小 - 1

int numbers[5] = {10, 20, 30, 40, 50};printf("%d\n", numbers[0]); // 输出第一个元素：10
printf("%d\n", numbers[2]); // 输出第三个元素：30

一维数组的遍历

可以使用循环遍历数组中的所有元素。

int numbers[5] = {10, 20, 30, 40, 50};for (int i = 0; i < 5; i++)
{printf("%d ", numbers[i]);
}

输出：

10 20 30 40 50

数组名

1. 数组名代表数组首元素的地址

   #include <stdio.h>int main()
   {int a[10] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };printf("a = %p\n", a); //数组名printf("&a[0] = %p\n", &a[0]);  //数组首元素for (int i = 0; i < sizeof(a) / sizeof(a[0]); i++){printf("%d ", a[i]);}printf("\n");return 0;
   }
   

   输出：

   a = 0000006C5C4FFAA8
   &a[0] = 0000006C5C4FFAA8
   1 2 3 4 5 6 7 8 9 10

---

2. 数组名是一个指向数组首元素的指针（可以通过指针访问数组元素）

   int numbers[5] = {10, 20, 30, 40, 50};
   int *ptr = numbers; // ptr 指向数组的首元素printf("%d\n", *ptr); // 输出第一个元素：10
   printf("%d\n", *(ptr + 2)); // 输出第三个元素：30
   

#include <stdio.h>
#include <stdlib.h>int main()
{int a = 5, b = 29, c = 10;int arr[10] = { 1, 2, 4, 6, 76, 8, 90, 4, 3, 6 }; printf("&a = %p\n", &a);printf("&b = %p\n", &b);printf("&c = %p\n", &c);printf("&arr[0] = %x\n", &arr[0]);printf("&arr[1] = %p\n", &arr[1]);printf("&arr[2] = %p\n", &arr[2]);printf("&arr[3] = %p\n", &arr[3]);printf("&arr[4] = %x\n", &arr[4]);system("pause");return EXIT_SUCCESS;
}

输出：

&a = 00000045704FF964
&b = 00000045704FF984
&c = 00000045704FF9A4
&arr[0] = 704ff9c8
&arr[1] = 00000045704FF9CC
&arr[2] = 00000045704FF9D0
&arr[3] = 00000045704FF9D4
&arr[4] = 704ff9d8

分析：

• 变量a，b，c在内存中是非连续存储的。
• 数组arr中的10个整形变量在内存中是连续存储的。

---

%x 和 %p 的区别：

• %x 用于以十六进制格式打印无符号整数。
• %p 用于打印指针地址，通常以十六进制格式显示。

一维数组的常用数据

一维数组的大小 ：sizeof(arr));

一维数组一个元素的大小： sizeof(arr[0]));

一维数组元素的个数： sizeof(arr) / sizeof(arr[0]));

#include <stdio.h>
#include <stdlib.h>int main(void)
{int a = 5, b = 29, c = 10;int arr[12] = { 1, 2, 4, 6, 76, 8, 90, 4, 3, 6, 6, 8 }; printf("数组的大小: %u\n", sizeof(arr));printf("数组一个元素的大小: %u\n", sizeof(arr[0]));printf("数组元素的个数: %d\n", sizeof(arr) / sizeof(arr[0]));system("pause");return EXIT_SUCCESS;
}

输出：

数组的大小: 48
数组一个元素的大小: 4
数组元素的个数: 12

强化训练

一维数组的最值

#include <stdio.h>int main()
{int a[] = { 1, -2, 3,-4, 5, -6, 7, -8, 9, -10 };//定义一个数组，同时初始化所有成员变量int i = 0;int max = a[0];for (i = 1; i < sizeof(a) / sizeof(a[0]); i++){if (a[i] > max){max = a[i];}}printf("数组中最大值为：%d\n", max);return 0;
}

输出：

数组中最大值为：9

一维数组的逆置

#include <stdio.h>int main()
{int a[] = { 1, -2, 3,-4, 5, -6, 7, -8, -9, 10 };//定义一个数组，同时初始化所有成员变量int i = 0;int j = sizeof(a) / sizeof(a[0]) - 1;int temp;while (i < j){temp = a[i];a[i] = a[j];a[j] = temp;i++;j--;}for (i = 0; i < sizeof(a) / sizeof(a[0]); i++){printf("%d ", a[i]);}printf("\n");return 0;
}

输出：

10 -9 -8 7 -6 5 -4 3 -2 1

一维数组的排序（冒泡排序）

#include <stdio.h>int main()
{int a[] = { 1, -2, 3,-4, 5, -6, 7, -8, -9, 10 };//定义一个数组，同时初始化所有成员变量int i = 0;int j = 0;int n = sizeof(a) / sizeof(a[0]);int temp;for (i = 0; i < n - 1; i++){for (j = 0; j < n - i - 1; j++)//内循环的目的是比较相邻的元素，把大的放到后面{if (a[j] > a[j + 1]){temp = a[j];a[j] = a[j + 1];a[j + 1] = temp;}}}for (i = 0; i < n; i++){printf("%d ", a[i]);}printf("\n");return 0;
}

输出：

-9 -8 -6 -4 -2 1 3 5 7 10

二维数组

二维数组的定义

二维数组的定义语法：数据类型 数组名[行数][列数];

• 数据类型：数组中每个元素的类型。（例如： int、float、char 等）
• 数组名：数组的标识符。
• 行数：数组的行数。
• 列数：数组的列数。

int matrix[3][3]; // 定义一个3行3列的二维数组
float scores[5][10]; // 定义一个5行10列的二维数组

int a[3][4]; ：定义了一个三行四列的数组。

• 数组名为a其元素类型为整型
• 该数组的元素个数为3×4个

二维数组在内存中是按行优先顺序存储的，先存放a[0]行，再存放a[1]行、a[2]行，并且每行有四个元素，也是依次存放的。

例如：

int matrix[3][4] = {{1, 2, 3},{4, 5, 6},{7, 8, 9}
};

在内存中的存储顺序为：

1, 2, 3, 4, 5, 6, 7, 8, 9

---

二维数组在概念上是二维的

• 其下标在两个方向上变化，对其访问一般需要两个下标。

在内存中并不存在二维数组

• 也就是说内存中只有一维数组，即放完一行之后顺次放入第二行，和一维数组存放方式是一样的。

所以：二维数组它可以看作是一个“数组的数组”

二维数组的初始化

二维数组可以在定义时初始化，也可以在定义后逐个赋值

---

定义时初始化：

1.完全初始化

• 使用嵌套的大括号 {} 初始化二维数组。

  int matrix[3][3] = {{1, 2, 3},{4, 5, 6},{7, 8, 9}
  };
  

2.部分初始化

• 如果初始化时未指定所有元素的值，剩余元素会自动初始化为 0

  int matrix[3][3] = {{1, 2},{4, 5},{7, 8}
  };
  

3.省略数组行数

• 在初始化三维数组时，可以省略第一维（层数）的大小，但必须指定第二维（行数）和第三维（列数）的大小。

• 编译器会根据初始化的数据自动推断第一维的大小。

  #include <stdio.h>int main() 
  {// 省略行数，指定列数为 3int arr[][3] = {1, 2, 3, 4, 5, 6, 7};// 计算行数int rows = sizeof(arr) / sizeof(arr[0]);int cols = sizeof(arr[0]) / sizeof(arr[0][0]);for (int i = 0; i < rows; i++) {for (int j = 0; j < cols; j++) {printf("%d ", arr[i][j]);}printf("\n");}return 0;
  }
  

  输出：

  1 2 3
  4 5 6
  7 0 0
  

---

定义后赋值：

• 逐个为二维数组的元素赋值。

  int matrix[3][3];
  matrix[0][0] = 1;
  matrix[0][1] = 2;
  matrix[0][2] = 3;
  matrix[1][0] = 4;
  matrix[1][1] = 5;
  matrix[1][2] = 6;
  matrix[2][0] = 7;
  matrix[2][1] = 8;
  matrix[2][2] = 9;
  

二维数组的初始化总结：

#include <stdio.h>
#include <stdlib.h>int main()
{// 定义并初始化二维数组int arr1[3][3] ={{ 1, 2, 3 },{ 4, 5, 6 },{ 7, 8, 9 }};int arr2[3][3] = { 1, 2, 3, 4, 5, 6, 7, 8, 9 };int arr3[3][3] = {{1, 2},{4, 5},{7, 8}};int arr4[3][3] = { 1, 2, 3, 4 };int arr5[3][3] = { 0 };int arr6[][3] = {{1},{2, 3},{4, 5}};int arr7[][4] = { 1, 2, 3, 4, 5, 6 };int arr8[][4] = { 0 };// 打印arr1printf("arr1= \n");for (int i = 0; i < 3; i++){for (int j = 0; j < 3; j++){printf("%d ", arr1[i][j]);}printf("\n");}printf("\n");// 打印arr2printf("arr2= \n");for (int i = 0; i < 3; i++){for (int j = 0; j < 3; j++){printf("%d ", arr2[i][j]);}printf("\n");}printf("\n");// 打印arr3printf("arr3= \n");for (int i = 0; i < 3; i++){for (int j = 0; j < 3; j++){printf("%d ", arr3[i][j]);}printf("\n");}printf("\n");// 打印arr4printf("arr4= \n");for (int i = 0; i < 3; i++){for (int j = 0; j < 3; j++){printf("%d ", arr4[i][j]);}printf("\n");}printf("\n");// 打印arr5printf("arr5= \n");for (int i = 0; i < 3; i++){for (int j = 0; j < 3; j++){printf("%d ", arr5[i][j]);}printf("\n");}printf("\n");// 打印arr6printf("arr6= \n");int rows6 = sizeof(arr6) / sizeof(arr6[0]);int cols6 = sizeof(arr6[0]) / sizeof(arr6[0][0]);for (int i = 0; i < rows6; i++){for (int j = 0; j < cols6; j++){printf("%d ", arr6[i][j]);}printf("\n");}printf("\n");// 打印arr7printf("arr7= \n");int rows7 = sizeof(arr7) / sizeof(arr7[0]);int cols7 = sizeof(arr7[0]) / sizeof(arr7[0][0]);for (int i = 0; i < rows7; i++){for (int j = 0; j < cols7; j++){printf("%d ", arr7[i][j]);}printf("\n");}printf("\n");// 打印arr8printf("arr8= \n");int rows8 = sizeof(arr8) / sizeof(arr8[0]);int cols8 = sizeof(arr8[0]) / sizeof(arr8[0][0]);for (int i = 0; i < rows8; i++){for (int j = 0; j < cols8; j++){printf("%d ", arr8[i][j]);}printf("\n");}printf("\n");// 暂停程序（Windows特有）system("pause");// 返回成功状态return EXIT_SUCCESS;
}

输出：

arr1=
1 2 3
4 5 6
7 8 9arr2=
1 2 3
4 5 6
7 8 9arr3=
1 2 0
4 5 0
7 8 0arr4=
1 2 3
4 0 0
0 0 0arr5=
0 0 0
0 0 0
0 0 0arr6=
1 0 0
2 3 0
4 5 0arr7=
1 2 3 4
5 6 0 0arr8=
0 0 0 0

二维数组的访问

二维数组的元素通过行索引和列索引访问，索引从 0 开始。

int matrix[3][3] = {{1, 2, 3},{4, 5, 6},{7, 8, 9}
};printf("%d\n", matrix[1][2]); // 输出第二行第三列的元素：6

二维数组的遍历

可以使用嵌套循环遍历二维数组中的所有元素。

int matrix[3][3] = {{1, 2, 3},{4, 5, 6},{7, 8, 9}
};
for (int i = 0; i < 3; i++) // 遍历行
{for (int j = 0; j < 3; j++) // 遍历列{printf("%d ", matrix[i][j]);}printf("\n");
}

输出：

1 2 3
4 5 6
7 8 9

数组名

数组名 == 数组的首元素地址 == 数组的首行地址

printf(“%p\n",arr);== printf("%p\n"，&arr[0][0]); == printf("%p\n"，arr[0]):

注：arr[0][0]的前面一定要有&符号。

#include <stdio.h>int main()
{int a[3][4] = { 1, 2, 3, 4 , 5, 6, 7, 8, 9, 10, 11, 12 };printf("a = %p\n", a);printf("a[0] = %p\n", a[0]);printf("&a[0][0] = %p\n", &a[0][0]);printf("a[0][0] = %p\n", a[0][0]);return 0;
}

输出：

a = 00000072972FF648
a[0] = 00000072972FF648
&a[0][0] = 0000003750AFFB58    
a[0][0] = 0000000000000001    

二维数组的常用数据

二维数组数组的大小：sizeof(arr)
二维数组一行的大小：sizeof(arr[0])
二维数组一个元素的大小：sizeof(arr[0][0])
二维数组的行数: sizeof(arr)/ sizeof(arr[0])
二维数组的列数: sizeof(arr[0])/ sizeof(arr[0][0])

二维数组元素的个数 ：sizeof(arr) / sizeof(arr[0][0])

#include <stdio.h>int main()
{int arr[3][3] = {{1, 2, 3},{4, 5, 6},{7, 8, 9}};for (size_t i = 0; i < 3; i++) // 行{for (size_t j = 0; j < 3; j++) // 列{printf("%d ", arr[i][j]);}printf("\n");}printf("二维数组数组的大小：%u\n", sizeof(arr));printf("二维数组一行的大小：%u\n", sizeof(arr[0]));printf("二维数组一个元素的大小：%u\n", sizeof(arr[0][0]));printf("二维数组的行数：%u\n", sizeof(arr) / sizeof(arr[0]));printf("二维数组的列数：%u\n", sizeof(arr[0]) / sizeof(arr[0][0]));printf("二维数组元素的个数：%u\n", sizeof(arr) / sizeof(arr[0][0]));return 0;
}

输出：

1 2 3
4 5 6
7 8 9
二维数组数组的大小：36
二维数组一行的大小：12
二维数组一个元素的大小：4
二维数组的行数：3
二维数组的列数：3
二维数组元素的个数：9

强化训练

学生成绩统计与分析

#include <stdio.h>int main()
{//二维数组：五行、三列//行代表学生  列代表科目float a[5][3] = { { 80, 75, 56 }, { 59, 65, 71 }, { 59, 63, 70 }, { 85, 45, 90 }, { 76, 77, 45 } };int i, j, person_low[3] = { 0 };float s = 0, lesson_aver[3] = { 0 };for (i = 0; i < 3; i++){for (j = 0; j < 5; j++){s = s + a[j][i];if (a[j][i] < 60){person_low[i]++;}}lesson_aver[i] = s / 5;s = 0;}printf("各科的平均成绩:\n");for (i = 0; i < 3; i++){printf("%.2f\n", lesson_aver[i]);}printf("各科不及格的人数:\n");for (i = 0; i < 3; i++){printf("%d\n", person_low[i]);}return 0;
}

输出：

各科的平均成绩:
71.80
65.00
66.40
各科不及格的人数:
2
1
2

多维数组

多维数组的定义

三维数组的定义语法：数据类型 数组名[层数][行数][列数];

多维数组的定义语法：数据类型 数组名[维度1大小][维度2大小]...[维度N大小];

• 数据类型：数组中每个元素的类型。（例如： int、float、char 等）
• 数组名：数组的标识符。
• 维度大小：每个维度的大小。（必须是一个常量）

int matrix[3][3]; // 定义一个3x3的二维数组
float cube[2][3][4]; // 定义一个2x3x4的三维数组

int a[3][4][5]; ：定义了一个三维数组。

• 数组的名字是a，数组的长度为3
• 每个数组的元素又是一个二维数组，这个二维数组的长度是4
• 并且这个二维数组中的每个元素又是一个一维数组，这个一维数组的长度是5，元素类型是int

#include <stdio.h>int main()
{//int a[3][4][5] ;//定义了一个三维数组，有3个二维数组int[4][5]int a[3][4][5] = { { //第一层{ 1, 2, 3, 4, 5 },{ 6, 7, 8, 9, 10 }, { 0 }, { 0 }}, {//第二层{ 0 },{ 0 }, { 0 }, { 0 }},{//第三层{ 0 },{ 0 },{ 0 },{ 0 } } };int i, j, k;for (i = 0; i < 3; i++){for (j = 0; j < 4; j++){for (k = 0; k < 5; k++){//添加访问元素代码printf("%d ", a[i][j][k]);}printf("\n");}printf("\n");}return 0;
}

输出：

1 2 3 4 5
6 7 8 9 10
0 0 0 0 0
0 0 0 0 00 0 0 0 0
0 0 0 0 0
0 0 0 0 0
0 0 0 0 00 0 0 0 0
0 0 0 0 0
0 0 0 0 0
0 0 0 0 0

多维数组的初始化

多维数组可以在定义时初始化，也可以在定义后逐个赋值

---

定义时初始化

1.完全初始化

• 使用嵌套的大括号 {} 初始化多维数组。

int cube[2][3][4] = {{{1, 2, 3, 4},{5, 6, 7, 8},{9, 10, 11, 12}},{{13, 14, 15, 16},{17, 18, 19, 20},{21, 22, 23, 24}}
};

2.部分初始化

• 如果初始化时未指定所有元素的值，剩余元素会自动初始化为 0

int cube[2][3][4] = {{{1, 2},{5, 6},{9, 10}},{{13, 14},{17, 18},{21, 22}}
};

• 未初始化的元素为 0

3.省略数组大小

• 可以省略第一个维度（行数）的大小，但必须指定第二个维度（列数）的大小。编译器会根据初始化的数据自动推断行数。

#include <stdio.h>int main()
{// 定义并初始化三维数组，省略层数int arr[][3][4] = {{{1, 2, 3, 4},{5, 6, 7, 8},{9, 10, 11, 12}},{{13, 14, 15, 16},{17, 18, 19, 20},{21, 22, 23, 24}}};// 计算层数int layers = sizeof(arr) / sizeof(arr[0]);// 遍历三维数组并打印元素for (int i = 0; i < layers; i++) // 层{printf("第 %d 层:\n", i + 1);for (int j = 0; j < 3; j++) // 行{for (int k = 0; k < 4; k++) // 列{printf("%2d ", arr[i][j][k]);}printf("\n");}printf("\n");}return 0;
}

输出：

第 1 层:1  2  3  45  6  7  89 10 11 12第 2 层:
13 14 15 16
17 18 19 20
21 22 23 24

---

定义后赋值

• 逐个为多维数组的元素赋值。

int cube[2][3][4];
cube[0][0][0] = 1;
cube[0][0][1] = 2;
cube[0][0][2] = 3;
cube[0][0][3] = 4;
cube[0][1][0] = 5;
cube[0][1][1] = 6;
cube[0][1][2] = 7;
cube[0][1][3] = 8;
cube[0][2][0] = 9;
cube[0][2][1] = 10;
cube[0][2][2] = 11;
cube[0][2][3] = 12;
cube[1][0][0] = 13;
cube[1][0][1] = 14;
cube[1][0][2] = 15;
cube[1][0][3] = 16;
cube[1][1][0] = 17;
cube[1][1][1] = 18;
cube[1][1][2] = 19;
cube[1][1][3] = 20;
cube[1][2][0] = 21;
cube[1][2][1] = 22;
cube[1][2][2] = 23;
cube[1][2][3] = 24;

多维数组的访问

多维数组的元素通过多个索引访问，索引从 0 开始。

int cube[2][3][4] = {{{1, 2, 3, 4},{5, 6, 7, 8},{9, 10, 11, 12}},{{13, 14, 15, 16},{17, 18, 19, 20},{21, 22, 23, 24}}
};printf("%d\n", cube[1][2][3]); // 输出第二层第三行第四列的元素：24

多维数组的遍历

可以使用嵌套循环遍历多维数组中的所有元素。

int cube[2][3][4] = {{{1, 2, 3, 4},{5, 6, 7, 8},{9, 10, 11, 12}},{{13, 14, 15, 16},{17, 18, 19, 20},{21, 22, 23, 24}}
};
for (int i = 0; i < 2; i++) // 遍历第一维
{for (int j = 0; j < 3; j++) // 遍历第二维{for (int k = 0; k < 4; k++) // 遍历第三维{printf("%d ", cube[i][j][k]);}printf("\n");}printf("\n");
}

输出：

1 2 3 4
5 6 7 8
9 10 11 1213 14 15 16
17 18 19 20
21 22 23 24

👨‍💻 博主正在持续更新C语言基础系列中。
❤️ 如果你觉得内容还不错，请多多点赞。

⭐️ 如果你觉得对你有帮助，请多多收藏。（防止以后找不到了）

👨‍👩‍👧‍👦 C语言基础系列 持续更新中~，后续分享内容主要涉及 C++全栈开发 的知识，如果你感兴趣请多多关注博主。