数据结构学习笔记(郝斌老师).pdf

1、学 算 法 ， 不 要 想 着 自 己 能 够 完 完 整 整 的 自 己 编 一 个 算 法 ， 也 不 要 觉 得 自 己 想 不 出 来 就 备受 打 击 。只 要 能 看 懂 别 人 写 的 算 法 ， 然 后 反 复 地 自 己 敲 ， 反 反 复 复 地 出 错 ， 然 后 再 敲 ， 最 后 实 现能 够 把 这 个 程 序 敲 出 来 就 行 了 。看 懂 主 要 分 三 步 ： 1 看 懂 主 函 数 的 流 程 ； 2 明 确 每 一 个 子 函 数 的 功 能 ； 3 试 数 ， 就 是 自己 往 里 面 代 数 。总 搞 不 懂 ， 看 不 懂 地 算 法 ， 就 把

2、它 背 会 ， 然 后 反 复 想 ， 期 待 能 够 搞 定 （ 基 本 很 少 ， 但 有 ） 。数 据 结 构 研 究 的 就 是 个 体 的 存 储 和 个 体 与 个 体 之 间 关 系 的 存 储 问 题 ， 算 法 研 究 的 是 对 数 据 的操 作 问 题 ， 并 且 不 同 的 存 储 结 构 会 影 响 算 法 的 使 用 ， 举 个 简 单 的 例 子 ， 要 想 实 现 一 个 功 能 ，你 首 先 需 要 把 数 据 拿 出 来 ， 对 于 数 组 来 说 用 for 循 环 就 可 以 实 现 ， 但 对 于 链 表 就 不 可 以 了 ，所 以 说 算 法 依

3、附 于 存 储 数 据 的 结 构 ， 结 构 不 同 算 法 必 定 会 有 差 异(控 制 线 用 来 控 制 cpu 对 于 内 存 条 ， 是 只 读 还 是 只 写 ， 还 是 可 读 或 可 写 )两 个 指 针 变 量 之 间 只 可 以 相 减 ， 不 可 以 相 加 ， 相 乘 或 相 除 ， 因 为 这 样 的 运 算 无 意 义对 于 单 个 指 针 可 以 进 行 加 法 或 者 减 法 运 算 （ 自 增 ， 自 减 ）“指 向 同 一 块 连 续 空 间 的 不 同 存 储 单 元 ”这 个 要 求 存 在 ， 是 因 为 不 同 类 型 的 指 针 变 量 ， 相

4、减 无 意 义 ， 例 如 ， 一 个 保 存 的 是 整 型 的 地 址 ， 另 一 个 保 存 的 是 实 型 的 地 址 ， 相 减 干 啥 ？指 针 就 是 地 址 ， 计 算 机 里 的 地 址 值 就 是 编 号 ， 所 以 可 以 说 指 针 就 是 编 号 。Double 类 型 变 量 占 8 个 字 节 ， 一 个 字 节 占 8 位 ， 意 思 是 ， 一 个 字 节 可 以 存 放 8 个 0 或者 8 个 1 。一 个 字 节 用 一 个 地 址 表 示 （ 一 个 字 节 一 个 编 号 ） ， 那 么 double 类 型 变 量 因 为 占 8 个 字节 ， 那

5、 么 就 会 有 8 个 地 址 ， 那 么 指 针 中 究 竟 存 放 的 是 这 8 个 字 节 中 的 哪 个 地 址 呢 ？解 ： 对 于 变 量 来 说 ， 要 用 它 的 第 一 个 字 节 的 地 址 来 表 示 整 个 变 量 的 地 址 。 在 计 算 机 中 的 地址 总 线 中 用 3 2 根 线 （ 即 3 2 位 ） 来 存 储 变 量 在 内 存 中 所 占 首 字 节 的 地 址 ， 意 思 是 用 四 个 字 节来 存 储 某 变 量 首 字 节 的 地 址 。所 有 的 指 针 变 量 占 四 个 字 节 ， 这 意 味 着 ， 一 个 指 针 变 量 无 论

6、 它 指 向 的 变 量 占 多 大 的 字 节 ，它 永 远 只 占 四 个 字 节 。所 以 ， 指 针 中 究 竟 存 放 的 是 这 8 个 字 节 中 的 第 一 个 字 节 的 地 址 。据 此 ， 做 下 面 这 个 题问 两 次 输 出 的 q 相 差 多 少 ？答 ： 因 为 每 个 double 类 型 变 量 占 8 个 字 节 ， 一 个 字 节 用 一 个 地 址 来 表 示 ， 用 一 个 变 量 中 的首 地 址 （ 即 第 一 个 字 节 的 地 址 ） 来 表 示 变 量 的 地 址 。 意 味 着 两 个 double 类 型 变 量 之 间 有 8个 地

