视频加载失败

C语言初阶 06:一维数组、二维数组与字符串

5294 字
26 分钟
C语言初阶 06:一维数组、二维数组与字符串

代码块包含可运行实现、局部片段、输出、故意出错的示例与思考题;它们是独立示例,请结合上下文阅读,不能将整章拼成一个程序。

阅读前先核对#

  • sizeof 是操作符,strlen 返回终止符前的字节数,头文件是 <string.h>。数组传参后不能用形参的 sizeof 推断原数组元素数。
  • C99 变长数组在部分后续标准/实现中支持情况不同,MSVC 常见 C 模式不支持;运行时长度必须为正,且应限制容量。

本章目标#

  1. 掌握一维数组和二维数组的使用

  2. 理解一维数组和二维数组的数据存放方式为后期学习指针和数组打好基础

  3. 能够熟练使用一维数组和二维数组进行代码的编写

  4. 掌握变长数组的使用和特点

1. 数组的概念#

概念:数组是一组相同类型元素的集合;

  • 数组中存放的是1个或者多个数据,但是数组元素个数不能为0。

  • 数组中存放的多个数据,类型是相同的。

数组分为一维数组和多维数组,多维数组一般比较多见的是二维数组。

2. 一维数组的创建和初始化#

2.1 数组创建#

一维数组创建的基本语法如下:

课件代码 06-001 · PDF 第 1 页

type arr_name[常量值];
  • type 是数组中存放数据的类型,可以是: char、short、int、float 等,也可以自定义的

类型。

  • arr_name 是数组名的名字,这个名字根据实际情况,起的有意义就行。

  • [] 中的常量值是用来指定数组的大小的,这个数组的大小是根据实际的需求指定就行。

存放在数组的值被称为数组的元素,数组在创建的时候根据需要指定数组的大小和数组的元素类型。

比如:我们现在想存储某个班级的20人的数学成绩,那可以创建一个数组,如下:

课件代码 06-002 · PDF 第 2 页

int math[20];

当然我们也可以根据需要创建其他类型和大小的数组:

课件代码 06-003 · PDF 第 2 页

char ch[8];
double score[10];

2.2 数组的初始化#

有时候,数组在创建的时候,我们需要给定一些初始值,这种就称为初始化的。

数组的初始化一般使用大括号,将数据放在大括号中,使用逗号隔开。

数组如果进行了初始化,数组的大小是可以省略掉的。

课件代码 06-004 · PDF 第 2 页

//完全初始化
int arr[5] = {1,2,3,4,5};
int arr[] = {1,2,3,4,5};//这里数组的大小还是5,编译器会根据初始化的内容推算出来
//不完全初始化
int arr2[6] = {1};//第一个元素初始化为1,剩余的元素默认初始化为0
//错误的初始化 - 初始化项太多
int arr3[3] = {1, 2, 3, 4};

2.2.1 字符串和字符数组#

字符数组的初始化可以使用大括号,也可以使用字符串,请看代码:

课件代码 06-005 · PDF 第 3 页

#include <stdio.h>
int main()
{
char arr1[] = {'a', 'b', 'c'};
char arr2[] = "abc";
return 0;
}

这2种初始化是有差异的,如果我们调试观察一下,就会发现 arr2 数组中多了一个 ‘\0’ 字符。

第6章第3页配图
第6章第3页配图

这是为什么呢?

原因其实在于字符串,C语言中的字符串是用双引号括起来的一串字符,在字符串的末尾会隐藏一个 ‘\0’ 字符。

第6章第3页配图
第6章第3页配图

这个 ‘\0’ 字符是字符串的结束标志,遇到 ‘\0’ 的时候,就认为字符串结束了,再看一段代码:

课件代码 06-006 · PDF 第 3,4 页

#include <stdio.h>
int main()
{
char arr1[] = "abc";
char arr2[] = { 'a', 'b', 'c' };
printf("arr1 = %s\n", arr1);
printf("arr2 = %s\n", arr2);
return 0;
}

