C 语 言 --- 函 数

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

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

函 数

定 义

       函 数 是 一 段 完 成 特 定 任 务 的 独 立 代 码 块，它 可 以 接 收 输 入 参 数， 经 过 一 系 列 的 处 理 后 返 回 一 个 结 果 。在 C 语 言 中，函 数 就 像 是 一 个 小 型 的 程 序，有 自 己 的 输 入 和 输 出。

分 类

库 函 数
自 定 义 函 数

库 函 数

定 义

         C 语 言 的 库 函 数 是 C 语 言 的 重 要 组 成 部 分，它 定 义 了 一 系 列 的 标 准 头 文 件 和 对 应 的 库 函 数 。这 些 库 函 数 可 以 分 为 多 个 类 别 ，每 个 类 别 都 有 其 特 定 的 用 途 。 要 使 用 标 准 库 函 数，只 需 要 在 代 码 中 包 含 相 应 的 头 文 件 即 可。

分 类

I O 函 数
字 符 串 操 作 函 数
字 符 操 作 函 数
内 存 操 作 函 数
时 间 / 日 期 函 数
数 学 函 数
其 他 库 函 数

学 会 使 用 库 函 数

         对 于 库 函 数，读 者 无 需 死 记 硬 背 全 部 内 容，只 需 熟 练 掌 握 常 用 部 分 即 可。在 学 习 库 函 数 过 程 中，推 荐 以 英 文 文 档 作 为主 要 参 考 资 料，并 借 助 翻 译 软 件，这 样 能 更 准 确 地 理 解 函 数 的 使 用 方 法 和 特 点 。
网 站 1
网 站 2
网 站 3
网 易 有 道 翻 译

自 定 义 函 数

定 义

         自 定 义 函 数 是 程 序 员 根 据 自 己 的 需 求 编 写 的 一 段 具 有 特 定 功 能 的 代 码 块。它 就 像 一 个 小 型 的 程 序，有 自 己 的 输 入（参 数）和 输 出（返 回 值），可 以 在 程 序 的 不 同 地 方 被 多 次 调 用。自 定 义 函 数 和 库 函 数 一 样，有 函 数 名，返 回 值 类 型 和 函 数 参 数。但 是 不 一 样 的 是 这 些 都 是我 们 自 己来 设 计。这 给 程 序 员 一 个 很 大 的 发 挥 空 间。

基 本 结 构

       自 定 义 函 数 的 基 本 结 构 包 括 返 回 类 型 、函 数 名、参 数 列 表 和 函 数 体，其 语 法 格 式 如 下 ：

返 回 类 型  函 数 名(参 数 列 表) 
{
    //函数体
    //一系列的语句
    return //返回值; 如果返回类型为void，则可以省略return语句
}

返 回 类 型：指 定 函 数 执 行 完 毕 后 返 回 值 的 类 型，如 int、float、char 等。如 果 函 数 不 返 回 任 何 值，则 使 用 void 类 型。

函 数 名 ：是 函 数 的 标 识 符，用 于 在 程 序 中 调 用 该 函 数。函 数 名 应 遵 循 标 识 符 的 命 名 规 则，且 要 具 有 一 定 的 描 述 性，以 便 于 理 解 函 数 的 功 能。

参 数 列 表：是 函 数 接 收 的 输 入 值，参 数 之 间 用 逗 号 分 隔。每 个 参 数 由 参 数 类 型 和 参 数 名 组 成。这 里 的 参 数 名 可 以 和 主 函 数 的 参 数 名 相 同。如 果 函 数 不 需 要 接 收 任 何 参 数，则 参 数 列 表 可 以 为 空，或 者 使 用 void 表 示。

函 数 体：是 函 数 的 具 体 实 现 部 分，包 含 了 一 系 列 的 语 句，用 于 完 成 特 定 的 任 务。函 数 体 需 要 用 花 括 号 { } 括 起 来。

