C 语 言 --- 数 组 (1)

💻作 者 简 介：曾 与 你 一 样 迷 茫，现 以 经 验 助 你 入 门 C 语 言
💡个 人 主 页：@笑口常开xpr 的 个 人 主 页
📚系 列 专 栏：C 启新程
✨代 码 趣 语：读 代 码 比 写 代 码 困 难。
💪代 码 千 行，始 于 坚 持，每 日 敲 码，进 阶 编 程 之 路。
📦gitee 链 接：gitee

       在 编 程 的 世 界 里，每 一 行 代 码 都 可 能 隐 藏 着 无 限 的 可 能 性 。你 是 否 想 过，一 个 小 小 的 程 序 究 竟 能 改 变 什 么？它 可 以 是 解 决 复 杂 问 题 的 工 具 ，也 可 以 是 实 现 梦 想 的 桥 梁。今 天，就 让 我 们 一 起 走 进 C 语 言 的 世 界，探 索 它 的 无 限 潜 力。

数 组

定义

         数 组 是 一 种 数 据 结 构，是 一 组 相 同 类 型 元 素 的 集 合。它 可 以 存 储 多 个 相 同 类 型 的 数 据 元 素，这 些 元 素 在 内 存 中 是 连 续 存 储 的。数 组 通 过 一 个 统 一 的 名 称 来 引 用，每 个 元 素 可 以 通 过 其 在 数 组 中 的 索 引 来 访 问。

一维数组

语 法 格 式

type arrayName[arraySize];

         其 中，type 是 数 组 中 元 素 的 类 型，可 以 是 基 本 数 据 类 型（如 int、float、char 等），也 可 以 是 自 定 义 数 据 类 型；arrayName 是 数 组 的 名 称，遵 循 变 量 命 名 规 则；arraySize 是 数 组 的 大 小，必 须 是 一 个 常 量 表 达 式，表 示 数 组 中 元 素 的 个 数。

         在 C99 标 准 之 前，C 语 言 在 创 建 数 组 的 时 候，数 组 ⼤ 小 的 指 定 只 能 使 ⽤ 常 量、常 量 表 达 式，C99 中 给 ⼀ 个 变 长 数 组，允 许 我 们 可 以 使 ⽤ 变 量 指 定 数 组 ⼤ 小。

         变 长 数 组 的 根 本 特 征：数 组 长 度 只 有 运 行 时 才 能 确 定，所 以 变 长 数 组 不 能 初 始 化。

         它 的 好 处 是 随 意 为 数 组 指 定 ⼀ 个 估 计 的 长 度，程 序 可 以 在 运 行 时 为 数 组 分 配 精 确 的 长 度。

下 面 展 示代码示例。

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

下 面 使 用 代 码 展 示数 组 是 如 何 创 建 的。

#include<stdio.h>
int main()
{int arr[20];char ch[8];return 0;
}

初始化

完 全 初 始 化

下 面 使 用 代 码 展 示数 组 的 完 全 初 始 化 。

#include <stdio.h>int main() 
{// 完全初始化一个包含5个整数的数组int numbers[5] = {1, 2, 3, 4, 5};return 0;
}

         在 上 面 的 代 码 中，定 义 了 一 个 整 型 数 组，名 称 为 numbers，并 将 整 型 数 组 中 的 元 素 初 始 化 为 1、2、3、4、5，数 组 的 大 小 为 5，意 味 着 它 可 以 容 纳 5 个 整 型 数 据。这 里 采 用 的 是 完 全 初 始 化 的 方 式，即 只 对 数 组 的 所 有 元 素 明 确 指 定 了 初 始 值。

不 完 全 初 始 化

下 面 使 用 代 码 展 示数 组 的 不 完 全 初 始 化 。

#include <stdio.h>
int main() 
{// 不完全初始化一个包含5个整数的数组，未初始化的元素默认值为0int numbers[5] = {1, 2};return 0;
}

         在 上 面 的 代 码 中，定 义 了 一 个 整 型 数 组，名 称 为 numbers，并 将 整 型 数 组 中 的 元 素 初 始 化 为 1、2，数 组 的 大 小 为 5，意 味 着 它 可 以 容 纳 5 个 整 型 数 据。这 里 采 用 的 是 不 完 全 初 始 化 的 方 式，即 只 对 数 组 的 前 两 个 元 素 明 确 指 定 了 初 始 值，对 于 未 显 式 初 始 化 的 后 三个 元 素，会 自 动 将 其 默 认 初 始 化 为 0。

省 略 数 组 大 小

下 面 使 用 代 码 展 示省 略 数 组 大 小。

#include <stdio.h>
int main() 
{// 省略数组大小，编译器会根据初始化列表的元素个数自动确定数组大小int numbers[] = {1, 2, 3, 4, 5};return 0;
}