第6章第4页配图
第6章第4页配图

printf 函数在使用 %s 占位符打印字符串的时候,从头开始,直到 ‘\0’ ,打印才结束。

打印 arr1 数组的内容,输出的内容是 abc ,正常结束;但是打印 arr2 数组的 abc 后,后续还打印了一堆乱码,就是因为 arr2 中缺少 \0 字符, printf 打印字符串认为还不应该结束,直到找到\0 才算结束。

同理 strlen 函数在求字符串长度的时候, strlen 统计的是字符串中 \0 之前的字符的个数,从前往后统计的时候没有遇到 \0 ,就会一直往后找,可能会越界访问,结果可能是未知数。

课件代码 06-007 · PDF 第 4 页

#include <stdio.h>
#include <string.h>
int main()
{
char arr1[] = "abc";
char arr2[] = { 'a', 'b', 'c' };
printf("%zu\n", strlen(arr1));
printf("%zu\n", strlen(arr2));
return 0;
}

我们把 strlen 换成 sizeof ,看看代码的结果:

课件代码 06-008 · PDF 第 5 页

#include <stdio.h>
#include <string.h>
int main()
{
char arr1[] = "abc";
char arr2[] = { 'a', 'b', 'c' };
printf("%zu\n", sizeof(arr1));
printf("%zu\n", sizeof(arr2));
return 0;
}

2.2.2 sizeof 和 strlen的对比#

第6章第5页图表
第6章第5页图表

2.3 数组的类型#

数组也是有类型的,数组算是一种自定义类型,去掉数组名留下的就是数组的类型。

如下:

课件代码 06-009 · PDF 第 5 页

int arr1[10];
int arr2[12];
char ch[5];

arr1 数组的类型是 int [10]arr2 数组的类型是 int [12]ch 数组的类型是 char [5]

3. 一维数组的使用#

数组中可以存放数据,存放数据的目的是使用数据,对数据进行操作,那我们如何使用一维数组呢?

3.1 数组下标#

C语言规定数组是有下标的,下标是从0开始的,假设数组有n个元素,最后一个元素的下标就是n-1,下标就相当于数组元素的编号,如下:

课件代码 06-010 · PDF 第 6 页

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

第6章第6页配图
第6章第6页配图

数组元素和下标在C语言中数组的访问提供了一个操作符 [] ,这个操作符叫:下标引用操作符。

有了下标访问操作符,可以轻松的访问到数组的元素了,比如我们访问下标为7的元素,我们就可以使用 arr[7] ,想要访问下标是3的元素,就可以使用 arr[3] ,如下代码:

课件代码 06-011 · PDF 第 6 页

#include <stdio.h>
int main()
{
int arr[10] = {1,2,3,4,5,6,7,8,9,10};
printf("%d\n", arr[7]);//8
arr[7] = 0; //也可以修改这个元素的值
printf("%d\n", arr[7]);//0
printf("%d\n", arr[3]);//4
return 0;
}

输出结果:

第6章第7页配图
第6章第7页配图

3.2 数组元素的遍历#

3.2.1 打印数组内容#

接下来,如果想要打印整个数组的内容,那怎么办呢?

访问一个元素需要一个下标,要访问所有元素,我们产生数组所有元素的下标就可以了;那我们使用 for 循环产生0~9的下标,接下来使用下标访问数组元素就行了。

如下代码:

课件代码 06-012 · PDF 第 7 页

#include <stdio.h>
int main()
{
int arr[10] = {1,2,3,4,5,6,7,8,9,10};
int i = 0;
for(i = 0; i < 10; i++)
{
printf("%d ", arr[i]);
}
return 0;
}

输出的结果:

第6章第7页配图
第6章第7页配图

🎈 思考练习:

  1. 如果要逆序打印数组的内容,怎么处理?

  2. 间隔一个元素打印数组内容,怎么处理?

  3. 如果在访问数组元素的时候,下标超出了范围,会怎么样?

3.2.2 给数组输入内容#

当然我们也可以根据需求,自己给数组输入想要的数据,如下:

