数组
- 介绍
- 一维数组
- 定义
- 应用方法
- 初始化
- 举例
- 示例
- 结果
- 二维数组
- 定义
- 应用方法
- 初始化
- 举例
- 示例
- 结果
- 字符数组
- 定义
- 应用方法
- 初始化
- 举例
- 示例
- 结果
- 分析
介绍
在C语言中，数组是一种基本的数据结构，用于存储一系列相同类型的数据。数组可以是多维的，最常见的是一维数组和二维数组。字符数组用于存储字符串。
一维数组
定义
一维数组是一系列数据的集合，每个数据都是相同类型的，可以通过索引来访问。
类型说明符 数组名[数组长度];
应用方法
- 初始化：可以在定义时初始化数组
- 访问：通过索引访问数组元素，索引从0开始
- 遍历：通常使用for循环来遍历数组
初始化
在C语言中，一维数组可以在声明时进行初始化。
以下是一些常见的初始化方法：
- 完全初始化：初始化时为数组的每个元素指定一个值
int arr[5] = {1, 2, 3, 4, 5}; // 所有元素都被初始化 - 部分初始化：初始化时只为数组的一部分元素指定值，未指定的元素自动初始化为0
int arr[5] = {1, 2}; // arr[0] = 1, arr[1] = 2, arr[2] = arr[3] = arr[4] = 0 - 省略数组大小：在初始化时可以省略数组的大小，编译器会根据初始化列表中的元素数量自动确定数组的大小
int arr[] = {1, 2, 3, 4, 5}; // 数组大小为5 - 指定初始化器：C99标准引入了指定初始化器，可以初始化数组的特定元素
int arr[5] = {[2] = 10, [4] = 20}; // arr[2] = 10, arr[4] = 20, 其他元素为0 - 字符串初始化：字符数组可以用字符串常量进行初始化，编译器会在字符串的末尾自动添加
\0（空字符）作为结束符char str[] = "Hello"; // 包含空字符'\0'，数组大小为6 - 零初始化：如果数组在声明时没有被显式初始化，那么其中的元素将自动初始化为0（对于整数和浮点数）或空字符（对于字符数组）
int arr[5]; // 所有元素都初始化为0
示例：
#include <stdio.h>
int main() {
int arr1[5] = {1, 2, 3, 4, 5}; // 完全初始化
int arr2[5] = {1, 2}; // 部分初始化
int arr3[] = {1, 2, 3, 4, 5}; // 省略数组大小
int arr4[5] = {[2] = 10, [4] = 20}; // 指定初始化器
char str[] = "Hello"; // 字符串初始化
printf("arr1: %d %d %d %d %d\n", arr1[0], arr1[1], arr1[2], arr1[3], arr1[4]);
printf("arr2: %d %d %d %d %d\n", arr2[0], arr2[1], arr2[2], arr2[3], arr2[4]);
printf("arr3: %d %d %d %d %d\n", arr3[0], arr3[1], arr3[2], arr3[3], arr3[4]);
printf("arr4: %d %d %d %d %d\n", arr4[0], arr4[1], arr4[2], arr4[3], arr4[4]);
printf("str: %s\n", str);
return 0;
}
结果：
！！！注意，数组的大小必须是一个整型常量表达式，这意味着数组的大小不能是变量！
举例
示例
#include <stdio.h>
int main() {
int numbers[5] = {1, 2, 3, 4, 5}; // 定义并初始化数组
int sum = 0;
// 遍历数组并计算元素之和
for (int i = 0; i < 5; i++) {
sum += numbers[i];
}
printf("数组元素之和为：%d\n", sum);
return 0;
}
结果
二维数组
定义
二维数组可以看作是数组的数组，即它由多个一维数组组成，通常用于表示表格或矩阵。
类型说明符 数组名[行数][列数];
应用方法
- 初始化：可以在定义时初始化二维数组。
- 访问：通过行索引和列索引访问数组元素。
- 遍历：通常使用嵌套的for循环来遍历二维数组。
初始化
在C语言中，二维数组可以在声明时进行初始化。
以下是一些常见的初始化方法：
- 完全初始化：初始化时为二维数组的每个元素指定一个值
int arr[2][3] = {{1, 2, 3}, {4, 5, 6}}; // 所有元素都被初始化 - 部分初始化：初始化时只为二维数组的一部分元素指定值，未指定的元素自动初始化为0
int arr[2][3] = {{1}, {2}}; // arr[0][0] = 1, arr[1][0] = 2, 其他元素为0 - 省略行大小：在初始化时可以省略数组的行大小，但列大小必须指定。编译器会根据初始化列表中的元素数量自动确定行的大小
int arr[][3] = {{1, 2, 3}, {4, 5, 6}}; // 自动确定为2行3列的数组 - 省略所有大小：如果两个维度都省略，则必须提供足够的初始化器来确定大小
int arr[][] = {{1, 2}, {3, 4}}; // 错误，至少需要指定一维的大小 - 逐个初始化：可以逐个为二维数组的元素指定值，而不必按照行的形式组织
int arr[2][3] = {1, 2, 3, 4, 5, 6}; // 等同于{{1, 2, 3}, {4, 5, 6}} - 零初始化：如果二维数组在声明时没有被显式初始化，那么其中的元素将自动初始化为0
int arr[2][3]; // 所有元素都初始化为0
示例：
#include <stdio.h>
int main() {
int arr1[2][3] = {{1, 2, 3}, {4, 5, 6}}; // 完全初始化
int arr2[2][3] = {{1}, {2}}; // 部分初始化
int arr3[][3] = {{1, 2, 3}, {4, 5, 6}}; // 省略行大小
int arr4[2][3] = {1, 2, 3, 4, 5, 6}; // 逐个初始化
int arr5[2][3]; // 零初始化
// 打印数组内容
for (int i = 0; i < 2; i++) {
for (int j = 0; j < 3; j++) {
printf("%d ", arr1[i][j]);
}
printf("\n");
}
printf("\n");
for (int i = 0; i < 2; i++) {
for (int j = 0; j < 3; j++) {
printf("%d ", arr2[i][j]);
}
printf("\n");
}
printf("\n");
for (int i = 0; i < 2; i++) {
for (int j = 0; j < 3; j++) {
printf("%d ", arr3[i][j]);
}
printf("\n");
}
printf("\n");
for (int i = 0; i < 2; i++) {
for (int j = 0; j < 3; j++) {
printf("%d ", arr4[i][j]);
}
printf("\n");
}
printf("\n");
for (int i = 0; i < 2; i++) {
for (int j = 0; j < 3; j++) {
printf("%d ", arr5[i][j]);
}
printf("\n");
}
return 0;
}
结果：
！！！注意，二维数组的第一维的大小可以省略（如果提供了足够的初始化器来确定行数），但第二维的大小必须指定！
举例
示例
#include <stdio.h>
int main() {
int matrix[2][3] = {{1, 2, 3}, {4, 5, 6}}; // 定义并初始化二维数组
int i, j;
// 遍历并打印二维数组
for (i = 0; i < 2; i++) {
for (j = 0; j < 3; j++) {
printf("%d ", matrix[i][j]);
}
printf("\n");
}
return 0;
}
结果
字符数组
定义
字符数组用于存储字符串，实际上是一个一维的字符集合。
char 数组名[长度];
应用方法
- 初始化：可以在定义时初始化字符数组。
- 访问：通过索引访问字符。
- 字符串操作：可以使用字符串库函数（如
strcpy,strlen,strcmp等）进行操作。
初始化
在C语言中，字符数组用于存储字符串，可以在声明时进行初始化。
以下是一些常见的初始化方法：
- 字符串初始化：使用双引号括起来的字符串常量来初始化字符数组。编译器会在字符串的末尾自动添加一个空字符
\0作为字符串的结束标志。char str[] = "Hello"; // 自动包含空字符'\0'，数组大小为6 - 字符初始化：使用单引号括起来的字符来初始化字符数组的每个元素。
char str[] = {'H', 'e', 'l', 'l', 'o', '\0'}; // 手动添加空字符，数组大小为6 - 部分初始化：初始化时只为字符数组的一部分元素指定值，未指定的元素自动初始化为空字符
\0。char str[10] = "Hello"; // str[0]到str[4]被初始化为'H', 'e', 'l', 'l', 'o'，其余为'\0' - 省略数组大小：在初始化时可以省略字符数组的大小，编译器会根据初始化列表中的元素数量自动确定数组的大小，并添加一个额外的元素用于存储空字符
\0。char str[] = "Hello"; // 自动确定为大小为6的数组 - 零初始化：如果字符数组在声明时没有被显式初始化，那么其中的元素将自动初始化为空字符
\0。char str[10]; // 所有元素都初始化为'\0'
示例：
#include <stdio.h>
int main() {
char str1[] = "Hello"; // 字符串初始化
char str2[] = {'H', 'e', 'l', 'l', 'o', '\0'}; // 字符初始化
char str3[10] = "Hello"; // 部分初始化
char str4[] = "Hello"; // 省略数组大小
char str5[10]; // 零初始化
printf("str1: %s\n", str1);
printf("str2: %s\n", str2);
printf("str3: %s\n", str3);
printf("str4: %s\n", str4);
// 打印str5的内容和长度
printf("str5: ");
for (int i = 0; i < 10; i++) {
printf("%c", str5[i]);
}
printf("\n");
return 0;
}
输出结果：
！！！注意，字符数组的大小必须足够容纳字符串中的所有字符以及空字符\0。如果数组大小小于字符串长度，则编译器不会添加空字符，这可能导致字符串处理函数的行为不确定！
举例
示例
#include <stdio.h>
#include <string.h>
int main() {
char greet[6] = "Hello"; // 定义并初始化字符数组
char message[20];
// 使用strcpy复制字符串
strcpy(message, "World");
strcat(greet, " ");
strcat(greet, message);
printf("拼接后的字符串：%s\n", greet);
printf("字符串长度：%zu\n", strlen(greet));
return 0;
}
结果
分析
在上述示例中，字符数组greet被初始化为"Hello"，然后使用strcat函数将message的内容连接到greet后面，最终输出拼接后的字符串及其长度。