不 初 始 化

         如 果 对 数 组 不 进 行 初 始 化，数 组 里 面 是 随 机 值。一 定 要 写 上 数 组 的 大 小，否 则 编 译 会 报 错。

下 面 使 用 代 码 展 示不 对 数 组 进 行 初 始 化。

#include <stdio.h>
int main() 
{int numbers[5];return 0;
}

使 用 memset 初 始 化

         memset 是 C 语 言 标 准 库 <string.h> 中 的 一 个 函 数，主 要 用 于 将 一 段 内 存 区 域 的 值 设 置 为 指 定 的 字 节 值。下 面 将 从 函 数 原 型 、参 数、返 回 值、功 能、使 用 示 例、注 意 事 项 等 方 面 详 细 介 绍 memset 函 数。

函 数 原 型

void *memset(void *s, int c, size_t n);

参 数

s：指 向 要 填 充 的 内 存 块 的 指 针，该 指 针 可 以 是 任 意 类 型，但 通 常 会 转 换 为 void* 类 型，以 支 持 不 同 类 型 的 内 存 块 操 作。
c：要 设 置 的 值，该 值 会 被 转 换 为 unsigned char 类 型。也 就 是 说，memset 是 以 字 节 为 单 位 进 行 填 充 的。
n：要 填 充 的 字 节 数，即 从 指 针 s 开 始 的 连 续 内 存 区 域 的 大 小。

返 回 值

返 回 指 向 s 的 指 针，这 样 可 以 方 便 进 行 链 式 操 作。

功 能

         memset 函 数 的 主 要 功 能 是 将 指 针 s 所 指 向 的 内 存 区 域 的 前 n 个 字 节 都 设 置 为 指 定 的 值 c。

下 面 展 示使 用 memset 对 数 组 进 行 初 始 化。

#include <stdio.h>
#include <string.h>int main() 
{int arr[5];// 将arr数组的前5个字节都设置为0memset(arr, 0, 5 * sizeof(int));for (int i = 0; i < 5; i++) {printf("%d ", arr[i]);}printf("\n");return 0;
}

注意：

         memset 是 以 字 节 为 单 位 进 行 填 充 的。当 对 整 型 数 组 等 非 字 符 类 型 数 组 进 行 操 作 时，要 特 别 注 意 这 一 点。例 如，将 一 个 整 型 数 组 使 用 memset 设 置 为 非 0 值 时，可 能 无 法 得 到 预 期 的 结 果。因 为 一 个 整 数 通 常 由 多 个 字 节 组 成，memset 会 将 每 个 字 节 都 设 置 为 指 定 的 值。

下 面 展 示使 用 memset 对 数 组 进 行 初 始 化。

#include <stdio.h>
#include <string.h>
int main() 
{int arr[5];// 将arr数组的前5个字节都设置为1memset(arr, 1, 5 * sizeof(int));for (int i = 0; i < 5; i++) {printf("%d ", arr[i]);}printf("\n");return 0;
}

整 数 在 内 存 中 的 存 储 方 式

1 个 字 节 = 8 个 比 特 位

         int 类 型 通 常 占 用 4 个 字 节（即 32 位）。每 个 字 节 由 8 位 二 进 制 数 表 示。当 使 用 memset 将 每 个 字 节 都 设 置 为 1 时，一 个 int 类 型 的 元素 在 内 存 中 的 存 储 情 况 如 下：

         一 个 字 节 的 二 进 制 表 示 为 0000 0001（十 进 制 为 1），而 一 个 int 类 型 有 4 个 字 节，那 么 这 个 int 类 型 元 素 在 内 存 中 的 二 进 制 表 示 就 是
0000 0001 0000 0001 0000 0001 0000 0001。化 为 十 进 制 是 16843009。

         而 当 值 是 0 时，那 么 这 个 int 类 型 元 素 在 内 存 中 的 二 进 制 表 示 就 是
0000 0000 0000 0000 0000 0000 0000 0000。化 为 十 进 制 是 0。

         memset 函 数 的 第 三 个 参 数 代 表 的 是 要 操 作 的 内 存 区 域 的 大 小，且 该 大 小 是 以 字 节 为 单 位 来 衡 量 的。对 于 一 个 数 组 而 言，其 占 用的 总 字 节 数 等 于 数 组 元 素 类 型 所 占 的 字 节 数 乘 以 数 组 的 元 素 个 数。因 此，在 上 述 代 码 里，memset 函 数 的 第 三 个 参 数 被 设 置 为 5 * sizeof(int)，这 里 的 5 是 数 组 的 元 素 个 数，sizeof(int) 则 是 int 类 型 元 素 所 占 的 字 节 数，二 者 相 乘 便 得 到 了 整 个 数 组 所 占 用 的 字 节 数。

类 型

数 组 的 类 型 是：去 掉 数 组 名 剩 下 的 是 类 型。