课件代码 06-013 · PDF 第 8 页

#include <stdio.h>
int main()
{
int arr[10] = {1,2,3,4,5,6,7,8,9,10};
int i = 0;
for(i = 0; i < 10; i++)
{
scanf("%d", &arr[i]);
}
for(i = 0; i < 10; i++)
{
printf("%d ", arr[i]);
}
return 0;
}

输入个输出结果:

第6章第8页配图
第6章第8页配图

4. sizeof计算数组元素个数#

在遍历数组的时候,我们经常想知道数组的元素个数,那C语言中有办法使用程序计算数组元素个数吗?

答案是有的,可以使用sizeof。

sizeof 中C语言是一个关键字,是可以计算类型或者变量大小的,其实 sizeof 也可以计算数组的大小。

比如:

课件代码 06-014 · PDF 第 8,9 页

#include <stdio.h>
int main()
{
int arr[10] = {0};
printf("%d\n", sizeof(arr));
return 0;
}

这里输出的结果是40,计算的是数组所占内存空间的总大小,单位是字节。

我们又知道数组中所有元素的类型都是相同的,那只要计算出一个元素所占字节的个数,数组的元素个数就能算出来。这里我们选择第一个元素算大小就可以。

课件代码 06-015 · PDF 第 9 页

#include <stdio.h>
int main()
{
int arr[10] = {0};
printf("%d\n", sizeof(arr[0]));//计算一个元素的大小,单位是字节
return 0;
}

接下来就能计算出数组的元素个数:

课件代码 06-016 · PDF 第 9 页

#include <stdio.h>
int main()
{
int arr[10] = {0};
int sz = sizeof(arr)/sizeof(arr[0]);
printf("%d\n", sz);
return 0;
}

这里的结果是:10,表示数组有10个元素。

以后在代码中需要数组元素个数的地方就不用固定写死了,使用上面的计算,不管数组怎么变化,计算出的大小也就随着变化了。

5. 一维数组在内存中的存储#

有了前面的知识,我们其实使用数组基本没有什么障碍了,如果我们要深入了解数组,我们最好能了解一下数组在内存中的存储方式。

依次打印数组元素的地址,来观察一下:

课件代码 06-017 · PDF 第 10 页

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

输出结果我们看看(在自己电脑上运行的结果可能和课件不一样哦):

课件代码 06-018 · PDF 第 10 页

&arr[0] = 00000003BDB1F638
&arr[1] = 00000003BDB1F63C
&arr[2] = 00000003BDB1F640
&arr[3] = 00000003BDB1F644
&arr[4] = 00000003BDB1F648
&arr[5] = 00000003BDB1F64C
&arr[6] = 00000003BDB1F650
&arr[7] = 00000003BDB1F654
&arr[8] = 00000003BDB1F658
&arr[9] = 00000003BDB1F65C

从输出的结果我们分析,数组随着下标的增长,地址是由小到大变化的,并且我们发现每两个相邻的元素之间相差4(因为一个整型是4个字节)。所以我们得出结论:数组在内存中是连续存放的。这就为后期我们使用指针访问数组奠定了基础(在讲指针的时候我们在再讲,这里暂且记住就行)。

第6章第10页配图
第6章第10页配图

数组元素在内存中是连续存放的

6. 一维数组练习#

6.1 练习1#

编写代码,演示多个字符从两端移动,向中间汇聚比如,我想在屏幕上打印: ” welcome to bit!!! “这个字符串的内容但是打印的过程是一步步完成的,每次显示出2端的2个字符,逐渐向中间汇聚,直到全部字符都显示出来类似下面的效果:

课件代码 06-019 · PDF 第 11 页

#################
w###############!
we#############!!
wel###########!!!
....
welcome to bit!!!

课件代码 06-020 · PDF 第 11 页