返 回 值：通 过 return 语 句 将 函 数 的 计 算 结 果 返 回 给 调 用 者。返 回 值 的 类 型 必 须 与 函 数 定 义 的 返 回 类 型 一 致。

下 面 举 一 个 例 子 帮 助 读 者 理 解 函 数 的 使 用 方 法。

写 一 个 函 数 可 以 找 出 两 个 整 数 中 的 最 大 值。

下 面 展 示代码示例。

#include<stdio.h>
int Max(int x, int y)
{
	if (x > y)
	{
		return x;
	}
	else
	{
		return y;
	}
}
int main()
{
	int num1 = 0;
	int num2 = 0;
	scanf("%d %d", &num1, &num2);
	int max = Max(num1, num2);
	printf("%d\n", max);
	return 0;
}

函 数 的 参 数

形 式 参 数（ 形 参）

定 义

         形 式 参 数 又 被 称 为 形 参，是 在 定 义 函 数 时 声 明 的 参 数。它 出 现 在 函 数 定 义 的 参 数 列 表 中 ，就 像 是 函 数 内 部 的 一 个 占 位 符，用 于接 收 调 用 该 函 数 时 传 递 进 来 的 数 据 。形 参 在 函 数 定 义 时 并 不 占 用 实 际 的 内 存 空 间 ，只 有 在 函 数 被 调 用 时，系 统 才 会 为 其 分 配 内存。形 式 参 数 当 函 数 调 用 完 成 之 后 就 自 动 销 毁 了。因 此 形 式 参 数 只 在 函 数 中 有 效。

语 法 形 式

       形 参 的 语 法 形 式 为：数 据 类 型    形 参 名。多 个 形 参 之 间 用 逗 号 分 隔。例 如 在 上 面 的 例 子 中 x，y 是 形 式 参 数。int 是 形 参 的 数 据 类 型。

形 参 的 作 用 域 和 生 命 周 期

         形 参 的 作 用 域 仅 限 于 定 义 它 的 函 数 内 部，也 就 是 说，在 函 数 外 部 无 法 直 接 访 问 形 参。形 参 的 生 命 周 期 从 函 数 被 调 用 开 始，到 函 数 执 行 结 束 时 结 束。当 函 数 执 行 完 毕，形 参 所 占 用 的 内 存 空 间 会 被 释 放。

实 际 参 数 ( 实 参 )

定义

         实 参，即 实 际 参 数，是 在 调 用 函 数 时 传 递 给 函 数 的 具 体 数 据。它 可 以 是 常 量、变 量、表 达 式 等。实 参 在 函 数 调 用 时 会 将 其 值 传 递 给 对 应 的 形 参。

读 者 也 可 以 这 样 认 为 形 参 相 当 于 实 参 的 一 份 临 时 拷 贝。

实参的传递方式

         实 参 在 传 递 给 形 参 时，会 根 据 不 同 的 情 况 采 用 不 同 的 传 递 方 式，常 见 的 有 值 传 递 和 地 址 传 递。

值传递

         值 传 递 是 C 语 言 中 最 常 用 的 参 数 传 递 方 式。在 值 传 递 过 程 中 ，实 参 的 值 会 被 复 制 一 份 传 递 给 形 参，函 数 内 部 对 形 参 的 修 改 不 会 影 响 到 实 参 本 身。

下 面 展 示代码示例。

#include <stdio.h>

void changeValue(int x) 
{
    x = 10;
    printf("change_value: x = %d\n", x);
}

int main() 
{
    int num = 5;
    printf("Before_value: num = %d\n", num);
    changeValue(num);
    printf("After_value: num = %d\n", num);
    return 0;
}

输 出 结 果 是：

        在 这 个 例 子 中，num 是 实 参，x 是 形 参。调 用 changeValue 函 数 时，num 的 值 5 被 复 制 给 x，在 函 数 内 部 将 x 的 值 修 改 为 10，但 这 并 不 会 影 响 到 num 的 值，所 以 函 数 调 用 结 束 后，num 的 值 仍 然 是 5。