7、址 值 ， 所 以 两 个 地 址 值 应 该 相 差 8 ；运 行 结 果 ： 第 一 个 数 据 +8 等 于 第 二 个 数 据 。 （ 1 6 进 制 ）指 针 与 一 维 数 组# include int main(void) int a5 ; /a 是 数 组 名 5 是 数 组 元 素 的 个 数 元 素 就 是 变 量 a0 - a4 / int a3 4 ; /3 行 4 列 a0 0 是 第 一 个 元 素 aij第 i+1 行 j+1 列int b5 ;/a = b;/error a 是 常 量printf(“%#Xn“, printf(“%#Xn“, a);return

8、 0 ;/* 在 Vc+6 .0 中 的 输 出 结 果 是 :-0 X1 2 FF6 C0 X1 2 FF6 CPress any key to continue-总 结 ：一 维 数 组 名 一 维 数 组 名 是 个 指 针 常 量 ， 常 量 意 味 着 ， 其 值 不 可 以 被 改 变它 存 放 的 是 一 维 数 组 第 一 个 元 素 的 地 址*/指 针 变 量 ， 变 量 ， 这 两 种 变 量 的 “ 变 ” ， 一 定 要 好 好 理 解 ， 它 的 变 化 范 围 是 什 么 ， 变 化对 象 是 什 么 ， 一 定 要 搞 清 楚 。指 针 变 量 也 是 变 量

9、， 它 与 变 量 的 区 别 在 于 其 存 放 的 东 西 不 一 样 ， 这 就 意 味 着 变 化 的 对 象不 一 样 ； 以 及 变 化 的 范 围 不 同 。指 针 变 量 存 放 的 是 地 址 值 （ 为 什 么 要 经 常 用 字 母 p 来 表 示 一 个 指 针 变 量 ， 就 是 因 为 它 里面 存 放 的 是 地 址 值 ， 是 位 置 信 息 ， 英 文 单 词 position 的 首 字 母 为 p） ， 地 址 值 是 变 量 在 定 义时 计 算 机 赋 给 变 量 的 一 个 计 算 机 识 别 的 标 识 ， 它 的 值 是 计 算 机 编 好 的

10、一 系 列 的 编 号 。 所 以 ，指 针 变 量 的 变 化 范 围 就 是 那 些 所 有 的 地 址 值 编 号 ， 一 般 来 说 就 是 以 1 6 进 制 表 示 的 从 0 开 始的 一 系 列 的 数 。指 针 的 变 量 值 是 人 赋 予 的 那 些 数 据 ， 其 变 化 范 围 就 是 数 学 上 所 定 义 的 那 个 范 围 。语 法 程 序 举 例 1 ：# include int main(void)int * p; /p 是 变 量 的 名 字 , int * 表 示 p 变 量 存 放 的 是 int 类 型 变 量 的 地 址int i = 3 ;p =

11、 /OK/p = i; /error， 因 为 类 型 不 一 致 ， p 只 能 存 放 int 类 型 变 量 的 地 址 ， 不 能 存 放 int 类型 变 量 的 值/p = 5 5 ; /error 原 因 同 上return 0 ;程 序 举 例 2# include int main(void) int * p; /p是 变 量 的 名 字 , int * 表 示 p变 量 存 放 的 是 int类 型 变 量 的 地 址/int * p; 不 表 示 定 义 了 一 个 名 字 叫 做 *p的 变 量/ int * p; 应 该 这 样 理 解 : p是 变 量 名 , p变