#include <stdio.h>
#include <stdlib.h>
int main()
{
char arr1[] = "welcome to bit!!!";
char arr2[] = "#################";
int left = 0;
int right = strlen(arr1)-1;
printf("%s\n", arr2);
while(left <= right)
{
Sleep(1000);
arr2[left] = arr1[left];
arr2[right] = arr1[right];
left++;
right--;
printf("%s\n", arr2);
}
return 0;
}

6.2 练习2#

二分查找(折半查找)给定一个升序的整型数组,在这个数组中查找到指定的值n

  1. 如果找到了,就打印n的下标

  2. 如果找不到就打印:“找不到”

比如:

数组内容: 1 2 3 4 5 6 7 8 9 10找7时,就打印出:6找17时,就打印: 找不到

课件代码 06-021 · PDF 第 12 页

#include <stdio.h>
int main()
{
int arr[] = {1,2,3,4,5,6,7,8,9,10};
int left = 0;
int right = sizeof(arr)/sizeof(arr[0])-1;
int key = 7;//要找的数字
int mid = 0;//记录中间元素的下标
int find = 0;
while(left <= right)
{
mid = (left+right)/2;
if(arr[mid] > key)
{
right = mid-1;
}
else if(arr[mid] < key)
{
left = mid+1;
}
else
{
find = 1;
break;
}
}
if(1 == find)
printf("找到了,下标是%d\n", mid);
else
printf("找不到\n");
return 0;
}

第6章第13页配图
第6章第13页配图

求中间元素的下标,使用 mid = (left + right) / 2 ,如果left和right比较大的时候可能存在问题,可以使用下面的方式:

课件代码 06-022 · PDF 第 13 页

mid = left + (right - left) / 2;

7. 二维数组的创建#

7.1 二维数组的概念#

前面学习的数组被称为一维数组,数组的元素都是内置类型的,如果我们把一维数组做为数组的元素,这时候就是二维数组,二维数组作为数组元素的数组被称为三维数组,二维数组以上的数组统称为多维数组。

第6章第14页配图
第6章第14页配图

整型、整型一维数组、整型二维数组

7.2 二维数组的创建#

那我们如何定义二维数组呢?语法如下:

语法形式

课件代码 06-023 · PDF 第 14 页

type arr_name[常量值1][常量值2];
例如:
int arr[3][5];
double data[2][8];
  • 3表示数组有3行

  • 5表示每一行有5个元素

  • int 表示数组的每个元素是整型类型

  • arr 是数组名,可以根据自己的需要指定名字

8. 二维数组的初始化#

在创建变量或者数组的时候,给定一些初始值,被称为初始化。

那二维数组如何初始化呢?像一维数组一样,也是使用大括号初始化的。

8.1 不完全初始化#

课件代码 06-024 · PDF 第 15 页

int arr1[3][5] = {1, 2};
int arr2[3][5] = {0};

第6章第15页配图
第6章第15页配图

8.2 完全初始化#

课件代码 06-025 · PDF 第 15 页

int arr3[3][5] = {1,2,3,4,5, 2,3,4,5,6, 3,4,5,6,7};

第6章第15页配图
第6章第15页配图

8.3 按照行初始化#

课件代码 06-026 · PDF 第 16 页

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

第6章第16页配图
第6章第16页配图

8.4 初始化时省略行,但是不能省略列#

课件代码 06-027 · PDF 第 16 页

int arr5[][5] = {1,2,3};
int arr6[][5] = {1,2,3,4,5,6,7};
int arr7[][5] = {{1,2}, {3,4}, {5,6}};

第6章第16页配图
第6章第16页配图

9. 二维数组的使用#

9.1 二维数组的下标#

当我们掌握了二维数组的创建和初始化,那我们怎么使用二维数组呢?

其实二维数组访问也是使用下标的形式的,二维数组是有行和列的,只要锁定了行和列就能唯一锁定数组中的一个元素。

C语言规定,二维数组的行是从0开始的,列也是从0开始的,如下所示:

课件代码 06-028 · PDF 第 17 页

int arr[3][5] = {1,2,3,4,5, 2,3,4,5,6, 3,4,5,6,7};