地址传递

         地 址 传 递 是 将 实 参 的 地 址 传 递 给 形 参，形 参 通 过 这 个 地 址 可 以 直 接 访 问 和 修 改 实 参 所 指 向 的 内 存 空 间 中 的 数 据。

下 面 展 示代码示例。

#include <stdio.h>

void changeValue(int* x) 
{
    *x = 10;
    printf("change_value: *x = %d\n", *x);
}

int main() 
{
    int num = 5;
    printf("Before_value: num = %d\n", num);
    changeValue(&num);
    printf("After_value: num = %d\n", num);
    return 0;
}

输 出 结 果 是：

取 地 址 符 &

基 本 含 义

         &是 取 地 址 运 算 符，它 的 主 要 作 用 是 获 取 变 量 在 内 存 中 的 地 址。 在 计 算 机 内 存 中，每 个 变 量 都 有 一 个 唯 一 的 存 储 位 置，这 个 位 置 由 一 个 地 址 来 标 识。通 过 & 运 算 符，我 们 可 以获 取 到 变 量 的 这 个 地 址。

语 法 形 式

& 运 算 符 通 常 紧 跟 在 变 量 名 之 前，其 语 法 形 式 为 & 变 量 名。

间 接 寻 址 运 算 符 *

基 本 含 义

       作 为 间 接 寻 址 运 算 符（ 也 称 为 解 引 用 运 算 符），它 的 作 用 与 & 相 反。& 是 获 取 变 量 的 地 址，而 * 是 通 过 指 针 访 问 指 针 所 指 向 的 内 存 地 址 中 的 值。

语 法 形 式

运 算 符 * 通 常 紧 跟 在 指 针 变 量 名 之 前，其 语 法 形 式 为 * 指 针 变 量名。

现 在 回 到 这 个 例 子 ，&num 是 实 参，它 是 num 的 地 址；x 是 形 参，它 是 一 个 指 针，指 向 num 的 内 存 地 址。在 函 数 内 部，通 过 *x 可 以 直 接 修 改 num 的 值，所 以 函 数 调 用 结 束 后，num 的 值 变 为 10。

实 参 的 类 型 和 数 量 要 求

         实 参 的 类 型 必 须 与 形 参 的 类 型 相 匹 配，否 则 可 能 会 导 致 编 译 错 误 或 运 行 时 错 误。同 时，实 参 的 数 量 必 须 与 形 参 的 数 量 一 致，按 照 顺 序 一 一 对 应 传 递。

实 参 和 形 参 的 关 系

数 据 传 递 关 系

       实 参 和 形 参 之 间 是 一 种 数 据 传 递 的 关 系，实 参 将 数 据 传 递 给 形 参，使 得 函 数 能 够 使 用 这 些 数 据 进 行 相 应 的 计 算 和 处 理。

独 立 性 与 关 联 性

         虽 然 实 参 和 形 参 在 名 称 上 可 以 相 同，但 它 们 是 相 互 独 立 的 变 量。在 值 传 递 中，它 们 只 是 值 相 同；在 地 址 传 递 中，形 参 通 过 地 址 与 实 参 关 联 起 来，可 以 对 实 参 进 行 修 改。

函 数 的 嵌 套 调 用

定 义

         函 数 的 嵌 套 调 用 是 指 在 一 个 函 数 的 定 义 或 执 行 过 程 中，调 用 了 另 一 个 函 数。简 单 来 说 ，就 是 在 一 个 函 数 内 部 调 用 其 他 函数，当 然 也 可 以 函 数 自 己 调 用 自 己，形 成 函 数 调 用 的 嵌 套 结 构。

注意：
函数可以嵌套调用，但是不能嵌套定义。

下 面 展 示代码示例。

#include <stdio.h>

// 定义函数B
int functionB(int a, int b) 
{
    return a + b;
}