12、 量 的 数 据 类 型 是 int *类 型/ 所 谓 int * 类 型 实 际 就 是 存 放 int变 量 地 址 的 类 型int i = 3;int j;p = /* 这 句 话 写 完 就 意 味 着 ：1. p保 存 了 i的 地 址 , 因 此 p指 向 i2. p不 是 i， i也 不 是 p， 更 准 确 的 说 ： 修 改 p的 值 不 影 响 i的 值 ， 修 改i的 值 也 不 会 影 响 p的 值3. 如 果 一 个 指 针 变 量 指 向 了 某 个 普 通 变 量 , 则*指 针 变 量 就 完 全 等 同 于 普 通 变 量例 子 :如 果 p是 个 指 针

13、 变 量 ， 并 且 p存 放 了 普 通 变 量 i的 地 址则 p指 向 了 普 通 变 量 i*p 就 完 全 等 同 于 i或 者 说 : 在 所 有 出 现 *p的 地 方 都 可 以 替 换 成 i在 所 有 出 现 i的 地 方 都 可 以 替 换 成 *p*p 就 是 以 p的 内 容 为 地 址 的 变 量*/j = *p; /等 价 于 j = i;printf(“i = %d, j = %dn“, i, j);return 0;程 序 举 例 3互 换 两 个 数 字# include void huhuan_1(int , int);void huhuan_2(int