第6章第17页配图
第6章第17页配图

图中最右侧绿色的数字表示行号,第一行蓝色的数字表示列号,都是从0开始的;比如,我们说:第2行,第4列,快速就能定位出7。

课件代码 06-029 · PDF 第 17 页

#include <stdio.h>
int main()
{
int arr[3][5] = {1,2,3,4,5, 2,3,4,5,6, 3,4,5,6,7};
printf("%d\n", arr[2][4]);
return 0;
}

输出的结果如下:

课件代码 06-030 · PDF 第 17 页

7

9.2 二维数组的输入和输出#

访问二维数组的单个元素了,那如何访问整个二维数组呢?

其实我们只要能够按照一定的规律产生所有的行和列的数字就行;以上一段代码中的arr数组为例,行的选择范围是02,列的取值范围是04,所以我们可以借助循环实现生成所有的下标。

课件代码 06-031 · PDF 第 17,18 页

#include <stdio.h>
int main()
{
int arr[3][5] = {1,2,3,4,5, 2,3,4,5,6, 3,4,5,6,7};
int i = 0;//遍历行
//输入
for(i = 0; i < 3; i++) //产生行号
{
int j = 0;
for(j = 0; j < 5; j++) //产生列号
{
scanf("%d", &arr[i][j]); //输入数据
}
}
//输出
for(i = 0; i < 3; i++) //产生行号
{
int j = 0;
for(j = 0; j < 5; j++) //产生列号
{
printf("%d ", arr[i][j]); //输出数据
}
printf("\n");
}
return 0;
}

输入和输出的结果:

第6章第18页配图
第6章第18页配图

10. 二维数组在内存中的存储#

像一维数组一样,我们如果想研究二维数组在内存中的存储方式,我们也是可以打印出数组所有元素的地址的。代码如下:

x64环境

课件代码 06-032 · PDF 第 18,19 页

#include <stdio.h>
int main()
{
int arr[3][5] = { 0 };
int i = 0;
int j = 0;
for (i = 0; i < 3; i++)
{
for (j = 0; j < 5; j++)
{
printf("&arr[%d][%d] = %p\n", i, j, &arr[i][j]);
}
}
return 0;
}

输出的结果:

课件代码 06-033 · PDF 第 19 页

&arr[0][0] = 00000073E4CFFB18
&arr[0][1] = 00000073E4CFFB1C
&arr[0][2] = 00000073E4CFFB20
&arr[0][3] = 00000073E4CFFB24
&arr[0][4] = 00000073E4CFFB28
&arr[1][0] = 00000073E4CFFB2C
&arr[1][1] = 00000073E4CFFB30
&arr[1][2] = 00000073E4CFFB34
&arr[1][3] = 00000073E4CFFB38
&arr[1][4] = 00000073E4CFFB3C
&arr[2][0] = 00000073E4CFFB40
&arr[2][1] = 00000073E4CFFB44
&arr[2][2] = 00000073E4CFFB48
&arr[2][3] = 00000073E4CFFB4C
&arr[2][4] = 00000073E4CFFB50

从输出的结果来看,每一行内部的每个元素都是相邻的,地址之间相差4个字节,跨行位置处的两个元素(如: arr[0][4] 和 arr[1][0] )之间也是差4个字节,所以二维数组中的每个元素都是连续存放的。

如下图所示:

第6章第20页配图
第6章第20页配图

二维数组的每一行在内存中连续存放如果把二维数组的第1行当作一个一维数组,数组名就是 arr[0] ,同理第2行的数组名就是arr[1] 。

了解清楚二维数组在内存中的布局,有利于我们后期使用指针来访问数组的学习。

11. 二数组练习#

11.1 随机点名程序#

  1. 班里有20名同学

  2. 现在需要一个程序,对20名同学随机点名

  3. 每次随机生成2个学生的名字

课件代码 06-034 · PDF 第 20,21 页