// 定义函数A,在函数A中调用函数B
int functionA(int x, int y) 
{
    int result = functionB(x, y);
    return result * 2;
}

int main() 
{
    int num1 = 3;
    int num2 = 5;
    int finalResult = functionA(num1, num2);
    printf("final_result = %d\n", finalResult);
    return 0;
}

输 出 结 果 是：

代 码 解 释

functionB 函 数：该 函 数 接 收 两 个 整 数 参 数 a 和 b，返 回 它 们 的 和。
functionA 函 数：在 functionA 函 数 内 部 调 用 了 functionB 函 数，将 x 和 y 作 为 参 数 传 递 给 functionB，并 将 functionB 的 返 回 值 乘 以 2 后 返 回。
main 函 数：调 用 functionA 函 数，并 将 结 果 存 储 在 final_Result 变 量 中，最 后 输 出 结 果。

嵌 套 调 用 的 执 行 流 程

         当 程 序 执 行 到 functionA 函 数 内 部 的 functionB(x, y) 时，程 序 会 暂 停 functionA 的 执 行，转 而 执 行 functionB 函 数。当 functionB 函 数 执 行 完 毕 并 返 回 结 果 后，程 序 会 回 到 functionA 函 数 中 调 用 functionB 的 位 置，继 续 执 行 后 续 代 码。

函 数 的 链 式 访 问

定 义

         函 数 的 链 式 访 问 是 指 将 一 个 函 数 的 返 回 值 作 为 另 一 个 函 数 的 参 数 进 行 调 用，形 成 一 个 连 续 的 函 数 调 用 链。这 种 方 式 可 以 让 代 码 更 加 简 洁 ，避 免 使 用 中 间 变 量 来 存 储 函 数 的 返 回 值。

下 面 展 示代码示例。

#include <stdio.h>

//将输入的整数乘以2
int multiply_Two(int num) 
{
    return num * 2;
}

//将输入的整数加上5
int add_Five(int num) 
{
    return num + 5;
}

//将输入的整数除以3并返回整数部分
int divide_Three(int num) 
{
    return num / 3;
}

int main() 
{
    int num = 9;
    //链式访问：将函数的返回值依次作为下一个函数的参数
    //先调用multiply_Two,再将结果传入add_Five
    //最后将add_Five的结果传入divide_Three
    //最终将divide_Three的结果作为printf的参数输出
    printf("final_result = %d\n", divide_Three(add_Five(multiply_Two(num))));
    return 0;
}

输 出 结 果 是：

代 码 解 释

         首 先 定 义 了 三 个 自 定 义 函 数 multiply_Two、add_Five 和 divide_Three，分 别 实 现 将 整 数 乘 以 2、加 上 5、除 以 3 的 功 能。

在 main 函 数 中，设 定 了 初 始 数 字 num 为 9。

         然 后 进 行 函 数 的 链 式 访 问，按 照 从 内 层 到 外 层 的 顺 序，先 调 用 multiply_Two 函 数 对 num 进 行 处 理，将 其 返 回 值 作 为 参 数 传 递 给 add_Five 函 数，add_Five 函 数 的 返 回 值 又 作 为 参 数 传 递 给 divide_Three 函 数，最 后 divide_Three 函 数 的 返 回 值 作 为 printf 函 数 的 参 数 被 输 出。

注 意 事 项

         函 数 返 回 值 类 型 匹 配：在 进 行 链 式 访 问 时，要 确 保 前 一 个 函 数 的 返 回 值 类 型 与 后 一 个 函 数 的 参 数 类 型 相 匹 配，否 则 会 导 致 编 译 错 误。

         执 行 顺 序：链 式 访 问 是 从 内 到 外 依 次 执 行 函 数 调 用，即 先 执 行 最 内 层 的 函 数，将 其 返 回 值 作 为 外 层 函 数 的 参 数，然 后 继 续 执 行 外 层 函 数，以 此 类 推。

总结

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