【C语言/C++干货系列】你真的了解数组吗？-优快云博客

前言

一维数组

二维数组

字符数组

尾声

点击👇领取20+精品游戏

我不允许还有人不知道我的一个精品资源：良心商家C++小游戏合集，真的超棒的！

内涵20+精选游戏，均可在DEV C++运行！代表作：

无尽之剑5.0【限定版】 超级升级！新增了非常多功能！战斗界面全新更新（1000+行有效代码）

丧失危机2【存档版】可以存档啦！剧情一波三折，非常刺激！（1900+行有效代码）

愤怒的小鸟【图形界面版】 图形界面？泰库辣！玩一个下午都不会腻！（400+行有效代码）

价格只需要 5 积分！

性价比超越%99的资源！

购买链接🔗：

良心商家C++小游戏合集https://download.youkuaiyun.com/download/class_x/89470226?spm=1001.2014.3001.5503

前言

在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];



#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;
}

结果

数组元素之和为：15

二维数组

定义

二维数组可以看作是数组的数组，即它由多个一维数组组成，通常用于表示表格或矩阵。

类型说明符 数组名[行数][列数];

应用方法
初始化：可以在定义时初始化二维数组。
访问：通过行索引和列索引访问数组元素。
遍历：通常使用嵌套的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后面，最终输出拼接后的字符串及其长度。