数组
- 介绍
- 一维数组
- 定义
- 应用方法
- 初始化
- 举例
- 示例
- 结果
- 二维数组
- 定义
- 应用方法
- 初始化
- 举例
- 示例
- 结果
- 字符数组
- 定义
- 应用方法
- 初始化
- 举例
- 示例
- 结果
- 分析
介绍
在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
后面,最终输出拼接后的字符串及其长度。