#include <stdio.h>
#include <stdlib.h>
#include <time.h>
int main()
{
// 学生名单
char students[20][10] =
{
"张三", "李四", "王五", "赵六", "小明",
"小红", "小刚", "小丽", "小华", "小强",
"张伟", "李芳", "王磊", "赵敏", "陈晨",
"刘洋", "孙丽", "周涛", "吴杰", "郑爽"
};
int index1 = 0;
int index2 = 0;
// 初始化随机数种子
srand((unsigned int)time(NULL));
// 生成两个不同的随机索引
do
{
index1 = rand() % 20;
index2 = rand() % 20;
} while (index1 == index2);
// 输出点名结果
printf("随机点名结果:\n");
printf("第一位同学(%d):%s\n", index1, students[index1]);
printf("第二位同学(%d):%s\n", index2, students[index2]);
return 0;
}

第6章第21页配图
第6章第21页配图

12. C99中的变长数组#

在C99标准之前,C语言在创建数组的时候,数组大小的指定只能使用常量、常量表达式,或者如果我们初始化数据的话,可以省略数组大小。

如:

课件代码 06-035 · PDF 第 21 页

int arr1[10];
int arr2[3+5];
int arr3[] = {1,2,3};

这样的语法限制,让我们创建数组就不够灵活,有时候数组大了浪费空间,有时候数组又小了不够用的。

C99中给一个变长数组(variable-length array,简称 VLA)的新特性,允许我们可以使用变量指定数组大小。

请看下面的代码:

课件代码 06-036 · PDF 第 22 页

int n = a + b;
int arr[n];

上面示例中,数组 arr 就是变长数组,因为它的长度取决于变量 n 的值,编译器没法事先确定,只有运行时才能知道 n 是多少。

变长数组的根本特征,就是数组长度只有运行时才能确定,所以变长数组不能初始化。它的好处是程序员不必在开发时,随意为数组指定一个估计的长度,程序可以在运行时为数组分配精确的长度。有一个比较迷惑的点,变长数组的意思是数组的大小是可以使用变量来指定的,在程序运行的时候,根据变量的大小来指定数组的元素个数,而不是说数组的大小是可变的。数组的大小一旦确定就不能再变化了。

遗憾的是在VS2022/2026上,默认的 msvc 编译器,虽然支持大部分 C99 的语法,却没有支持 C99中的变长数组的语法,没法测试;下面是我在gcc编译器上测试,可以看一下。

课件代码 06-037 · PDF 第 22 页

#include <stdio.h>
int main()
{
int n = 0;
scanf("%d", &n);//根据输入数值确定数组的大小
int arr[n];
int i = 0;
for (i = 0; i < n; i++)
{
scanf("%d", &arr[i]);
}
for (i = 0; i < n; i++)
{
printf("%d ", arr[i]);
}
return 0;
}

第一次测试,我给n中输入5,然后输入5个数字在数组中,并正常输出第二次测试,我给n中输入10,然后输入10个数字在数组中,并正常输出

第6章第23页配图
第6章第23页配图

🎈 AI提示词:关于变长数组,在使用的时候都有哪些注意事项呢?

如果想在VS2022/2026上测试变长数组,需要安装 clang 编译器,如下图所示:

第6章第23页配图
第6章第23页配图

13. AI加餐课#

  1. Vibe Coding的好与坏

课件中的参考链接#

支持与分享

如果这篇文章对你有帮助,欢迎分享给更多人或打赏支持!

打赏
C语言初阶 06:一维数组、二维数组与字符串
https://16888000.xyz/posts/c-beginner-06-arrays/
作者
小螺号
发布于
2026-11-14
许可协议
CC BY-NC-SA 4.0
Profile Image of the Author
小螺号
Hello, I'm LittleTrumpet.
公告
欢迎来到我的博客!这是一则示例公告。
分类
标签
最新动态
站点统计
文章
26
分类
4
标签
34
总字数
100,664
运行时长
0 天
最后活动
0 天前
站点信息
构建平台
Cloudflare Workers
博客版本
Firefly v6.16.8
文章许可
CC BY-NC-SA 4.0
文章目录