14、*, int *);void huhuan_3(int *, int *);int main(void) int a = 3;int b = 5;huhuan_3( /huhuan_2(*p, *q); 是 错 误 的 , huhuan_1(a, b);也 是错 误 的 printf(“a = %d, b = %dn“, a, b);return 0;/不 能 完 成 互 换 功 能void huhuan_1(int a, int b) int t;t = a;a = b;b = t;return;/*主 函 数 的 a和 b与 该 被 调 函 数 的 a,b占 不 同 的 内 存 空 间 ，

15、 所 以 在 被 调 函 数 中 对 a和 b进 行 交 换 并 不 会 修 改 主 函 数 中 a和 b的 值 。 函 数 huhuan_1(int a, int b)的 形 参 为整 形 ， 这 意 味 着 只 是 将 主 函 数 中 的 a 和 b的 值 发 送 给 函 数 huhuan_1， 让 它 可 以 使 用 这个 变 量 的 值 ， 然 后 进 行 为 了 实 现 某 个 功 能 的 操 作 ， 其 操 作 结 果 不 会 影 响 主 函 数 中 a和 b的 值 。 */*全 局 变 量 的 生 存 期 是 伴 随 着 整 个 程 序 的 执 行 的局 部 变 量 的 生 存

16、期 是 伴 随 着 其 所 在 函 数 的 执 行 的所 以 ， 函 数 huhuan_1互 换 完 毕 后 ， 结 束 该 函 数 ， 然 后 返 回 主 函 数 ， 继 续 执 行 printf()语 句 ， 所 以 a和 b的 值 没 有 被 互 换 */不 能 完 成 互 换 功 能void huhuan_2(int * p, int * q) int * t;/如 果 要 互 换 p和 q的 值 ， 则 t必 须 是 int *,不 能 是 int,否 则 会 出错 t = p;p = q;q = t;/可 以 完 成 互 换 功 能void huhuan_3(int * p, in

17、t * q) intt;/如 果 要 互 换 *p和 *q的 值 , 则 t必 须 定 义 成 int,不 能 定 义 成 int*, 否则 语 法 出 错t = *p; /p是 int *, *p是 int*p = *q;*q = t;指 针 常 见 错 误 ：（ 这 个 程 序 跑 起 来 ， 语 法 上 不 会 报 错 ， 但 是 ，系 统 会 自 动 终 止 程 序 ， 因 为 这 样 的 错 误 太 弱 智 了 ， 系 统 还 是 可 以 识 别 出 来 的 ， 如 果 一 个 程 序能 够 躲 避 操 作 系 统 的 控 制 ， 在 内 存 中 捣 一 些 鬼 ， 这 些 程 序

18、就 是 病 毒 程 序 ）（ 这 个程 序 时 会 报 错 的 ， 因 为 ， *q 所 存 储 的 事 整 型 数 据 ， 而 p 存 放 的 是 整 型 地 址 ， 类 型 不 一 致 所以 编 译 的 时 候 就 会 报 错 。 ）（ 这 个 程 序 在 语 法 上 并 没 有 问 题 ， 但 是 ,操 作 系 统 只 允 许 程 序 操 作 已 经 开 辟 了 的 内 存 空 间 ，开 辟 了 的 存 储 空 间 就 属 于 该 程 序 的 天 地 ， 不 允 许 程 序 对 未 开 辟 的 不 属 于 这 个 程 序 的 天 地 进行 操 作 ， 例 如 读 写 操 作 ， 或 者

19、说 其 他 操 作 。 操 作 系 统 会 检 验 出 这 个 程 序 存 在 超 越 权 限 的 代码 ， 所 以 程 序 跑 起 来 时 会 被 操 作 系 统 报 错 ， 然 后 被 终 止 。 例 如 ， 具 体 来 说 就 是 ， int *q， 就为 q 变 量 开 辟 了 一 块 存 储 单 元 ， 这 一 块 存 储 空 间 就 属 于 这 个 程 序 的 天 地 ， 可 以 对 其 进 行 操 作 ，例 如 进 行 同 类 型 变 量 的 赋 值 等 操 作 、 p=q、 ， 但 是 ， printf(“%dn”,*q)， 因 为 q 变 量 存 储 的 是一 个 不 属 于

20、 该 程 序 天 地 的 一 块 存 储 单 元 的 地 址 ， *p 就 是 对 这 这 块 区 域 进 行 取 值 运 算 ， 就 属于 对 不 属 于 这 个 程 序 天 地 的 进 行 读 的 操 作 ， 这 样 的 操 作 是 不 被 操 作 系 统 允 许 的 ， ）指 针 最 复 杂 的 地 方 在 于 ： 1 .内 存 泄 漏 （ 内 存 越 用 越 少 ， 内 存 用 光 之 后 就 会 调 用 虚 拟 内 存 ， 如果 虚 拟 内 存 也 用 光 了 ， 机 子 就 死 机 了 ） ； 2 .野 指 针 （ 不 直 到 指 针 确 切 地 指 向 或 者 说 保 存 了 谁

21、的 地 址 。 ）（ 本 质 上 来 说 这 两 个 问 题 就 是 ， 你 怎 么 确 定 当 前 这 一 块 存 储 单 元 ， 有 多 少 个 指 针 变 量保 存 了 这 块 单 元 的 地 址 ， 因 为 一 块 存 储 空 间 在 一 个 大 型 的 程 序 中 会 有 好 多 个 指 针 指 向 它 ，如 果 一 次 都 不 释 放 就 会 导 致 内 存 泄 漏 ， 一 不 小 心 free 多 了 ， 程 序 就 会 挂 掉 。 ）当 前 学 c 语 言 的 指 针 ， 最 关 键 的 就 在 于 讲 动 态 内 存 ， 为 将 来 学 java,c#,c+准 备 ， 对 于

22、 一块 动 态 的 内 存 空 间 ， 用 完 之 后 就 需 要 进 行 释 放 ， 释 放 就 是 通 过 函 数 free(p)； 进 行 释 放 ， p是 指 向 该 内 存 的 一 个 指 针 变 量 。（ 这 个 图 中 有 三 个 指 针 变 量 指 向 了 一 块 动 态 的 内 存 空 间 ， 这 在 一 个 大 型 的 程 序 中 很 常 见 ， 那么 ， 这 个 时 候 如 果 再 写 一 个 free(q)， 整 个 程 序 就 会 挂 掉 。 同 一 个 空 间 被 释 放 两 次 ， 程 序 会 挂掉 。 ）要 想 在 自 定 义 函 数 中 改 变 主 函 数 中

23、 变 量 的 值 ， 就 需 要 把 变 量 的 地 址 值 作 为 实 参 传 递 给 形参 ， 因 为 指 针 变 量 就 是 用 来 存 放 变 量 的 地 址 值 的 ， 所 以 形 参 要 定 义 成 指 针 类 型 。 下 面 这 个 程序 中 把 通 过 传 递 i 变 量 的 地 址 值 ， 在 自 定 义 函 数 中 修 改 i 的 值 ， 就 对 i 的 值 进 行 了 改 变 。 f()函 数 把 指 针 变 量 p(实 参 )的 值 传 递 给 指 针 变 量 q（ 形 参 ） ， 相 当 于 给 指 针 变 量 q 赋 初值 ， 在 函 数 f()中 再 次 对 q

24、进 行 bidiaohanshu 了 赋 值 （ 这 种 强 制 转 换 ， 就 可 以 直 接 把 一 个 数转 换 为 地 址 值 ） ， 所 以 并 不 会 改 变 指 针 变 量 p 所 存 放 的 地 址 值 。要 想 在 自 定 义 函 数 中 改 变 主 函 数 中 指 针 变 量 的 值 ， 就 需 要 把 指 针 变 量 的 地 址 值 作 为 实 参传 递 给 形 参 ， 因 为 指 向 指 针 的 指 针 变 量 就 是 用 来 存 放 指 针 变 量 的 地 址 值 的 ， 所 以 形 参 要 定 义成 指 向 指 针 的 指 针 变 量 。 程 序 如 下 ：结 构

25、体 ：1 .为 什 么 会 出 现 结 构 体 ？在 c 语 言 中 ， 要 想 用 多 个 特 征 来 表 示 一 个 个 体 ， 只 能 通 过 结 构 体 来 表 示 。 例 如 ，要 想 表 示 学 生 这 个 数 据 ， 学 生 有 很 多 的 特 征 ： 名 字 ， 学 号 ， 姓 名 ， 性 别 等 ， 如 果 将这 些 特 征 一 一 单 独 表 示 ， 如 ， 当 学 生 个 数 多 的时 候 ， 就 会 混 乱 ， 无 法 满 足 现 实 需 求 。 这 个 时 候 就 需 要 把 这 若 干 个 特 征 组 合 在 一 起来 表 示 学 生 ， 这 种 表 示 学 生 这

26、 个 变 量 的 方 法 或 者 说 结 构 就 是 结 构 体 。为 了 表 示 一 些 复 杂 的 数 据 （ 为 了 模 拟 一 个 复 杂 的 事 物 ， 需 要 定 义 好 多 个 基 本 属性 在 它 的 身 上 ， 这 些 基 本 属 性 就 用 基 本 的 数 据 类 型 来 描 述 ） ， 单 个 的 普 通 基 本 数 据类 型 变 量 无 法 满 足 满 足 要 求 ， 而 将 单 个 的 普 通 基 本 类 型 变 量 组 合 到 一 起 ， 形 成 一 种新 的 数 据 类 型 ， 这 样 就 可 以 用 这 种 新 的 数 据 类 型 定 义 的 变 量 来 表 示

27、 这 一 系 列 的 复 杂的 数 据 。2 .什 么 叫 做 结 构 体 ？结 构 体 ， 是 用 户 根 据 实 际 需 要 ， 自 己 定 义 的 复 合 数 据 类 型 。结 构 体 不 是 变 量 ， 它 是 存 储 数 据 的 一 种 类 型 ， 只 不 过 这 种 类 型 是 由 整 型 int,字 符 型char， 实 型 double， 等 基 本 数 据 类 型 复 合 而 成 的 一 种 复 合 数 据 类 型 ， 其 实 结 构 体 就像 复 合 函 数 ， 基 本 数 据 类 型 （ 整 型 int,字 符 型 char， 实 型 double） 就 像 基 本 初

28、等 函数 ， 复 合 函 数 也 是 函 数 ， 你 不 能 说 它 不 是 函 数 ， 它 也 是 由 基 本 初 等 函 数 复 合 而 成 的 。在 结 构 体 中 ， 上 面 所 说 的 基 本 数 据 类 型 ， 或 者 说 是 理 解 的 基 本 初 等 函 数 ， 叫 做成 员 注 意 ， 这 个 数 据 类 型 的 名 字 包 括 前 面 的 struct,例 如 下 面 定 义 的 数 据 类 型， 在 给 这 个 复 合 数 据 类 型 定 义 变 量 的时 候 ， 不 能 写 成 Student=什 么 什 么 的 ， 而 要 写 成 struct Student 是 数

29、 据 类 型 （ 地 位 相当 于 是 int 或 者 double， 只 不 过 这 是 自 己 定 义 的 复 合 数 据 类 型 ） ， 尾 随 其 后 的 st是 变 量 名 。 赋 值 语 句 如 下单 个 变 量 要 用 括 起 来 ， 各 个 基 本 数 据 类 型 定 义 的 变 量 在 符 合 其 本 身 赋 值 条 件 下 要用 逗 号 隔 开 ； 当 然 ， 也 可 以 这 样 来 定 义 一 个 变 量 ， 形 式 为 ： “ 复 合 数 据 类 型 所 定 义的 变 量 名 +点 +基 本 数 据 类 型 定 义 的 变 量 名 ” （ 只 限 于 基 本 数 据 类

30、 型 为 非 字 符 型 的 变量 ） ， 例 如 中 第 二 个 st.name 的 赋 值 是 错 误的 ， 正 确 的 应 该 是例 1# include # include /是 为 了 能 够 使 用 strcpy 函 数/第 一 种 方 式struct Student int age;double score;char name1 0 0 ;int main(void) struct Student st = 8 0 , 6 6 .6 , “刘 昊 “; /初 始 化 定 义 的 同 时 赋 初 值 ,就 跟 数组 一 样 ， 定 义 的 时 候 可 以 全 部 赋 值struct

31、 Student st2 ;st2 .age = 1 0 ;st2 .score = 8 8 ;strcpy(st2 .name,“史 静 “);/st2 .name = “史 静 “;/error（ 这 个 问 题 是 c 语 言 的重 点 ， 字 符 串 的 处 理 ， 但 是 其 它 对 于 其 它 语 言 ， 这 并 不 重 要 ）printf(“%d %lf %sn“, st.age, st.score, st.name);printf(“%d %lf %sn“, st2 .age, st2 .score, st2 .name);return 0 ;例 2# include /第 一

32、 种 方 式struct Student int age;float score;char sex;int main(void) struct Student st = 8 0 , 6 6 .6 , F; /初 始 化 定 义 的 同 时 赋 初 值 ,就 跟 数 组 一样 ， 定 义 的 时 候 可 以 全 部 赋 值struct Student st2 ;/error st=8 0 ,6 6 .6 ,F;st2 .age = 1 0 ;st2 .score = 8 8 ;st2 .sex = F;printf(“%d %f %cn“, st.age, st.score, st.sex);p

33、rintf(“%d %f %cn“, st2 .age, st2 .score, st2 .sex);return 0 ;3 .怎 么 使 用 结 构 体 ？首 先 要 自 定 义 一 个 结 构 体 将 要 使用 的 基 本 数 据 类 型 放 到 括 号 里 面 ；其 次 是 用 这 个 数 据 类 型 定 义 变 量 ， 具 体 细 节 如 上 面 所 说 的 ；然 后 是 访 问 自 定 的 变 量 的 方 法 ： 有 两 种 方 式 来 访 问 结 构 体 基 本 变 量 ， 一 是 直 接访 问 ， 而 是 通 过 指 针 来 访 问 （ 注 ： 任 何 一 个 变 量 都 可 以

34、 通 过 这 两 种 方 法 来 进 行 访 问 ） ；因 为 是 复 合 的 数 据 类 型 ， 一 个 变 量 下 会 包 含 多 个 基 本 数 据 类 型 的 变 量 ， 所 以 需 要 在这 个 “ 复 合 的 变 量 名 ” 下 打 一 个 点 ， 再 在 后 面 写 出 基 本 数 据 类 型 所 定 义 的 变 量 名 ，形 式 为 ： “ 复 合 的 变 量 名 +点 +基 本 变 量 名 ” ， 才 可 以 实 现 引 用 复 合 数 据 类 型 变 量 中的 基 本 数 据 类 型 变 量 。 例 如 ：通 过 指 针 来 引 用 的 如 下解 释 ： 首 先 定 义 了

35、 一 个 自 己 定 义 的 数 据 类 型 的 指 针 变 量 ， 然 后 把 变 量 的 地 址 值给 了 这 个 指 针 变 量 （ 到 这 一 步 ， 和 通 过 指 针 来 访 问 基 本 数 据 类 型 变 量 的 方 法 一 致 ，区 别 就 在 下 一 步 ） ， 因 为 这 是 一 个 复 合 的 变 量 ， 所 以 按 照 规 定 有 了 两 种 如 下 的 通 过已 赋 值 指 针 变 量 引 用 结 构 体 基 本 变 量 的 方 法 1 是 “ 已 赋 值 指 针 变 量 名 +减 号 +大 于 号+基 本 变 量 名 ” 方 法 2 是 “ （ *已 赋 值 指 针

36、 变 量 名 ） +点 +基 本 变 量 名 ”这 一 部 分 说 的 比 较 啰 嗦 ：用 代 码 表 示 如 下2 中 少 写 了 这 种 方 式 “ （ *已 赋 值 指 针 变 量 名 ） +点 +基 本 变 量 名 ” 即 （ *pst） .sid# include /第 一 种 方 式struct Student int age;float score;char sex;int main(void) struct Student st = 8 0 , 6 6 .6 F, F; /初 始 化 定 义 的 同 时 赋 初 值struct Student * pst = /第 二 种 方

37、 式st.score = 6 6 .6 f; /第 一 种 方 式 6 6 .6 在 C 语 言 中 默 认 是 double 类 型 ， 如 果希 望 一 个 实 数 是 float类 型 ， 则 必 须 在 末 尾 加 f或 F, 因 此 6 6 .6 是 double, 6 6 .6 f或 6 6 .6 F是 floatprintf(“%d %fn“, st.age, pst-score);return 0 ;4 .注 意 事 项 ：1 .结 构 体 变 量 不 能 相 互 加 减 乘 除 ， 但 可 以 相 互 赋 值 ， 例 如 上 面 程 序 中 如 果 定 义了 st1 ,st2

38、 ,st3 三 个 变 量 ， 不 能 出 现 st3 =st1 +st2 ， 但 可 以 出 现 st3 =st12 .当 定 义 好 一 个 变 量 后 ， 无 论 有 没 有 进 行 赋 值 ， 计 算 机 都 会 根 据 变 量 的 数 据 类 应该 占 多 大 字 节 为 其 开 辟 存 储 空 间 。 没 有 赋 值 时 里 面 的 值 时 一 个 “ 垃 圾 值 （ 随 机值 ， 不 确 定 ， 没 有 用 ， 所 以 垃 圾 ， 哈 哈 哈 ） ”通 过 函 数 给 结 构 体 变 量 赋 值 （ 跟 给 基 本 变 量 赋 值 的 思 路 是 一 致 的 ， 只 不 过 在

39、表示 上 有 所 区 别 ， 因 为 结 构 体 变 量 包 含 了 若 干 个 基 本 变 量 ）通 过 函 数 给 引 用 结 构 体 变 量 ， 因 为 结 构 体 变 量 是 可 以 直 接 相 互 赋 值 的 ， 所 以 实参 可 以 是 结 构 体 变 量 st ， 将 相 当 于 给 形 参 st 赋 初 始 值 ；但 是 这 种 直 接 传 递 结 构 体 变 量 的 方 法 耗 内 存 ， 耗 时 间 所 以 一 般 不 采 用 ， 因 为 在实 参 传 递 给 形 参 时 至 少 要 传 递 所 有 结 构 体 变 量 中 的 基 本 变 量 所 占 的 字 节 ， 那 么

40、 多 数据 。 所 以 就 使 用 指 针 ， 直 接 传 递 结 构 体 变 量 的 地 址 （ 只 有 4 个 字 节 ， 相 比 于 直 接 传递 结 构 体 变 量 已 经 很 少 了 ,再 想 一 下 ， 如 果 定 义 的 是 一 个 整 形 变 量 ， 实 参 为 整 形 变量 的 地 址 与 变 量 名 ， 本 质 上 在 传 输 上 的 速 度 和 量 上 没 有 区 别 ， 因 为 地 址 和 整 形 变 量都 占 四 个 字 节 ） 就 可 以 实 现 调 用 。（ g2 (char sex;char name1 0 0 ; /分 号 不 能 省void InputStu

41、dent(struct Student *);void OutputStudent(struct Student *);int main(void) struct Student st ; /1 5 行/printf(“%dn“, sizeof(st);InputStudent( /对 结 构 体 变 量 输 入 必 须 发 送 st 的 地 址OutputStudent( /对 结 构 体 变 量 输 出 可 以 发 送 st的 地 址 也 可 以 直 接 发 送 st的 内 容但 为 了 减 少 内 存 的 耗 费 ， 也 为 了 提 高 执 行 速 度 ， 推 荐 发 送 地 址retu

42、rn 0 ;void OutputStudent(struct Student *pst)printf(“%d %c %sn“, pst-age, pst-sex, pst-name);void InputStudent(struct Student * pstu) /pstu 只 占 4 个 字 节(*pstu).age = 1 0 ;strcpy(pstu-name, “张 三 “);pstu-sex = F;/*/本 函 数 无 法 修 改 主 函 数 1 5 行 st 的 值 所 以 本 函 数 是 错 误 的void InputStudent(struct Student stu)

43、stu.age = 1 0 ;strcpy(stu.name, “张 三 “); /不 能 写 成 stu.name = “张 三 “;stu.sex = F;*/使 用 结 构 体 定 义 变 量 的 方 式 一 般 为 “ 结 构 体 类 型 名 +变 量 ” （ 如 下 所 示 ）但 是 结 构 体 类 型 名 过 长 ， 写 起 来 不 太 方 便 ， 所 以 就 要 用 发 到 typedef(已 有 数 据 类 型 名 +新 起的 数 据 类 型 名 )函 数 将 已 有 的 数 据 类 型 名 再 起 一 个 名 字 ， 新 起 的 数 据 类 型 名 等 价 于 其 前 面 的

44、数 据 类 型 名 ， 就 像 下 面 程 序 演 示 的 ：根 据 这 样 一 个 思 路 ， 借 用 typedef 函 数 就 可 以 把 新 定 义 的 复 合 数 据 类 型 结 构 体 类 型 名 简 写了 ：12 .3 .定 义 结 构 体 型 指 针 变 量小 结 ：(指 针 的 移 动 )动 态 内 存 和 静 态 内 存 的 比 较静 态 内 存 是 由 系 统 自 动 分 配 ， 由 系 统 自 动 释 放静 态 内 存 是 在 栈 分 配 的 ， 所 以 ， 随 着 函 数 执 行 完 毕 ， 其 也 就 被 释 放 了动 态 内 存 是 由 程 序 员 手 动 分 配

45、 ， 手 动 释 放动 态 内 存 是 在 堆 分 配 的 ， 所 以 ， 不 会 随 着 函 数 执 行 完 毕 后 ， 被 释 放 ， 因 此其 他 函 数 还 是 可 以 调 用 的 。为 了 在 程 序 运 行 过 程 中 动 态 地 分 配 一 块 内 存 ， 使 用 malloc()函 数 ， 实 现 动 态 分 配 内 存 ，如 果 不 够 ， 可 以 增 加 ， 如 果 用 完 了 ， 可 以 释 放 。/* 2 0 0 9 年 1 1 月 1 7 日 1 0 :2 1 :3 1malloc 是 memory(内 存 ) allocate(分 配 )的 缩 写*/# inclu

46、de # include /不 能 省int main(void) int i = 5 ; /分 配 了 4 个 字 节 静 态 分 配 1 1 行int * p = (int *)malloc(4 ); /1 2 行/* 1 . 要 使 用 malloc 函 数 ， 必 须 添 加 malloc.h 这 个 头 文 件2 . malloc 函 数 只 有 一 个 形 参 ， 并 且 形 参 是 整 型3 . 4 表 示 请 求 系 统 为 本 程 序 分 配 4 个 字 节4 . malloc 函 数 只 能 返 回 第 一 个 字 节 的 地 址5 . 1 2 行 分 配 了 8 个 字

47、节 , p 变 量 占 4 个 字 节 ， p 所 指 向 的 内 存 也占 4 个 字 节 6 . p 本 身 所 占 的 内 存 是 静 态 分 配 的 ， p 所 指 向 的 内 存 是 动 态 分 配的 */*p = 5 ; /*p 代 表 的 就 是 一 个 int 变 量 ， 只 不 过 *p 这 个 整 型 变 量 的 内 存 分配 方 式 和 1 1 行 的 i 变 量 的 分 配 方 式 不 同free(p); /freep(p)表 示 把 p 所 指 向 的 内 存 给 释 放 掉 p 本 身 的 内 存 是 静 态的 ， 不 能 由 程 序 员 手 动 释 放 ， p 本

48、 身 的 内 存 只 能 在 p 变 量 所 在 的 函 数 运 行 终 止 时 由系 统 自 动 释 放printf(“同 志 们 好 ！ n“);return 0 ;malloc()函 数 讲 解 ：这 个 函 数 使 用 ， 首 先 要 包 含 头 文 件 ；malloc 函 数 参 数 是 一 个 数 据 ， 这 个 数 据 决 定 你 要 请 求 操 作 系 统 为 你 开 辟 多 少 个 字 节 的 存储 单 元 (下 面 这 个 函 数 中 的 参 数 是 int 类 型 的 字 节 数 乘 以 要 重 新 定 义 的 数 组 的 长 度 ， 例 如 要 重新 定 义 一 个 长

49、 度 为 1 0 的 整 形 数 组 ， 就 需 要 操 作 系 统 重 新 开 辟 4 x1 0 个 字 节 。 )malloc 函 数 的 返 回 值 是 一 个 1 6 进 制 的 地 址 值 （ 开 辟 的 存 储 空 间 首 字 节 的 地 址 值 ） ， 这个 时 候 的 地 址 值 就 是 一 个 没 有 指 定 类 型 的 无 意 义 的 地 址 值 ， 或 者 叫 做 干 地 址 ， 因 为 整 型 变 量 ，实 型 变 量 的 地 址 值 都 是 这 样 的 值 ， 通 过 前 面 的 （ 基 本 数 据 类 型 名 +星 号 ） 进 行 强 制 类 型 转 换 ，因 为 是 地 址 值 所 以 要 在 类 型 名 后 加 一 个 星 号 （ 就 像 函 数 返 回 值