下 面 使 用 代 码 展 示数 组 的 类 型。

#include<stdio.h>
int main()
{int data1[5];//int --- 数组元素的类型//data1是数组名//数组的类型是:去掉数组名剩下的是类型,int [5]int data2[10];//data2的类型是int [10]return 0;
}

访 问 元 素

         在 C 语 言 中，数 组 元 素 的 访 问 是 通 过 下 标 实 现 的，这 个 下 标 相 当 于 数 组 元 素 的 编 号。下 标 需 放 在 方 括 号 [ ] 中。下 标 是 从 0 开 始 计 数 的。若 一 个 数 组 包 含 n 个 元 素，那 么 其 首 个 元 素 的 下 标 为 0，最 后 一 个 元 素 的 下 标 则 是 n - 1。数 组 元 素 的 操 作 是 逐 个 元 素 去 处 理的 , 没 办 法 一 次 性 输 入,也 没 办 法 一 次 性 输 出 ,必 须 使 用 循 环。

[ ] — 下 标 引 用 操 作 符

方 法 一：

下 面 展 示访 问 数 组 元 素。

#include<stdio.h>
int main()
{int i = 0;int arr[10];//输入数据for (i = 0;i < 10;i++){arr[i] = i;//将i的值依次存入数组}//输出数据for (i = 0;i < 10;i++){printf("%d ", arr[i]);}return 0;
}

方 法 二：

下 面 展 示使 用 指 针 访 问 数 组 元 素。

#include<stdio.h>
int main()
{int i = 0;int arr[10];//输入数据for (i = 0;i < 10;i++){arr[i] = i;//将i的值依次存入数组}//输出数据int* p = &arr[0];for (i = 0;i < 10;i++){printf("%d ", *(p + i));}return 0;
}

int* p = &arr[0];

         定 义 一 个 整 型 指 针 p，并 将 数 组 arr 的 第 一 个 元 素 的 地 址 赋 给 它。&arr[0] 表 示 取 数 组 arr 的 第 一 个 元 素 的 地 址，指 针 p 现 在 指 向 数 组 的 首 元 素。

printf("%d ", *(p + i));

         p + i 表 示 指 针 p 向 后 偏 移 i 个 元 素 的 位 置。由 于 p 指 向 数 组 的 首 元 素，p + i 就 指 向 数 组 的 第 i 个 元 素。

         *(p + i) 是 对 指 针 p + i 进 行 解 引 用 操 作，即 获 取 指 针 所 指 向 的 元 素 的 值。

数 组 的 大 小 可 以 通 过 计 算 得 到

下 面 展 示计 算 数 组 大 小。

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

代 码 解 释

         sizeof(arr) 计 算 的 是 整 个 数 组 arr 所 占 用 的 字 节 数。因 为 arr 是 一 个 包 含 5 个 int 类 型 元 素 的 数 组，在 常 见 的 32 位 或 64 位 系 统 中，int 类 型 通 常 占 用 4 个 字 节，所 以 sizeof(arr) 的 结 果 是 5 * 4 = 20 字 节。

         sizeof(arr[0]) 计 算 的 是 数 组 中 单 个 元 素（即arr[0]）所 占 用 的 字 节 数。由 于 arr 是 int 类 型 的 数 组，所 以 sizeof(arr[0]) 的 结 果 是 4 字 节。

         将 sizeof(arr) 除 以 sizeof(arr[0])，即 20 / 4，得 到 的 结 果 就 是 数 组 arr 中元 素 的 个 数。

一 维 数 组 在 内 存 中 的 存 储

下 面 展 示代码示例。

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

%p 是 格 式 控 制 符，用 于 输 出 一 个 指 针 的 值，也 就 是 元 素 的 地 址。

&arr[i] 表 示 取 数 组 arr 中 第 i 个 元 素 的 地 址。

         通 过 观 察 输 出 的 地 址，我 们 不 难 发 现 数 组 元 素 在 内 存 中 是 连 续 存 储 的，相 邻 元 素 的 地 址 差 值 通 常 等 于 sizeof(int)。即 4 个 字 节。

总结

       至 此，关 于 C 语 言 数 组 的 探 索 暂 告 一 段 落，但 你 的 编 程 征 程 才 刚 刚 启 航。写 代 码 是 与 机 器 深 度 对 话，过 程 中 虽 会 在 语 法、算 法 困 境 里 挣 扎，但 这 些 磨 砺 加 深 了 对 代 码 的 理 解。愿 你 合 上 电 脑 后，灵 感 不 断，在 C 语 言 的 世 界 里 持 续 深 耕，书 写 属 于 自 己 的 编 程 传 奇，下 一 次 开 启 ，定 有 全 新 的 精 彩 等 待。小 编 期 待 重 逢，盼 下 次 阅 读 见 你 们 更 大 进 步，共 赴 代 码 之 约！