1 C 语 言 概 述... 7 1.1 C 语 言 的 发 展 过 程... 7 1.2 当 代 最 优 秀 的 程 序 设 计 语 言... 7 1.3 C 语 言 版 本... 7 1.4 C 语 言 的 特 点... 7 1.5 面 向 对 象 的 程 序 设 计 语 言... 8 1.6 C 和 C++... 8 1.7 简 单 的 C 程 序 介 绍... 8 1.8 输 入 和 输 出 函 数... 9 1.9 C 源 程 序 的 结 构 特 点... 10 1.10 书 写 程 序 时 应 遵 循 的 规 则... 11 1.11 C 语 言 的 字 符 集... 11 1.12 C 语 言 词 汇... 11 1.13 Turbo C 2.0 集 成 开 发 环 境 的 使 用... 12 1.13.1 Turbo C 2.0 简 介 和 启 动... 12 1.13.2 Turbo C 2.0 集 成 开 发 环 境... 13 1.13.3 File 菜 单... 13 1.13.4 Edit 菜 单... 14 1.13.5 Run 菜 单... 15 1.13.6 Compile 菜 单... 16 1.13.7 Project 菜 单... 18 1.13.8 Options 菜 单... 19 1.13.9 Debug 菜 单... 22 1.13.10Break/watch 菜 单... 23 1.13.11Turbo C 2.0 的 配 置 文 件... 24 2 程 序 的 灵 魂 算 法... 24 2.1 算 法 的 概 念... 24 2.2 简 单 算 法 举 例... 25 2.3 算 法 的 特 性... 27 2.4 怎 样 表 示 一 个 算 法... 27 2.4.1 用 自 然 语 言 表 示 算 法... 27 2.4.2 用 流 程 图 表 示 算 法... 27 2.4.3 三 种 基 本 结 构 和 改 进 的 流 程 图... 31 2.4.4 用 N-S 流 程 图 表 示 算 法... 32 2.4.5 用 伪 代 码 表 示 算 法... 33 2.4.6 用 计 算 机 语 言 表 示 算 法... 34 2.5 结 构 化 程 序 设 计 方 法... 34 3 数 据 类 型 运 算 符 与 表 达 式... 35 3.1 C 语 言 的 数 据 类 型... 35 3.2 常 量 与 变 量... 37 3.2.1 常 量 和 符 号 常 量... 37 3.2.2 变 量... 38 3.3 整 型 数 据... 38 3.3.1 整 型 常 量 的 表 示 方 法... 38 第 1 页
3.3.2 整 型 变 量... 39 3.4 实 型 数 据... 42 3.4.1 实 型 常 量 的 表 示 方 法... 42 3.4.2 实 型 变 量... 43 3.4.3 实 型 常 数 的 类 型... 44 3.5 字 符 型 数 据... 44 3.5.1 字 符 常 量... 44 3.5.2 转 义 字 符... 44 3.5.3 字 符 变 量... 45 3.5.4 字 符 数 据 在 内 存 中 的 存 储 形 式 及 使 用 方 法... 45 3.5.5 字 符 串 常 量... 46 3.6 变 量 赋 初 值... 47 3.7 各 类 数 值 型 数 据 之 间 的 混 合 运 算... 47 3.8 算 术 运 算 符 和 算 术 表 达 式... 49 3.8.1 C 运 算 符 简 介... 49 3.8.2 算 术 运 算 符 和 算 术 表 达 式... 49 3.9 赋 值 运 算 符 和 赋 值 表 达 式... 51 3.10 逗 号 运 算 符 和 逗 号 表 达 式... 53 3.11 小 结... 54 3.11.1 C 的 数 据 类 型... 54 3.11.2 基 本 类 型 的 分 类 及 特 点... 54 3.11.3 常 量 后 缀... 54 3.11.4 常 量 类 型... 54 3.11.5 数 据 类 型 转 换... 54 3.11.6 运 算 符 优 先 级 和 结 合 性... 54 3.11.7 表 达 式... 55 4 最 简 单 的 C 程 序 设 计 顺 序 程 序 设 计... 55 4.1 C 语 句 概 述... 55 4.2 赋 值 语 句... 56 4.3 数 据 输 入 输 出 的 概 念 及 在 C 语 言 中 的 实 现... 57 4.4 字 符 数 据 的 输 入 输 出... 58 4.4.1 putchar 函 数 ( 字 符 输 出 函 数 )... 58 4.4.2 getchar 函 数 ( 键 盘 输 入 函 数 )... 58 4.5 格 式 输 入 与 输 出... 59 4.5.1 printf 函 数 ( 格 式 输 出 函 数 )... 59 4.5.2 scanf 函 数 ( 格 式 输 入 函 数 )... 62 4.6 顺 序 结 构 程 序 设 计 举 例... 65 5 分 支 结 构 程 序... 67 5.1 关 系 运 算 符 和 表 达 式... 67 5.1.1 关 系 运 算 符 及 其 优 先 次 序... 67 5.1.2 关 系 表 达 式... 67 5.2 逻 辑 运 算 符 和 表 达 式... 68 5.2.1 逻 辑 运 算 符 极 其 优 先 次 序... 68 5.2.2 逻 辑 运 算 的 值... 68 第 2 页
5.2.3 逻 辑 表 达 式... 69 5.3 if 语 句... 70 5.3.1 if 语 句 的 三 种 形 式... 70 5.3.2 if 语 句 的 嵌 套... 73 5.3.3 条 件 运 算 符 和 条 件 表 达 式... 75 5.4 switch 语 句... 76 5.5 程 序 举 例... 77 6 循 环 控 制... 78 6.1 概 述... 78 6.2 goto 语 句 以 及 用 goto 语 句 构 成 循 环... 78 6.3 while 语 句... 79 6.4 do-while 语 句... 81 6.5 for 语 句... 83 6.6 循 环 的 嵌 套... 86 6.7 几 种 循 环 的 比 较... 86 6.8 break 和 continue 语 句... 86 6.8.1 break 语 句... 86 6.8.2 continue 语 句... 87 6.9 程 序 举 例... 88 7 数 组... 90 7.1 一 维 数 组 的 定 义 和 引 用... 90 7.1.1 一 维 数 组 的 定 义 方 式... 90 7.1.2 一 维 数 组 元 素 的 引 用... 91 7.1.3 一 维 数 组 的 初 始 化... 93 7.1.4 一 维 数 组 程 序 举 例... 93 7.2 二 维 数 组 的 定 义 和 引 用... 94 7.2.1 二 维 数 组 的 定 义... 94 7.2.2 二 维 数 组 元 素 的 引 用... 95 7.2.3 二 维 数 组 的 初 始 化... 96 7.2.4 二 维 数 组 程 序 举 例... 97 7.3 字 符 数 组... 97 7.3.1 字 符 数 组 的 定 义... 97 7.3.2 字 符 数 组 的 初 始 化... 98 7.3.3 字 符 数 组 的 引 用... 98 7.3.4 字 符 串 和 字 符 串 结 束 标 志... 98 7.3.5 字 符 数 组 的 输 入 输 出... 99 7.3.6 字 符 串 处 理 函 数... 100 7.4 程 序 举 例... 103 7.5 本 章 小 结... 105 8 函 数... 106 8.1 概 述... 106 8.2 函 数 定 义 的 一 般 形 式... 107 8.3 函 数 的 参 数 和 函 数 的 值... 108 8.3.1 形 式 参 数 和 实 际 参 数... 108 第 3 页
8.3.2 函 数 的 返 回 值... 110 8.4 函 数 的 调 用... 110 8.4.1 函 数 调 用 的 一 般 形 式... 110 8.4.2 函 数 调 用 的 方 式... 110 8.4.3 被 调 用 函 数 的 声 明 和 函 数 原 型... 111 8.5 函 数 的 嵌 套 调 用... 112 8.6 函 数 的 递 归 调 用... 113 8.7 数 组 作 为 函 数 参 数... 116 8.8 局 部 变 量 和 全 局 变 量... 121 8.8.1 局 部 变 量... 121 8.8.2 全 局 变 量... 122 8.9 变 量 的 存 储 类 别... 124 8.9.1 动 态 存 储 方 式 与 静 态 动 态 存 储 方 式... 124 8.9.2 auto 变 量... 124 8.9.3 用 static 声 明 局 部 变 量... 125 8.9.4 register 变 量... 126 8.9.5 用 extern 声 明 外 部 变 量... 126 9 预 处 理 命 令... 127 9.1 概 述... 127 9.2 宏 定 义... 127 9.2.1 无 参 宏 定 义... 127 9.2.2 带 参 宏 定 义... 130 9.3 文 件 包 含... 133 9.4 条 件 编 译... 134 9.5 本 章 小 结... 136 10 指 针... 136 10.1 地 址 指 针 的 基 本 概 念... 137 10.2 变 量 的 指 针 和 指 向 变 量 的 指 针 变 量... 137 10.2.1 定 义 一 个 指 针 变 量... 138 10.2.2 指 针 变 量 的 引 用... 138 10.2.3 指 针 变 量 作 为 函 数 参 数... 142 10.2.4 指 针 变 量 几 个 问 题 的 进 一 步 说 明... 145 10.3 数 组 指 针 和 指 向 数 组 的 指 针 变 量... 148 10.3.1 指 向 数 组 元 素 的 指 针... 148 10.3.2 通 过 指 针 引 用 数 组 元 素... 149 10.3.3 数 组 名 作 函 数 参 数... 151 10.3.4 指 向 多 维 数 组 的 指 针 和 指 针 变 量... 158 10.4 字 符 串 的 指 针 指 向 字 符 串 的 针 指 变 量... 160 10.4.1 字 符 串 的 表 示 形 式... 160 10.4.2 使 用 字 符 串 指 针 变 量 与 字 符 数 组 的 区 别... 163 10.5 函 数 指 针 变 量... 164 10.6 指 针 型 函 数... 165 10.7 指 针 数 组 和 指 向 指 针 的 指 针... 166 10.7.1 指 针 数 组 的 概 念... 166 第 4 页
10.7.2 指 向 指 针 的 指 针... 169 10.7.3 main 函 数 的 参 数... 171 10.8 有 关 指 针 的 数 据 类 型 和 指 针 运 算 的 小 结... 172 10.8.1 有 关 指 针 的 数 据 类 型 的 小 结... 172 10.8.2 指 针 运 算 的 小 结... 173 10.8.3 void 指 针 类 型... 173 11 结 构 体 与 共 用 体... 173 11.1 定 义 一 个 结 构 的 一 般 形 式... 173 11.2 结 构 类 型 变 量 的 说 明... 174 11.3 结 构 变 量 成 员 的 表 示 方 法... 176 11.4 结 构 变 量 的 赋 值... 176 11.5 结 构 变 量 的 初 始 化... 177 11.6 结 构 数 组 的 定 义... 177 11.7 结 构 指 针 变 量 的 说 明 和 使 用... 180 11.7.1 指 向 结 构 变 量 的 指 针... 180 11.7.2 指 向 结 构 数 组 的 指 针... 181 11.7.3 结 构 指 针 变 量 作 函 数 参 数... 182 11.8 动 态 存 储 分 配... 183 11.9 链 表 的 概 念... 185 11.10 枚 举 类 型... 186 11.10.1 枚 举 类 型 的 定 义 和 枚 举 变 量 的 说 明... 187 11.10.2 枚 举 类 型 变 量 的 赋 值 和 使 用... 187 11.11 类 型 定 义 符 typedef... 188 12 位 运 算... 189 12.1 位 运 算 符 C 语 言 提 供 了 六 种 位 运 算 符 :... 189 12.1.1 按 位 与 运 算... 190 12.1.2 按 位 或 运 算... 190 12.1.3 按 位 异 或 运 算... 191 12.1.4 求 反 运 算... 191 12.1.5 左 移 运 算... 191 12.1.6 右 移 运 算... 191 12.2 位 域 ( 位 段 )... 192 12.3 本 章 小 结... 194 13 文 件... 195 13.1 C 文 件 概 述... 195 13.2 文 件 指 针... 195 13.3 文 件 的 打 开 与 关 闭... 196 13.3.1 文 件 的 打 开 (fopen 函 数 )... 196 13.3.2 文 件 关 闭 函 数 (fclose 函 数 )... 197 13.4 文 件 的 读 写... 198 13.4.1 字 符 读 写 函 数 fgetc 和 fputc... 198 13.4.2 字 符 串 读 写 函 数 fgets 和 fputs... 201 13.4.3 数 据 块 读 写 函 数 fread 和 fwtrite... 203 13.4.4 格 式 化 读 写 函 数 fscanf 和 fprintf... 204 第 5 页
13.5 文 件 的 随 机 读 写... 205 13.5.1 文 件 定 位... 206 13.5.2 文 件 的 随 机 读 写... 206 13.6 文 件 检 测 函 数... 207 13.6.1 文 件 结 束 检 测 函 数 feof 函 数... 207 13.6.2 读 写 文 件 出 错 检 测 函 数... 207 13.6.3 文 件 出 错 标 志 和 文 件 结 束 标 志 置 0 函 数... 207 13.7 C 库 文 件... 208 13.8 本 章 小 结... 209 第 6 页
1 C 语 言 概 述 1.1 C 语 言 的 发 展 过 程 C 语 言 是 在 70 年 代 初 问 世 的 一 九 七 八 年 由 美 国 电 话 电 报 公 司 (AT&T) 贝 尔 实 验 室 正 式 发 表 了 C 语 言 同 时 由 B.W.Kernighan 和 D.M.Ritchit 合 著 了 著 名 的 THE C PROGRAMMING LANGUAGE 一 书 通 常 简 称 为 K&R, 也 有 人 称 之 为 K&R 标 准 但 是, 在 K&R 中 并 没 有 定 义 一 个 完 整 的 标 准 C 语 言, 后 来 由 美 国 国 家 标 准 协 会 (American National Standards Institute) 在 此 基 础 上 制 定 了 一 个 C 语 言 标 准, 于 一 九 八 三 年 发 表 通 常 称 之 为 ANSI C 1.2 当 代 最 优 秀 的 程 序 设 计 语 言 早 期 的 C 语 言 主 要 是 用 于 UNIX 系 统 由 于 C 语 言 的 强 大 功 能 和 各 方 面 的 优 点 逐 渐 为 人 们 认 识, 到 了 八 十 年 代,C 开 始 进 入 其 它 操 作 系 统, 并 很 快 在 各 类 大 中 小 和 微 型 计 算 机 上 得 到 了 广 泛 的 使 用, 成 为 当 代 最 优 秀 的 程 序 设 计 语 言 之 一 1.3 C 语 言 版 本 目 前 最 流 行 的 C 语 言 有 以 下 几 种 : Microsoft C 或 称 MS C Borland Turbo C 或 称 Turbo C AT&T C 这 些 C 语 言 版 本 不 仅 实 现 了 ANSI C 标 准, 而 且 在 此 基 础 上 各 自 作 了 一 些 扩 充, 使 之 更 加 方 便 完 美 1.4 C 语 言 的 特 点 1 C 语 言 简 洁 紧 凑, 使 用 方 便 灵 活 ANSI C 一 共 只 有 32 个 关 键 字 : auto break case char const continue default do double else enum extern float for goto if int long register return short signed static sizof struct switch typedef union unsigned void volatile while 9 种 控 制 语 句, 程 序 书 写 自 由, 主 要 用 小 写 字 母 表 示, 压 缩 了 一 切 不 必 要 的 成 分 Turbo C 扩 充 了 11 个 关 键 字 : asm _cs _ds _es _ss cdecl far huge interrupt near pascal 注 意 : 在 C 语 言 中, 关 键 字 都 是 小 写 的 2 运 算 符 丰 富 共 有 34 种 C 把 括 号 赋 值 逗 号 等 都 作 为 运 算 符 处 理 从 而 使 C 的 运 算 类 型 极 为 丰 富, 可 以 实 现 其 他 高 级 语 言 难 以 实 现 的 运 算 3 数 据 结 构 类 型 丰 富 第 7 页
4 具 有 结 构 化 的 控 制 语 句 5 语 法 限 制 不 太 严 格, 程 序 设 计 自 由 度 大 6 C 语 言 允 许 直 接 访 问 物 理 地 址, 能 进 行 位 (bit) 操 作, 能 实 现 汇 编 语 言 的 大 部 分 功 能, 可 以 直 接 对 硬 件 进 行 操 作 因 此 有 人 把 它 称 为 中 级 语 言 7 生 成 目 标 代 码 质 量 高, 程 序 执 行 效 率 高 8 与 汇 编 语 言 相 比, 用 C 语 言 写 的 程 序 可 移 植 性 好 但 是,C 语 言 对 程 序 员 要 求 也 高, 程 序 员 用 C 写 程 序 会 感 到 限 制 少 灵 活 性 大, 功 能 强, 但 较 其 他 高 级 语 言 在 学 习 上 要 困 难 一 些 1.5 面 向 对 象 的 程 序 设 计 语 言 在 C 的 基 础 上, 一 九 八 三 年 又 由 贝 尔 实 验 室 的 Bjarne Strou-strup 推 出 了 C++ C++ 进 一 步 扩 充 和 完 善 了 C 语 言, 成 为 一 种 面 向 对 象 的 程 序 设 计 语 言 C++ 目 前 流 行 的 最 新 版 本 是 Borland C++, Symantec C++ 和 Microsoft VisualC++ C++ 提 出 了 一 些 更 为 深 入 的 概 念, 它 所 支 持 的 这 些 面 向 对 象 的 概 念 容 易 将 问 题 空 间 直 接 地 映 射 到 程 序 空 间, 为 程 序 员 提 供 了 一 种 与 传 统 结 构 程 序 设 计 不 同 的 思 维 方 式 和 编 程 方 法 因 而 也 增 加 了 整 个 语 言 的 复 杂 性, 掌 握 起 来 有 一 定 难 度 1.6 C 和 C++ 但 是,C 是 C++ 的 基 础,C++ 语 言 和 C 语 言 在 很 多 方 面 是 兼 容 的 因 此, 掌 握 了 C 语 言, 再 进 一 步 学 习 C++ 就 能 以 一 种 熟 悉 的 语 法 来 学 习 面 向 对 象 的 语 言, 从 而 达 到 事 半 功 倍 的 目 的 1.7 简 单 的 C 程 序 介 绍 为 了 说 明 C 语 言 源 程 序 结 构 的 特 点, 先 看 以 下 几 个 程 序 这 几 个 程 序 由 简 到 难, 表 现 了 C 语 言 源 程 序 在 组 成 结 构 上 的 特 点 虽 然 有 关 内 容 还 未 介 绍, 但 可 从 这 些 例 子 中 了 解 到 组 成 一 个 C 源 程 序 的 基 本 部 分 和 书 写 格 式 例 1.1 main() printf(" 世 界, 您 好!\n"); main 是 主 函 数 的 函 数 名, 表 示 这 是 一 个 主 函 数 每 一 个 C 源 程 序 都 必 须 有, 且 只 能 有 一 个 主 函 数 (main 函 数 ) 函 数 调 用 语 句,printf 函 数 的 功 能 是 把 要 输 出 的 内 容 送 到 显 示 器 去 显 示 printf 函 数 是 一 个 由 系 统 定 义 的 标 准 函 数, 可 在 程 序 中 直 接 调 用 例 1.2 #include<math.h> #include<stdio.h> main() 第 8 页
double x,s; printf("input number:\n"); scanf("%lf",&x); s=sin(x); printf("sine of %lf is %lf\n",x,s); include 称 为 文 件 包 含 命 令 扩 展 名 为.h 的 文 件 称 为 头 文 件 定 义 两 个 实 数 变 量, 以 被 后 面 程 序 使 用 显 示 提 示 信 息 从 键 盘 获 得 一 个 实 数 x 求 x 的 正 弦, 并 把 它 赋 给 变 量 s 显 示 程 序 运 算 结 果 main 函 数 结 束 程 序 的 功 能 是 从 键 盘 输 入 一 个 数 x, 求 x 的 正 弦 值, 然 后 输 出 结 果 在 main() 之 前 的 两 行 称 为 预 处 理 命 令 ( 详 见 后 面 ) 预 处 理 命 令 还 有 其 它 几 种, 这 里 的 include 称 为 文 件 包 含 命 令, 其 意 义 是 把 尖 括 号 <> 或 引 号 "" 内 指 定 的 文 件 包 含 到 本 程 序 来, 成 为 本 程 序 的 一 部 分 被 包 含 的 文 件 通 常 是 由 系 统 提 供 的, 其 扩 展 名 为.h 因 此 也 称 为 头 文 件 或 首 部 文 件 C 语 言 的 头 文 件 中 包 括 了 各 个 标 准 库 函 数 的 函 数 原 型 因 此, 凡 是 在 程 序 中 调 用 一 个 库 函 数 时, 都 必 须 包 含 该 函 数 原 型 所 在 的 头 文 件 在 本 例 中, 使 用 了 三 个 库 函 数 : 输 入 函 数 scanf, 正 弦 函 数 sin, 输 出 函 数 printf sin 函 数 是 数 学 函 数, 其 头 文 件 为 math.h 文 件, 因 此 在 程 序 的 主 函 数 前 用 include 命 令 包 含 了 math.h scanf 和 printf 是 标 准 输 入 输 出 函 数, 其 头 文 件 为 stdio.h, 在 主 函 数 前 也 用 include 命 令 包 含 了 stdio.h 文 件 需 要 说 明 的 是,C 语 言 规 定 对 scanf 和 printf 这 两 个 函 数 可 以 省 去 对 其 头 文 件 的 包 含 命 令 所 以 在 本 例 中 也 可 以 删 去 第 二 行 的 包 含 命 令 #include<stdio.h> 同 样, 在 例 1.1 中 使 用 了 printf 函 数, 也 省 略 了 包 含 命 令 在 例 题 中 的 主 函 数 体 中 又 分 为 两 部 分, 一 部 分 为 说 明 部 分, 另 一 部 为 分 执 行 部 分 说 明 是 指 变 量 的 类 型 说 明 例 题 1.1 中 未 使 用 任 何 变 量, 因 此 无 说 明 部 分 C 语 言 规 定, 源 程 序 中 所 有 用 到 的 变 量 都 必 须 先 说 明, 后 使 用, 否 则 将 会 出 错 这 一 点 是 编 译 型 高 级 程 序 设 计 语 言 的 一 个 特 点, 与 解 释 型 的 BASIC 语 言 是 不 同 的 说 明 部 分 是 C 源 程 序 结 构 中 很 重 要 的 组 成 部 分 本 例 中 使 用 了 两 个 变 量 x,s, 用 来 表 示 输 入 的 自 变 量 和 sin 函 数 值 由 于 sin 函 数 要 求 这 两 个 量 必 须 是 双 精 度 浮 点 型, 故 用 类 型 说 明 符 double 来 说 明 这 两 个 变 量 说 明 部 分 后 的 四 行 为 执 行 部 分 或 称 为 执 行 语 句 部 分, 用 以 完 成 程 序 的 功 能 执 行 部 分 的 第 一 行 是 输 出 语 句, 调 用 printf 函 数 在 显 示 器 上 输 出 提 示 字 符 串, 请 操 作 人 员 输 入 自 变 量 x 的 值 第 二 行 为 输 入 语 句, 调 用 scanf 函 数, 接 受 键 盘 上 输 入 的 数 并 存 入 变 量 x 中 第 三 行 是 调 用 sin 函 数 并 把 函 数 值 送 到 变 量 s 中 第 四 行 是 用 printf 函 数 输 出 变 量 s 的 值, 即 x 的 正 弦 值 程 序 结 束 运 行 本 程 序 时, 首 先 在 显 示 器 屏 幕 上 给 出 提 示 串 input number, 这 是 由 执 行 部 分 的 第 一 行 完 成 的 用 户 在 提 示 下 从 键 盘 上 键 入 某 一 数, 如 5, 按 下 回 车 键, 接 着 在 屏 幕 上 给 出 计 算 结 果 1.8 输 入 和 输 出 函 数 在 前 两 个 例 子 中 用 到 了 输 入 和 输 出 函 数 scanf 和 printf, 在 以 后 要 详 细 介 绍 这 里 我 们 先 简 单 介 绍 一 下 它 们 的 格 式, 以 便 下 面 使 用 scanf 和 printf 这 两 个 函 数 分 别 称 为 格 式 输 入 函 数 和 格 式 输 出 函 数 其 意 义 是 按 指 定 的 格 式 输 入 输 出 值 因 此, 这 两 个 函 数 在 括 号 中 的 参 数 表 都 由 以 下 两 部 分 组 成 : 格 式 控 制 串, 参 数 表 第 9 页
格 式 控 制 串 是 一 个 字 符 串, 必 须 用 双 引 号 括 起 来, 它 表 示 了 输 入 输 出 量 的 数 据 类 型 各 种 类 型 的 格 式 表 示 法 可 参 阅 第 三 章 在 printf 函 数 中 还 可 以 在 格 式 控 制 串 内 出 现 非 格 式 控 制 字 符, 这 时 在 显 示 屏 幕 上 将 原 文 照 印 参 数 表 中 给 出 了 输 入 或 输 出 的 量 当 有 多 个 量 时, 用 逗 号 间 隔 例 如 : printf("sine of %lf is %lf\n",x,s); 其 中 %lf 为 格 式 字 符, 表 示 按 双 精 度 浮 点 数 处 理 它 在 格 式 串 中 两 次 现, 对 应 了 x 和 s 两 个 变 量 其 余 字 符 为 非 格 式 字 符 则 照 原 样 输 出 在 屏 幕 上 例 1.3 int max(int a,int b); /* 函 数 说 明 */ main() /* 主 函 数 */ int x,y,z; /* 变 量 说 明 */ int max(int a,int b); /* 函 数 说 明 */ printf("input two numbers:\n"); scanf("%d%d",&x,&y); /* 输 入 x,y 值 */ z=max(x,y); /* 调 用 max 函 数 */ printf("maxmum=%d",z); /* 输 出 */ int max(int a,int b) /* 定 义 max 函 数 */ if(a>b)return a;else return b; /* 把 结 果 返 回 主 调 函 数 */ 上 面 例 中 程 序 的 功 能 是 由 用 户 输 入 两 个 整 数, 程 序 执 行 后 输 出 其 中 较 大 的 数 本 程 序 由 两 个 函 数 组 成, 主 函 数 和 max 函 数 函 数 之 间 是 并 列 关 系 可 从 主 函 数 中 调 用 其 它 函 数 max 函 数 的 功 能 是 比 较 两 个 数, 然 后 把 较 大 的 数 返 回 给 主 函 数 max 函 数 是 一 个 用 户 自 定 义 函 数 因 此 在 主 函 数 中 要 给 出 说 明 ( 程 序 第 三 行 ) 可 见, 在 程 序 的 说 明 部 分 中, 不 仅 可 以 有 变 量 说 明, 还 可 以 有 函 数 说 明 关 于 函 数 的 详 细 内 容 将 在 以 后 第 五 章 介 绍 在 程 序 的 每 行 后 用 /* 和 */ 括 起 来 的 内 容 为 注 释 部 分, 程 序 不 执 行 注 释 部 分 上 例 中 程 序 的 执 行 过 程 是, 首 先 在 屏 幕 上 显 示 提 示 串, 请 用 户 输 入 两 个 数, 回 车 后 由 scanf 函 数 语 句 接 收 这 两 个 数 送 入 变 量 x,y 中, 然 后 调 用 max 函 数, 并 把 x,y 的 值 传 送 给 max 函 数 的 参 数 a,b 在 max 函 数 中 比 较 a,b 的 大 小, 把 大 者 返 回 给 主 函 数 的 变 量 z, 最 后 在 屏 幕 上 输 出 z 的 值 1.9 C 源 程 序 的 结 构 特 点 1. 一 个 C 语 言 源 程 序 可 以 由 一 个 或 多 个 源 文 件 组 成 2. 每 个 源 文 件 可 由 一 个 或 多 个 函 数 组 成 3. 一 个 源 程 序 不 论 由 多 少 个 文 件 组 成, 都 有 一 个 且 只 能 有 一 个 main 函 数, 即 主 函 数 4. 源 程 序 中 可 以 有 预 处 理 命 令 (include 命 令 仅 为 其 中 的 一 种 ), 预 处 理 命 令 通 常 应 放 在 源 文 件 或 源 程 序 的 最 前 面 5. 每 一 个 说 明, 每 一 个 语 句 都 必 须 以 分 号 结 尾 但 预 处 理 命 令, 函 数 头 和 花 括 号 之 后 不 能 加 分 号 6. 标 识 符, 关 键 字 之 间 必 须 至 少 加 一 个 空 格 以 示 间 隔 若 已 有 明 显 的 间 隔 符, 也 可 不 再 加 空 格 来 间 隔 第 10 页
1.10 书 写 程 序 时 应 遵 循 的 规 则 从 书 写 清 晰, 便 于 阅 读, 理 解, 维 护 的 角 度 出 发, 在 书 写 程 序 时 应 遵 循 以 下 规 则 : 1. 一 个 说 明 或 一 个 语 句 占 一 行 2. 用 括 起 来 的 部 分, 通 常 表 示 了 程 序 的 某 一 层 次 结 构 一 般 与 该 结 构 语 句 的 第 一 个 字 母 对 齐, 并 单 独 占 一 行 3. 低 一 层 次 的 语 句 或 说 明 可 比 高 一 层 次 的 语 句 或 说 明 缩 进 若 干 格 后 书 写 以 便 看 起 来 更 加 清 晰, 增 加 程 序 的 可 读 性 在 编 程 时 应 力 求 遵 循 这 些 规 则, 以 养 成 良 好 的 编 程 风 格 1.11 C 语 言 的 字 符 集 字 符 是 组 成 语 言 的 最 基 本 的 元 素 C 语 言 字 符 集 由 字 母, 数 字, 空 格, 标 点 和 特 殊 字 符 组 成 在 字 符 常 量, 字 符 串 常 量 和 注 释 中 还 可 以 使 用 汉 字 或 其 它 可 表 示 的 图 形 符 号 1. 字 母 小 写 字 母 a~z 共 26 个 大 写 字 母 A~Z 共 26 个 2. 数 字 0~9 共 10 个 3. 空 白 符 空 格 符 制 表 符 换 行 符 等 统 称 为 空 白 符 空 白 符 只 在 字 符 常 量 和 字 符 串 常 量 中 起 作 用 在 其 它 地 方 出 现 时, 只 起 间 隔 作 用, 编 译 程 序 对 它 们 忽 略 不 计 因 此 在 程 序 中 使 用 空 白 符 与 否, 对 程 序 的 编 译 不 发 生 影 响, 但 在 程 序 中 适 当 的 地 方 使 用 空 白 符 将 增 加 程 序 的 清 晰 性 和 可 读 性 4. 标 点 和 特 殊 字 符 1.12 C 语 言 词 汇 在 C 语 言 中 使 用 的 词 汇 分 为 六 类 : 标 识 符, 关 键 字, 运 算 符, 分 隔 符, 常 量, 注 释 符 等 1. 标 识 符 在 程 序 中 使 用 的 变 量 名 函 数 名 标 号 等 统 称 为 标 识 符 除 库 函 数 的 函 数 名 由 系 统 定 义 外, 其 余 都 由 用 户 自 定 义 C 规 定, 标 识 符 只 能 是 字 母 (A~Z,a~z) 数 字 (0~9) 下 划 线 (_) 组 成 的 字 符 串, 并 且 其 第 一 个 字 符 必 须 是 字 母 或 下 划 线 以 下 标 识 符 是 合 法 的 : a, x, x3, BOOK_1, sum5 以 下 标 识 符 是 非 法 的 : 3s 以 数 字 开 头 s*t 出 现 非 法 字 符 * -3x 以 减 号 开 头 bowy-1 出 现 非 法 字 符 -( 减 号 ) 在 使 用 标 识 符 时 还 必 须 注 意 以 下 几 点 : (1) 标 准 C 不 限 制 标 识 符 的 长 度, 但 它 受 各 种 版 本 的 C 语 言 编 译 系 统 限 制, 同 时 也 受 到 具 体 机 器 的 限 制 例 如 在 某 版 本 C 中 规 定 标 识 符 前 八 位 有 效, 当 两 个 标 识 符 前 八 位 相 同 时, 则 被 认 为 是 同 一 个 标 识 符 第 11 页
(2) 在 标 识 符 中, 大 小 写 是 有 区 别 的 例 如 BOOK 和 book 是 两 个 不 同 的 标 识 符 (3) 标 识 符 虽 然 可 由 程 序 员 随 意 定 义, 但 标 识 符 是 用 于 标 识 某 个 量 的 符 号 因 此, 命 名 应 尽 量 有 相 应 的 意 义, 以 便 于 阅 读 理 解, 作 到 顾 名 思 义 2. 关 键 字 关 键 字 是 由 C 语 言 规 定 的 具 有 特 定 意 义 的 字 符 串, 通 常 也 称 为 保 留 字 用 户 定 义 的 标 识 符 不 应 与 关 键 字 相 同 C 语 言 的 关 键 字 分 为 以 下 几 类 : (1) 类 型 说 明 符 用 于 定 义 说 明 变 量 函 数 或 其 它 数 据 结 构 的 类 型 如 前 面 例 题 中 用 到 的 int,double 等 (2) 语 句 定 义 符 用 于 表 示 一 个 语 句 的 功 能 如 例 1.3 中 用 到 的 if else 就 是 条 件 语 句 的 语 句 定 义 符 (3) 预 处 理 命 令 字 用 于 表 示 一 个 预 处 理 命 令 如 前 面 各 例 中 用 到 的 include 3. 运 算 符 C 语 言 中 含 有 相 当 丰 富 的 运 算 符 运 算 符 与 变 量, 函 数 一 起 组 成 表 达 式, 表 示 各 种 运 算 功 能 运 算 符 由 一 个 或 多 个 字 符 组 成 4. 分 隔 符 在 C 语 言 中 采 用 的 分 隔 符 有 逗 号 和 空 格 两 种 逗 号 主 要 用 在 类 型 说 明 和 函 数 参 数 表 中, 分 隔 各 个 变 量 空 格 多 用 于 语 句 各 单 词 之 间, 作 间 隔 符 在 关 键 字, 标 识 符 之 间 必 须 要 有 一 个 以 上 的 空 格 符 作 间 隔, 否 则 将 会 出 现 语 法 错 误, 例 如 把 int a; 写 成 inta;c 编 译 器 会 把 inta 当 成 一 个 标 识 符 处 理, 其 结 果 必 然 出 错 5. 常 量 C 语 言 中 使 用 的 常 量 可 分 为 数 字 常 量 字 符 常 量 字 符 串 常 量 符 号 常 量 转 义 字 符 等 多 种 在 后 面 章 节 中 将 专 门 给 予 介 绍 6. 注 释 符 C 语 言 的 注 释 符 是 以 /* 开 头 并 以 */ 结 尾 的 串 在 /* 和 */ 之 间 的 即 为 注 释 程 序 编 译 时, 不 对 注 释 作 任 何 处 理 注 释 可 出 现 在 程 序 中 的 任 何 位 置 注 释 用 来 向 用 户 提 示 或 解 释 程 序 的 意 义 在 调 试 程 序 中 对 暂 不 使 用 的 语 句 也 可 用 注 释 符 括 起 来, 使 翻 译 跳 过 不 作 处 理, 待 调 试 结 束 后 再 去 掉 注 释 符 1.13 Turbo C 2.0 集 成 开 发 环 境 的 使 用 1.13.1 Turbo C 2.0 简 介 和 启 动 我 们 上 机 实 习 和 将 来 考 试 都 是 使 用 Borland Turbo C 2.0 这 个 版 本 该 系 统 是 DOS 操 作 系 统 支 持 下 的 软 件, 在 windows 98 环 境 下, 可 以 在 DOS 窗 口 下 运 行 我 们 机 房 是 在 D 盘 根 目 录 下 建 立 一 个 TC 子 目 录 下 安 装 Turbo C 2.0 系 统 的 TC 下 还 建 立 了 两 个 了 目 录 LIB 和 INCLUDE, LIB 子 目 录 中 存 放 库 文 件, INCLUDE 子 目 录 中 存 放 所 有 头 文 件 在 DOS 环 境 下 或 在 windows 98 的 DOS 窗 口 下 运 行 运 行 Turbo C 2.0 时, 只 要 在 TC 子 目 录 下 键 入 TC 并 回 车 即 可 进 入 Turbo C 2. 0 集 成 开 发 环 境 在 windows 98 环 境 下, 也 可 以 选 运 行 菜 单, 然 后 键 入 d:\tc\tc 即 可, 也 可 以 在 tc 文 件 夹 找 到 tc.exe 文 件, 然 后 用 鼠 标 双 击 该 文 件 名 也 可 进 入 Turbo C 2. 0 集 成 开 发 环 境 Turbo C 是 美 国 Borland 公 司 的 产 品,Borland 公 司 是 一 家 专 门 从 事 软 件 开 发 研 制 的 大 公 司 该 公 司 相 继 推 出 了 一 套 Turbo 系 列 软 件, 如 Turbo BASIC, TurboPascal, Turbo Prolog, 这 些 软 件 很 受 用 户 欢 迎 该 公 司 在 1987 年 首 次 推 出 TurboC 1.0 产 品, 其 中 使 用 了 全 然 一 新 的 集 成 开 发 环 境, 即 使 用 了 一 系 列 下 拉 式 菜 单, 将 第 12 页
文 本 编 辑 程 序 编 译 连 接 以 及 程 序 运 行 一 体 化, 大 大 方 便 了 程 序 的 开 发 1988 年, Borland 公 司 又 推 出 Turbo C1.5 版 本, 增 加 了 图 形 库 和 文 本 窗 口 函 数 库 等, 而 Turbo C 2.0 则 是 该 公 司 1989 年 出 版 的 Turbo C2.0 在 原 来 集 成 开 发 环 境 的 基 础 上 增 加 了 查 错 功 能, 并 可 以 在 Tiny 模 式 下 直 接 生 成.COM ( 数 据 代 码 堆 栈 处 在 同 一 64K 内 存 中 ) 文 件 还 可 对 数 学 协 处 理 器 ( 支 持 8087/80287/80387 等 ) 进 行 仿 真 Borland 公 司 后 来 又 推 出 了 面 向 对 象 的 程 序 软 件 包 Turbo C++, 它 继 承 发 展 Turbo C 2.0 的 集 成 开 发 环 境, 并 包 含 了 面 向 对 象 的 基 本 思 想 和 设 计 方 法 1991 年 为 了 适 用 Microsoft 公 司 的 Windows 3.0 版 本, Borland 公 司 又 将 Turbo C++ 作 了 更 新, 即 Turbo C 的 新 一 代 产 品 Borlandc C++ 也 已 经 问 世 了 1.13.2 Turbo C 2.0 集 成 开 发 环 境 进 入 Turbo C 2.0 集 成 开 发 环 境 中 后, 屏 幕 上 显 示 : 其 中 顶 上 一 行 为 Turbo C 2.0 主 菜 单, 中 间 窗 口 为 编 辑 区, 接 下 来 是 信 息 窗 口, 最 底 下 一 行 为 参 考 行 这 四 个 窗 口 构 成 了 Turbo C 2.0 的 主 屏 幕, 以 后 的 编 程 编 译 调 试 以 及 运 行 都 将 在 这 个 主 屏 幕 中 进 行 主 菜 单 在 Turbo C 2.0 主 屏 幕 顶 上 一 行, 显 示 下 列 内 容 : File Edit Run Compile Project Options Debug Break/watch 除 Edit 外, 其 它 各 项 均 有 子 菜 单, 只 要 用 Alt 加 上 某 项 中 第 一 个 字 母, 就 可 进 入 该 项 的 子 菜 单 中 1.13.3 File 菜 单 按 Alt+F 可 进 入 File 菜 单, 如 图 : 第 13 页
File 菜 单 的 子 菜 单 共 有 9 项, 分 别 叙 述 如 下 : 1. Load: 装 入 一 个 文 件, 可 用 类 似 DOS 的 通 配 符 ( 如 *.C) 来 进 行 列 表 选 择 也 可 装 入 其 它 扩 展 名 的 文 件, 只 要 给 出 文 件 名 ( 或 只 给 路 径 ) 即 可 该 项 的 热 键 为 F3, 即 只 要 按 F3 即 可 进 入 该 项, 而 不 需 要 先 进 入 File 菜 单 再 选 此 项 2. Pick: 将 最 近 装 入 编 辑 窗 口 的 8 个 文 件 列 成 一 个 表 让 用 户 选 择, 选 择 后 将 该 程 序 装 入 编 辑 区, 并 将 光 标 置 在 上 次 修 改 过 的 地 方 其 热 健 为 Alt-F3 3. New: 新 建 文 件, 缺 省 文 件 名 为 NONAME.C, 存 盘 时 可 改 名 4. Save: 将 编 辑 区 中 的 文 件 存 盘, 若 文 件 名 是 NONAME.C 时, 将 询 问 是 否 更 改 文 件 名, 其 热 键 为 F2 5. Write to: 可 由 用 户 给 出 文 件 名 将 编 辑 区 中 的 文 件 存 盘, 若 该 文 件 已 存 在, 则 询 问 要 不 要 覆 盖 6. Directory: 显 示 目 录 及 目 录 中 的 文 件, 并 可 由 用 户 选 择 7. Change dir: 显 示 当 前 默 认 目 录, 用 户 可 以 改 变 默 认 目 录 8. Os shell: 暂 时 退 出 Turbo C 2.0 到 DOS 提 示 符 下, 此 时 可 以 运 行 DOS 命 令, 若 想 回 到 Turbo C 2.0 中, 只 要 在 DOS 状 态 下 键 入 EXIT 即 可 9. Quit: 退 出 Turbo C 2.0, 返 回 到 DOS 操 作 系 统 中, 其 热 键 为 Alt+X 说 明 : 以 上 各 项 可 用 光 标 键 移 动 色 棒 进 行 选 择, 回 车 则 执 行 也 可 用 每 一 项 的 第 一 个 大 写 字 母 直 接 选 择 若 要 退 到 主 菜 单 或 从 它 的 下 一 级 菜 单 列 表 框 退 回 均 可 用 Esc 键, Turbo C 2.0 所 有 菜 单 均 采 用 这 种 方 法 进 行 操 作, 以 下 不 再 说 明 1.13.4 Edit 菜 单 按 Alt+E 可 进 入 编 辑 菜 单, 若 再 回 车, 则 光 标 出 现 在 编 辑 窗 口, 此 时 用 户 可 以 进 行 文 本 编 辑 编 辑 方 法 基 本 与 wordstar 相 同, 可 用 F1 键 获 得 有 关 编 辑 方 法 的 帮 助 信 息 1. 与 编 辑 有 关 的 功 能 键 如 下 : F1 获 得 Turbo C 2.0 编 辑 命 令 的 帮 助 信 息 ; F5 扩 大 编 辑 窗 口 到 整 个 屏 幕 ; F6 在 编 辑 窗 口 与 信 息 窗 口 之 间 进 行 切 换 ; 第 14 页
F10 从 编 辑 窗 口 转 到 主 菜 单 2. 编 辑 命 令 简 介 : PageUp 向 前 翻 页 PageDn 向 后 翻 页 Home 将 光 标 移 到 所 在 行 的 开 始 End 将 光 标 移 到 所 在 行 的 结 尾 Ctrl+Y 删 除 光 标 所 在 的 一 行 Ctrl+T 删 除 光 标 所 在 处 的 一 个 词 Ctrl+KB 设 置 块 开 始 Ctrl+KK 设 置 块 结 尾 Ctrl+KV 块 移 动 Ctrl+KC 块 拷 贝 Ctrl+KY 块 删 除 Ctrl+KR 读 文 件 Ctrl+KW 存 文 件 Ctrl+KP 块 文 件 打 印 Ctrl+F1 如 果 光 标 所 在 处 为 Turbo C 2.0 库 函 数, 则 获 得 有 关 该 函 数 的 帮 助 信 息 Ctrl+Q[ 查 找 Turbo C 2.0 双 界 符 的 后 匹 配 符 Ctrl+Q] 查 找 Turbo C 2.0 双 界 符 的 前 匹 配 符 说 明 : 1) Turbo C 2.0 的 双 界 符 包 括 以 下 几 种 符 号 : a) 花 括 符 和 b) 尖 括 符 < 和 > c) 圆 括 符 ( 和 ) d) 方 括 符 [ 和 ] e) 注 释 符 /* 和 */ f) 双 引 号 " g) 单 引 号 ' 2) Turbo C 2.0 在 编 辑 文 件 时 还 有 一 种 功 能, 就 是 能 够 自 动 缩 进, 即 光 标 定 位 和 上 一 个 非 空 字 符 对 齐 在 编 辑 窗 口 中, Ctrl+OL 为 自 动 缩 进 开 关 的 控 制 键 1.13.5 Run 菜 单 按 Alt+R 可 进 入 Run 菜 单, 该 菜 单 有 以 下 各 项, 如 图 所 示 : 第 15 页
1. Run: 运 行 由 Project/Project name 项 指 定 的 文 件 名 或 当 前 编 辑 区 的 文 件 如 果 对 上 次 编 译 后 的 源 代 码 未 做 过 修 改, 则 直 接 运 行 到 下 一 个 断 点 ( 没 有 断 点 则 运 行 到 结 束 ) 否 则 先 进 行 编 译 连 接 后 才 运 行, 其 热 键 为 Ctrl+F9 2. Program reset: 中 止 当 前 的 调 试, 释 放 分 给 程 序 的 空 间, 其 热 键 为 Ctrl+F2 3. Go to cursor:: 调 试 程 序 时 使 用, 选 择 该 项 可 使 程 序 运 行 到 光 标 所 在 行 光 标 所 在 行 必 须 为 一 条 可 执 行 语 句, 否 则 提 示 错 误 其 热 键 为 F4 4. Trace into: 在 执 行 一 条 调 用 其 它 用 户 定 义 的 子 函 数 时, 若 用 Trace into 项, 则 执 行 长 条 将 跟 踪 到 该 子 函 数 内 部 去 执 行, 其 热 键 为 F7 5. Step over: 执 行 当 前 函 数 的 下 一 条 语 句, 即 使 用 户 函 数 调 用, 执 行 长 条 也 不 会 跟 踪 进 函 数 内 部, 其 热 键 为 F8 6. User screen: 显 示 程 序 运 行 时 在 屏 幕 上 显 示 的 结 果 其 热 键 为 Alt+F5 1.13.6 Compile 菜 单 按 Alt+C 可 进 入 Compile 菜 单, 该 菜 单 有 以 下 几 个 内 容, 如 图 所 示 : 第 16 页
1. Compile to OBJ: 将 一 个 C 源 文 件 编 译 生 成.OBJ 目 标 文 件, 同 时 显 示 生 成 的 文 件 名 其 热 键 为 Alt+F9 2. Make EXE file: 此 命 令 生 成 一 个.EXE 的 文 件, 并 显 示 生 成 的.EXE 文 件 名 其 中.EXE 文 件 名 是 下 面 几 项 之 一 : 1) 由 Project/Project name 说 明 的 项 目 文 件 名 2) 若 没 有 项 目 文 件 名, 则 由 Primary C file 说 明 的 源 文 件 3) 若 以 上 两 项 都 没 有 文 件 名, 则 为 当 前 窗 口 的 文 件 名 3. Link EXE file: 把 当 前.OBJ 文 件 及 库 文 件 连 接 在 一 起 生 成.EXE 文 件 4. Build all: 重 新 编 译 项 目 里 的 所 有 文 件, 并 进 行 装 配 生 成.EXE 文 件 该 命 令 不 作 过 时 检 查 ( 上 面 的 几 条 命 令 要 作 过 时 检 查, 即 如 果 目 前 项 目 里 源 文 件 的 日 期 和 时 间 与 目 标 文 件 相 同 或 更 早, 则 拒 绝 对 源 文 件 进 行 编 译 ) 5. Primary C file: 当 在 该 项 中 指 定 了 主 文 件 后, 在 以 后 的 编 译 中, 如 没 有 项 目 文 件 名 则 编 译 此 项 中 规 定 的 主 C 文 件, 如 果 编 译 中 有 错 误, 则 将 此 文 件 调 入 编 辑 窗 口, 不 管 目 前 窗 口 中 是 不 是 主 C 文 件 6. Get info: 获 得 有 关 当 前 路 径 源 文 件 名 源 文 件 字 节 大 小 编 译 中 的 错 误 数 目 可 用 空 间 等 信 息, 如 图 : 第 17 页
1.13.7 Project 菜 单 按 Alt+P 可 进 入 Project 菜 单, 该 菜 单 包 括 以 下 内 容, 如 图 所 示 : 1. Project name: 项 目 名 具 有.PRJ 的 扩 展 名, 其 中 包 括 将 要 编 译 连 接 的 文 件 名 例 如 有 一 个 程 序 由 file1.c, file2.c, file3.c 组 成, 要 将 这 3 个 文 件 编 译 装 配 成 一 个 file.exe 的 执 行 文 件, 可 以 先 建 立 一 个 file.prj 的 项 目 文 件, 其 内 容 如 下 : file1.c file2.c file3.c 此 时 将 file.prj 放 入 Project name 项 中, 以 后 进 行 编 译 时 将 自 动 对 项 目 文 件 中 规 定 的 三 个 源 文 件 分 别 进 行 编 译 然 后 连 接 成 file.exe 文 件 如 果 其 中 有 些 文 件 已 经 编 译 成.OBJ 文 件, 而 又 没 有 修 改 过, 可 直 接 写 上.OBJ 第 18 页
扩 展 名 此 时 将 不 再 编 译 而 只 进 行 连 接 例 如 : file1.obj file2.c file3.c 将 不 对 file1.c 进 行 编 译, 而 直 接 连 接 说 明 : 当 项 目 文 件 中 的 每 个 文 件 无 扩 展 名 时, 均 按 源 文 件 对 待, 另 外, 其 中 的 文 件 也 可 以 是 库 文 件, 但 必 须 写 上 扩 展 名.LIB 2. Break make on: 由 用 户 选 择 是 否 在 有 Warining Errors Fatal Errors 时 或 Link 之 前 退 出 Make 编 译 3. Auto dependencies: 当 开 关 置 为 on, 编 译 时 将 检 查 源 文 件 与 对 应 的.OBJ 文 件 日 期 和 时 间, 否 则 不 进 行 检 查 4. Clear project: 清 除 Project/Project name 中 的 项 目 文 件 名 5. Remove messages: 把 错 误 信 息 从 信 息 窗 口 中 清 除 掉 1.13.8 Options 菜 单 按 Alt+O 可 进 入 Options 菜 单, 该 菜 单 对 初 学 者 来 说 要 谨 慎 使 用, 该 菜 单 有 以 下 几 个 内 容, 如 图 所 示 : 1. Compiler: 本 项 选 择 又 有 许 多 子 菜 单, 可 以 让 用 户 选 择 硬 件 配 置 存 储 模 型 调 试 技 术 代 码 优 化 对 话 信 息 控 制 和 宏 定 义 这 些 子 菜 单 如 图 所 示 : 第 19 页
1) Model: 共 有 Tiny, small, medium, compact, large, huge 六 种 不 同 模 式 可 由 同 户 选 择 2) Define: 打 开 一 个 宏 定 义 框, 同 户 可 输 入 宏 定 义 多 重 定 义 可 同 分 号, 赋 值 可 用 等 号 3) Code generation: 它 又 有 许 多 任 选 项, 这 些 任 选 项 告 诉 编 译 器 产 生 什 么 样 的 目 标 代 码 Calling convention 可 选 择 C 或 Pascal 方 式 传 递 参 数 Instruction set 可 选 择 8088/8086 或 80186/80286 指 令 系 列 Floating point 可 选 择 仿 真 浮 点 数 学 协 处 理 器 浮 点 或 无 浮 点 运 算 Default char type 规 定 char 的 类 型 Alignonent 规 定 地 址 对 准 原 则 Merge duplicate strings 作 优 化 用, 将 重 复 的 字 符 串 合 并 在 一 起 Standard stack frame 产 生 一 个 标 准 的 栈 结 构 Test stack overflow 产 生 一 段 程 序 运 行 时 检 测 堆 栈 溢 出 的 代 码 Line number 在.OBJ 文 件 中 放 进 行 号 以 供 调 试 时 用 OBJ debug information 在.OBJ 文 件 中 产 生 调 试 信 息 4) Optimization: 它 又 有 许 多 任 选 项 Optimize for 选 择 是 对 程 序 小 型 化 还 是 对 程 序 速 度 进 行 优 化 处 理 Use register variable 用 来 选 择 是 否 允 许 使 用 寄 存 器 变 量 Register optimization 尽 可 能 使 用 寄 存 器 变 量 以 减 少 过 多 的 取 数 操 作 Jump optimization 通 过 去 除 多 余 的 跳 转 和 调 整 循 环 与 开 关 语 句 的 办 法, 压 缩 代 码 5) Source: 它 又 有 许 多 任 选 项 Indentifier length 说 明 标 识 符 有 效 字 符 的 个 数, 默 认 为 32 个 Nested comments 是 否 允 许 嵌 套 注 释 ANSI keywords only 是 只 允 许 ANSI 关 键 字 还 是 也 允 许 Turbo C2.0 关 键 字 6) Error Error stop after 多 少 个 错 误 时 停 止 编 译, 默 认 为 25 个 Warning stop after 多 少 个 警 告 错 误 时 停 止 编 译, 默 认 为 100 个 Display warning Portability warning 移 植 性 警 告 错 误 ANSI Violations 侵 犯 了 ANSI 关 键 字 的 警 告 错 误 第 20 页
Common error 常 见 的 警 告 错 误 Less common error 少 见 的 警 告 错 误 7) Names : 用 于 改 变 段 (segment) 组 (group) 和 类 (class) 的 名 字, 默 认 值 为 CODE, DATA, BSS 2. Linker: 本 菜 单 设 置 有 关 连 接 的 选 择 项, 它 有 以 下 内 容, 如 图 所 示 : 1) Map file menu 选 择 是 否 产 生.MAP 文 件 2) Initialize segments 是 否 在 连 接 时 初 始 化 没 有 初 始 化 的 段 3) Devault libraries 是 否 在 连 接 其 它 编 译 程 序 产 生 的 目 标 文 件 时 去 寻 找 其 缺 省 库 4) Graphics library 是 否 连 接 graphics 库 中 的 函 数 5) Warn duplicate symbols 当 有 重 复 符 号 时 产 生 警 告 信 息 6) Stack warinig 是 否 让 连 接 程 序 产 生 No stack 的 警 告 信 息 7) Case-sensitive link 是 否 区 分 大 小 写 字 3. Environment: 菜 单 规 定 是 否 对 某 些 文 件 自 动 存 盘 及 制 表 键 和 屏 幕 大 小 的 设 置, 它 有 以 下 内 容, 如 图 所 示 : 第 21 页
1) Message tracking: Current file 跟 踪 在 编 辑 窗 口 中 的 文 件 错 误 All files 跟 踪 所 有 文 件 错 误 Off 不 跟 踪 2) Keep message : 编 译 前 是 否 清 除 Message 窗 口 中 的 信 息 3) Config auto save: 选 on 时, 在 Run, Shell 或 退 出 集 成 开 发 环 境 之 前, 如 果 Turbo C 2.0 的 配 置 被 改 过, 则 所 做 的 改 动 将 存 入 配 置 文 件 中 选 off 时 不 存 4) Edit auto save: 是 否 在 Run 或 Shell 之 前, 自 动 存 储 编 辑 的 源 文 件 5) Backup file: 是 否 在 源 文 件 存 盘 时 产 生 后 备 文 件 (.BAK 文 件 ) 6) Tab size: 设 置 制 表 键 大 小, 默 认 为 8 7) Zoomed windows: 将 现 行 活 动 窗 口 放 大 到 整 个 屏 幕, 其 热 键 为 F5 8) Screen size 设 置 屏 幕 文 本 大 小 4. Directories: 规 定 编 译 连 接 所 需 文 件 的 路 径, 有 下 列 各 项, 如 图 所 示 : (1) Include directories: 包 含 文 件 的 路 径, 多 个 子 目 录 用 ";" 分 开 (2) Library directories: 库 文 件 路 径, 多 个 子 目 录 用 ";" 分 开 (3) Output directoried: 输 出 文 件 (.OBJ,.EXE,.MAP 文 件 ) 的 目 录 (4) Turbo C directoried:turbo C 所 在 的 目 录 (5) Pick file name: 定 义 加 载 的 pick 文 件 名, 如 不 定 义 则 从 currentpick file 中 取 5. Arguments: 允 许 用 户 使 用 命 令 行 参 数 6. Save options: 保 存 所 有 选 择 的 编 译 连 接 调 试 和 项 目 到 配 置 文 件 中, 缺 省 的 配 置 文 件 为 TCCONFIG.TC 7. Retrive options 装 入 一 个 配 置 文 件 到 TC 中, TC 将 使 用 该 文 件 的 选 择 项 1.13.9 Debug 菜 单 按 Alt+D 可 选 择 Debug 菜 单, 该 菜 单 主 要 用 于 查 错, 它 包 括 以 下 内 容, 如 图 所 示 : 第 22 页
1. Evaluate 1) Expression 要 计 算 结 果 的 表 达 式 2) Result 显 示 表 达 式 的 计 算 结 果 3) New value 赋 给 新 值 2. Call stack: 该 项 不 可 接 触 而 在 Turbo C debuger 时 用 于 检 查 堆 栈 情 况 3. Find function 在 运 行 Turbo C debugger 时 用 于 显 示 规 定 的 函 数 4. Refresh display 如 果 编 辑 窗 口 偶 然 被 用 户 窗 口 重 写 了 可 用 此 恢 复 编 辑 窗 口 的 内 容 1.13.10 Break/watch 菜 单 按 Alt+B 可 进 入 Break/watch 菜 单, 该 菜 单 有 以 下 内 容, 如 图 所 示 : 1. Add watch: 向 监 视 窗 口 插 入 一 监 视 表 达 式 第 23 页
2. Delete watch: 从 监 视 窗 口 中 删 除 当 前 的 监 视 表 达 式 3. Edit watch: 在 监 视 窗 口 中 编 辑 一 个 监 视 表 达 式 4. Remove all :watches 从 监 视 窗 口 中 删 除 所 有 的 监 视 表 达 式 5. Toggle breakpoint: 对 光 标 所 在 的 行 设 置 或 清 除 断 点 6. Clear all breakpoints: 清 除 所 有 断 点 7. View next breakpoint: 将 光 标 移 动 到 下 一 个 断 点 处 1.13.11 Turbo C 2.0 的 配 置 文 件 所 谓 配 置 文 件 是 包 含 Turbo C 2.0 有 关 信 息 的 文 件, 其 中 存 有 编 译 连 接 的 选 择 和 路 径 等 信 息 可 以 用 下 述 方 法 建 立 Turbo C 2.0 的 配 置 : 1. 建 立 用 户 自 命 名 的 配 置 文 件 : 可 以 从 Options 菜 单 中 选 择 Options/Save options 命 令, 将 当 前 集 成 开 发 环 境 的 所 有 配 置 存 入 一 个 由 用 户 命 名 的 配 置 文 件 中 下 次 启 动 TC 时 只 要 在 DOS 下 键 入 : tc/c< 用 户 命 名 的 配 置 文 件 名 > 就 会 按 这 个 配 置 文 件 中 的 内 容 作 为 Turbo C 2.0 的 选 择 2. 若 设 置 Options/Environment/Config auto save 为 on, 则 退 出 集 成 开 发 环 境 时, 当 前 的 设 置 会 自 动 存 放 到 Turbo C 2.0 配 置 文 件 TCCONFIG.TC 中 Turbo C 在 启 动 时 会 自 动 寻 找 这 个 配 置 文 件 3. 用 TCINST 设 置 Turbo C 的 有 关 配 置, 并 将 结 果 存 入 TC.EXE 中 Turbo C 在 启 动 时, 若 没 有 找 到 配 置 文 件, 则 取 TC.EXE 中 的 缺 省 值 2 程 序 的 灵 魂 算 法 一 个 程 序 应 包 括 : 对 数 据 的 描 述 在 程 序 中 要 指 定 数 据 的 类 型 和 数 据 的 组 织 形 式, 即 数 据 结 构 (data structure) 对 操 作 的 描 述 即 操 作 步 骤, 也 就 是 算 法 (algorithm) Nikiklaus Wirth 提 出 的 公 式 : 数 据 结 构 + 算 法 = 程 序 教 材 认 为 : 程 序 = 算 法 + 数 据 结 构 + 程 序 设 计 方 法 + 语 言 工 具 和 环 境 这 4 个 方 面 是 一 个 程 序 涉 及 人 员 所 应 具 备 的 知 识 本 课 程 的 目 的 是 使 同 学 知 道 怎 样 编 写 一 个 C 程 序, 进 行 编 写 程 序 的 初 步 训 练, 因 此, 只 介 绍 算 法 的 初 步 知 识 2.1 算 法 的 概 念 做 任 何 事 情 都 有 一 定 的 步 骤 为 解 决 一 个 问 题 而 采 取 的 方 法 和 步 骤, 就 称 为 算 法 计 算 机 算 法 : 计 算 机 能 够 执 行 的 算 法 计 算 机 算 法 可 分 为 两 大 类 : 数 值 运 算 算 法 : 求 解 数 值 ; 非 数 值 运 算 算 法 : 事 务 管 理 领 域 第 24 页
2.2 简 单 算 法 举 例 例 2.1 求 1 2 3 4 5 最 原 始 方 法 : 步 骤 1: 先 求 1 2, 得 到 结 果 2 步 骤 2: 将 步 骤 1 得 到 的 乘 积 2 乘 以 3, 得 到 结 果 6 步 骤 3: 将 6 再 乘 以 4, 得 24 步 骤 4: 将 24 再 乘 以 5, 得 120 这 样 的 算 法 虽 然 正 确, 但 太 繁 改 进 的 算 法 : S1: 使 t=1 S2: 使 i=2 S3: 使 t i, 乘 积 仍 然 放 在 在 变 量 t 中, 可 表 示 为 t i t S4: 使 i 的 值 +1, 即 i+1 i S5: 如 果 i 5, 返 回 重 新 执 行 步 骤 S3 以 及 其 后 的 S4 和 S5; 否 则, 算 法 结 束 如 果 计 算 100! 只 需 将 S5: 若 i 5 改 成 i 100 即 可 如 果 该 求 1 3 5 7 9 11, 算 法 也 只 需 做 很 少 的 改 动 : S1: 1 t S2: 3 i S3: t i t S4: i+2 t S5: 若 i 11, 返 回 S3, 否 则, 结 束 该 算 法 不 仅 正 确, 而 且 是 计 算 机 较 好 的 算 法, 因 为 计 算 机 是 高 速 运 算 的 自 动 机 器, 实 现 循 环 轻 而 易 举 思 考 : 若 将 S5 写 成 :S5: 若 i<11, 返 回 S3; 否 则, 结 束 例 2.2 有 50 个 学 生, 要 求 将 他 们 之 中 成 绩 在 80 分 以 上 者 打 印 出 来 如 果,n 表 示 学 生 学 号,n i 表 示 第 个 学 生 学 号 ;g 表 示 学 生 成 绩,g i 表 示 第 个 学 生 成 绩 ; 则 算 法 可 表 示 如 下 : S1: 1 i S2: 如 果 g i 80, 则 打 印 n i 和 g i, 否 则 不 打 印 S3: i+1 i S4: 若 i 50, 返 回 S2, 否 则, 结 束 例 2.3 判 定 2000 2500 年 中 的 每 一 年 是 否 闰 年, 将 结 果 输 出 润 年 的 条 件 : 第 25 页
1) 能 被 4 整 除, 但 不 能 被 100 整 除 的 年 份 ; 2) 能 被 100 整 除, 又 能 被 400 整 除 的 年 份 ; 设 y 为 被 检 测 的 年 份, 则 算 法 可 表 示 如 下 : S1: 2000 y S2: 若 y 不 能 被 4 整 除, 则 输 出 y 不 是 闰 年, 然 后 转 到 S6 S3: 若 y 能 被 4 整 除, 不 能 被 100 整 除, 则 输 出 y 是 闰 年, 然 后 转 到 S6 S4: 若 y 能 被 100 整 除, 又 能 被 400 整 除, 输 出 y 是 闰 年 否 则 输 出 y 不 是 闰 年, 然 后 转 到 S6 S5: 输 出 y 不 是 闰 年 S6:y+1 y S7: 当 y 2500 时, 返 回 S2 继 续 执 行, 否 则, 结 束 1 1 1 1 1 1 + +... + 例 2.4 求 2 3 4 99 100 算 法 可 表 示 如 下 : S1: sigh=1 S2: sum=1 S3: deno=2 S4: sigh=(-1) sigh S5: term= sigh (1/deno ) S6: term=sum+term S7: deno= deno +1 S8: 若 deno 100, 返 回 S4; 否 则, 结 束 第 26 页
例 2.5 对 一 个 大 于 或 等 于 3 的 正 整 数, 判 断 它 是 不 是 一 个 素 数 算 法 可 表 示 如 下 : S1: 输 入 n 的 值 S2: i=2 S3: n 被 i 除, 得 余 数 r S4: 如 果 r=0, 表 示 n 能 被 i 整 除, 则 打 印 n 不 是 素 数, 算 法 结 束 ; 否 则 执 行 S5 S5: i+1 i S6: 如 果 i n-1, 返 回 S3; 否 则 打 印 n 是 素 数 ; 然 后 算 法 结 束 改 进 : S6: 如 果 i n, 返 回 S3; 否 则 打 印 n 是 素 数 ; 然 后 算 法 结 束 2.3 算 法 的 特 性 有 穷 性 : 一 个 算 法 应 包 含 有 限 的 操 作 步 骤 而 不 能 是 无 限 的 确 定 性 : 算 法 中 每 一 个 步 骤 应 当 是 确 定 的, 而 不 能 应 当 是 含 糊 的 模 棱 两 可 的 有 零 个 或 多 个 输 入 有 一 个 或 多 个 输 出 有 效 性 : 算 法 中 每 一 个 步 骤 应 当 能 有 效 地 执 行, 并 得 到 确 定 的 结 果 对 于 程 序 设 计 人 员, 必 须 会 设 计 算 法, 并 根 据 算 法 写 出 程 序 2.4 怎 样 表 示 一 个 算 法 2.4.1 用 自 然 语 言 表 示 算 法 除 了 很 简 单 的 问 题, 一 般 不 用 自 然 语 言 表 示 算 法 2.4.2 用 流 程 图 表 示 算 法 流 程 图 表 示 算 法, 直 观 形 象, 易 于 理 解 第 27 页
例 2.6 将 例 2.1 求 5! 的 算 用 流 程 图 表 示 例 2.7 将 例 2.2 的 算 用 流 程 图 表 示 第 28 页
例 2.8 将 例 2.3 判 定 闰 年 的 算 用 流 程 图 表 示 第 29 页
1 1 1 1 1 1 + +... + 例 2.9 将 例 2.4 求 2 3 4 99 100 的 算 用 流 程 图 表 示 一 个 流 程 图 包 括 : 1. 表 示 相 应 操 作 的 框 ; 2. 带 箭 头 的 流 程 线 ; 3. 框 内 外 必 要 的 文 字 说 明 第 30 页
2.4.3 三 种 基 本 结 构 和 改 进 的 流 程 图 1. 顺 序 结 构 : 2. 选 择 结 构 : 3. 循 环 结 构 第 31 页
三 种 基 本 结 构 的 共 同 特 点 : 只 有 一 个 入 口 ; 只 有 一 个 出 口 ; 结 构 内 的 每 一 部 分 都 有 机 会 被 执 行 到 ; 结 构 内 不 存 在 死 循 环 2.4.4 用 N-S 流 程 图 表 示 算 法 1973 年 美 国 学 者 提 出 了 一 种 新 型 流 程 图 :N-S 流 程 图 顺 序 结 构 : 第 32 页
选 择 结 构 : 循 环 结 构 : 2.4.5 用 伪 代 码 表 示 算 法 伪 代 码 使 用 介 于 自 然 语 言 和 计 算 机 语 言 之 间 的 文 字 和 符 号 来 描 述 算 法 第 33 页
2.4.6 用 计 算 机 语 言 表 示 算 法 我 们 的 任 务 是 用 计 算 机 解 题, 就 是 用 计 算 机 实 现 算 法 ; 用 计 算 机 语 言 表 示 算 法 必 须 严 格 遵 循 所 用 语 言 的 语 法 规 则 例 2.20 求 1 2 3 4 5 用 C 语 言 表 示 main() int i,t; t=1; i=2; while(i<=5) t=t*i; i=i+1; printf( %d,t); 例 2.21 求 级 数 的 值 main() int sigh=1; float deno=2.0,sum=1.0,term; while(deno<=100) sigh= -sigh; term= sigh/ deno; sum=sum+term; deno=deno+1; printf( %f,sum); 2.5 结 构 化 程 序 设 计 方 法 自 顶 向 下 ; 逐 步 细 化 ; 模 块 化 设 计 ; 结 构 化 编 码 第 34 页
3 数 据 类 型 运 算 符 与 表 达 式 3.1 C 语 言 的 数 据 类 型 在 第 一 章 中, 我 们 已 经 看 到 程 序 中 使 用 的 各 种 变 量 都 应 预 先 加 以 定 义, 即 先 定 义, 后 使 用 对 变 量 的 定 义 可 以 包 括 三 个 方 面 : 数 据 类 型 存 储 类 型 作 用 域 在 本 章 中, 我 们 只 介 绍 数 据 类 型 的 说 明 其 它 说 明 在 以 后 各 章 中 陆 续 介 绍 所 谓 数 据 类 型 是 按 被 定 义 变 量 的 性 质, 表 示 形 式, 占 据 存 储 空 间 的 多 少, 构 造 特 点 来 划 分 的 在 C 语 言 中, 数 据 类 型 可 分 为 : 基 本 数 据 类 型, 构 造 数 据 类 型, 指 针 类 型, 空 类 型 四 大 类 第 35 页
数 据 类 型 基 本 类 型 整 型 字 符 型 实 型 ( 浮 点 型 ) 单 精 度 型 双 精 度 型 枚 举 类 型 构 造 类 型 数 组 类 型 结 构 体 类 型 共 用 体 类 型 指 针 类 型 空 类 型 1. 基 本 数 据 类 型 : 基 本 数 据 类 型 最 主 要 的 特 点 是, 其 值 不 可 以 再 分 解 为 其 它 类 型 也 就 是 说, 基 本 数 据 类 型 是 自 我 说 明 的 2. 构 造 数 据 类 型 : 构 造 数 据 类 型 是 根 据 已 定 义 的 一 个 或 多 个 数 据 类 型 用 构 造 的 方 法 来 定 义 的 也 就 是 说, 一 个 构 造 类 型 的 值 可 以 分 解 成 若 干 个 成 员 或 元 素 每 个 成 员 都 是 一 个 基 本 数 据 类 型 或 又 是 一 个 构 造 类 型 在 C 语 言 中, 构 造 类 型 有 以 下 几 种 : 数 组 类 型 结 构 体 类 型 共 用 体 ( 联 合 ) 类 型 3. 指 针 类 型 : 指 针 是 一 种 特 殊 的, 同 时 又 是 具 有 重 要 作 用 的 数 据 类 型 其 值 用 来 表 示 某 个 变 量 在 内 存 储 器 中 的 地 址 虽 然 指 针 变 量 的 取 值 类 似 于 整 型 量, 但 这 是 两 个 类 型 完 全 不 同 的 量, 因 此 不 能 混 为 一 谈 第 36 页
4. 空 类 型 : 在 调 用 函 数 值 时, 通 常 应 向 调 用 者 返 回 一 个 函 数 值 这 个 返 回 的 函 数 值 是 具 有 一 定 的 数 据 类 型 的, 应 在 函 数 定 义 及 函 数 说 明 中 给 以 说 明, 例 如 在 例 题 中 给 出 的 max 函 数 定 义 中, 函 数 头 为 :int max(int a,int b); 其 中 int 类 型 说 明 符 即 表 示 该 函 数 的 返 回 值 为 整 型 量 又 如 在 例 题 中, 使 用 了 库 函 数 sin, 由 于 系 统 规 定 其 函 数 返 回 值 为 双 精 度 浮 点 型, 因 此 在 赋 值 语 句 s=sin (x); 中,s 也 必 须 是 双 精 度 浮 点 型, 以 便 与 sin 函 数 的 返 回 值 一 致 所 以 在 说 明 部 分, 把 s 说 明 为 双 精 度 浮 点 型 但 是, 也 有 一 类 函 数, 调 用 后 并 不 需 要 向 调 用 者 返 回 函 数 值, 这 种 函 数 可 以 定 义 为 空 类 型 其 类 型 说 明 符 为 void 在 后 面 函 数 中 还 要 详 细 介 绍 在 本 章 中, 我 们 先 介 绍 基 本 数 据 类 型 中 的 整 型 浮 点 型 和 字 符 型 其 余 类 型 在 以 后 各 章 中 陆 续 介 绍 3.2 常 量 与 变 量 对 于 基 本 数 据 类 型 量, 按 其 取 值 是 否 可 改 变 又 分 为 常 量 和 变 量 两 种 在 程 序 执 行 过 程 中, 其 值 不 发 生 改 变 的 量 称 为 常 量, 其 值 可 变 的 量 称 为 变 量 它 们 可 与 数 据 类 型 结 合 起 来 分 类 例 如, 可 分 为 整 型 常 量 整 型 变 量 浮 点 常 量 浮 点 变 量 字 符 常 量 字 符 变 量 枚 举 常 量 枚 举 变 量 在 程 序 中, 常 量 是 可 以 不 经 说 明 而 直 接 引 用 的, 而 变 量 则 必 须 先 定 义 后 使 用 整 型 量 包 括 整 型 常 量 整 型 变 量 3.2.1 常 量 和 符 号 常 量 在 程 序 执 行 过 程 中, 其 值 不 发 生 改 变 的 量 称 为 常 量 直 接 常 量 ( 字 面 常 量 ): 整 型 常 量 :12 0-3; 实 型 常 量 :4.6-1.23; 字 符 常 量 : a b 标 识 符 : 用 来 标 识 变 量 名 符 号 常 量 名 函 数 名 数 组 名 类 型 名 文 件 名 的 有 效 字 符 序 列 符 号 常 量 : 用 标 示 符 代 表 一 个 常 量 在 C 语 言 中, 可 以 用 一 个 标 识 符 来 表 示 一 个 常 量, 称 之 为 符 号 常 量 符 号 常 量 在 使 用 之 前 必 须 先 定 义, 其 一 般 形 式 为 : #define 标 识 符 常 量 其 中 #define 也 是 一 条 预 处 理 命 令 ( 预 处 理 命 令 都 以 "#" 开 头 ), 称 为 宏 定 义 命 令 ( 在 后 面 预 处 理 程 序 中 将 进 一 步 介 绍 ), 其 功 能 是 把 该 标 识 符 定 义 为 其 后 的 常 量 值 一 经 定 义, 以 后 在 程 序 中 所 有 出 现 该 标 识 符 的 地 方 均 代 之 以 该 常 量 值 习 惯 上 符 号 常 量 的 标 识 符 用 大 写 字 母, 变 量 标 识 符 用 小 写 字 母, 以 示 区 别 例 3.1 符 号 常 量 的 使 用 #define PRICE 30 main() int num,total; num=10; total=num* PRICE; printf( total=%d,total); 第 37 页
用 标 识 符 代 表 一 个 常 量, 称 为 符 号 常 量 符 号 常 量 与 变 量 不 同, 它 的 值 在 其 作 用 域 内 不 能 改 变, 也 不 能 再 被 赋 值 使 用 符 号 常 量 的 好 处 是 : 含 义 清 楚 ; 能 做 到 一 改 全 改 3.2.2 变 量 其 值 可 以 改 变 的 量 称 为 变 量 一 个 变 量 应 该 有 一 个 名 字, 在 内 存 中 占 据 一 定 的 存 储 单 元 变 量 定 义 必 须 放 在 变 量 使 用 之 前 一 般 放 在 函 数 体 的 开 头 部 分 要 区 分 变 量 名 和 变 量 值 是 两 个 不 同 的 概 念 a 3 变 量 名 变 量 值 存 储 单 元 3.3 整 型 数 据 3.3.1 整 型 常 量 的 表 示 方 法 整 型 常 量 就 是 整 常 数 在 C 语 言 中, 使 用 的 整 常 数 有 八 进 制 十 六 进 制 和 十 进 制 三 种 1) 十 进 制 整 常 数 : 十 进 制 整 常 数 没 有 前 缀 其 数 码 为 0~9 以 下 各 数 是 合 法 的 十 进 制 整 常 数 : 237-568 65535 1627; 以 下 各 数 不 是 合 法 的 十 进 制 整 常 数 : 023 ( 不 能 有 前 导 0) 23D ( 含 有 非 十 进 制 数 码 ) 在 程 序 中 是 根 据 前 缀 来 区 分 各 种 进 制 数 的 因 此 在 书 写 常 数 时 不 要 把 前 缀 弄 错 造 成 结 果 不 正 确 2) 八 进 制 整 常 数 : 八 进 制 整 常 数 必 须 以 0 开 头, 即 以 0 作 为 八 进 制 数 的 前 缀 数 码 取 值 为 0~7 八 进 制 数 通 常 是 无 符 号 数 以 下 各 数 是 合 法 的 八 进 制 数 : 015( 十 进 制 为 13) 0101( 十 进 制 为 65) 0177777( 十 进 制 为 65535); 以 下 各 数 不 是 合 法 的 八 进 制 数 : 256( 无 前 缀 0) 03A2( 包 含 了 非 八 进 制 数 码 ) -0127( 出 现 了 负 号 ) 3) 十 六 进 制 整 常 数 : 十 六 进 制 整 常 数 的 前 缀 为 0X 或 0x 其 数 码 取 值 为 0~9,A~F 或 a~f 以 下 各 数 是 合 法 的 十 六 进 制 整 常 数 : 0X2A( 十 进 制 为 42) 0XA0 ( 十 进 制 为 160) 0XFFFF ( 十 进 制 为 65535); 以 下 各 数 不 是 合 法 的 十 六 进 制 整 常 数 : 5A ( 无 前 缀 0X) 0X3H ( 含 有 非 十 六 进 制 数 码 ) 第 38 页
4) 整 型 常 数 的 后 缀 : 在 16 位 字 长 的 机 器 上, 基 本 整 型 的 长 度 也 为 16 位, 因 此 表 示 的 数 的 范 围 也 是 有 限 定 的 十 进 制 无 符 号 整 常 数 的 范 围 为 0~65535, 有 符 号 数 为 -32768~+32767 八 进 制 无 符 号 数 的 表 示 范 围 为 0~0177777 十 六 进 制 无 符 号 数 的 表 示 范 围 为 0X0~0XFFFF 或 0x0~0xFFFF 如 果 使 用 的 数 超 过 了 上 述 范 围, 就 必 须 用 长 整 型 数 来 表 示 长 整 型 数 是 用 后 缀 L 或 l 来 表 示 的 例 如 : 十 进 制 长 整 常 数 : 158L ( 十 进 制 为 158) 358000L ( 十 进 制 为 358000); 八 进 制 长 整 常 数 : 012L ( 十 进 制 为 10) 077L ( 十 进 制 为 63) 0200000L ( 十 进 制 为 65536); 十 六 进 制 长 整 常 数 : 0X15L ( 十 进 制 为 21) 0XA5L ( 十 进 制 为 165) 0X10000L ( 十 进 制 为 65536) 长 整 数 158L 和 基 本 整 常 数 158 在 数 值 上 并 无 区 别 但 对 158L, 因 为 是 长 整 型 量,C 编 译 系 统 将 为 它 分 配 4 个 字 节 存 储 空 间 而 对 158, 因 为 是 基 本 整 型, 只 分 配 2 个 字 节 的 存 储 空 间 因 此 在 运 算 和 输 出 格 式 上 要 予 以 注 意, 避 免 出 错 无 符 号 数 也 可 用 后 缀 表 示, 整 型 常 数 的 无 符 号 数 的 后 缀 为 U 或 u 例 如 : 358u,0x38Au,235Lu 均 为 无 符 号 数 前 缀, 后 缀 可 同 时 使 用 以 表 示 各 种 类 型 的 数 如 0XA5Lu 表 示 十 六 进 制 无 符 号 长 整 数 A5, 其 十 进 制 为 165 3.3.2 整 型 变 量 1. 整 型 数 据 在 内 存 中 的 存 放 形 式 如 果 定 义 了 一 个 整 型 变 量 i: int i; i=10; i 10 0 0 0 0 0 0 0 0 0 0 0 0 1 0 1 0 数 值 是 以 补 码 表 示 的 : 正 数 的 补 码 和 原 码 相 同 ; 负 数 的 补 码 : 将 该 数 的 绝 对 值 的 二 进 制 形 式 按 位 取 反 再 加 1 例 如 : 求 -10 的 补 码 : 10 的 原 码 : 0 0 0 0 0 0 0 0 0 0 0 0 1 0 1 0 取 反 : 1 1 1 1 1 1 1 1 1 1 1 1 0 1 0 1 再 加 1, 得 -10 的 补 码 : 第 39 页
1 1 1 1 1 1 1 1 1 1 1 1 0 1 1 0 由 此 可 知, 左 面 的 第 一 位 是 表 示 符 号 的 2. 整 型 变 量 的 分 类 1) 基 本 型 : 类 型 说 明 符 为 int, 在 内 存 中 占 2 个 字 节 2) 短 整 量 : 类 型 说 明 符 为 short int 或 short 所 占 字 节 和 取 值 范 围 均 与 基 本 型 相 同 3) 长 整 型 : 类 型 说 明 符 为 long int 或 long, 在 内 存 中 占 4 个 字 节 4) 无 符 号 型 : 类 型 说 明 符 为 unsigned 无 符 号 型 又 可 与 上 述 三 种 类 型 匹 配 而 构 成 : 无 符 号 基 本 型 : 类 型 说 明 符 为 unsigned int 或 unsigned 无 符 号 短 整 型 : 类 型 说 明 符 为 unsigned short 无 符 号 长 整 型 : 类 型 说 明 符 为 unsigned long 各 种 无 符 号 类 型 量 所 占 的 内 存 空 间 字 节 数 与 相 应 的 有 符 号 类 型 量 相 同 但 由 于 省 去 了 符 号 位, 故 不 能 表 示 负 数 有 符 号 整 型 变 量 : 最 大 表 示 32767 0 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 无 符 号 整 型 变 量 : 最 大 表 示 65535 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 下 表 列 出 了 Turbo C 中 各 类 整 型 量 所 分 配 的 内 存 字 节 数 及 数 的 表 示 范 围 类 型 说 明 符 数 的 范 围 字 节 数 int -32768~32767 即 -2 15 ~(2 15-1) 2 unsigned int 0~65535 即 0~(2 16-1) 2 short int -32768~32767 即 -2 15 ~(2 15-1) 2 unsigned short int 0~65535 即 0~(2 16-1) 2 long int -2147483648~2147483647 即 -2 31 ~(2 31-1) 4 unsigned long 0~4294967295 即 0~(2 32-1) 4 以 13 为 例 : int 型 : 00 00 00 00 00 00 11 01 short int 型 : 00 00 00 00 00 00 11 01 long int 型 : 00 00 00 00 00 00 00 00 00 00 00 00 00 00 11 01 unsigned int 型 : 00 00 00 00 00 00 11 01 unsigned short int 型 : 00 00 00 00 00 00 11 01 unsigned long int 型 : 00 00 00 00 00 00 00 00 00 00 00 00 00 00 11 01 3. 整 型 变 量 的 定 义 变 量 定 义 的 一 般 形 式 为 : 第 40 页
类 型 说 明 符 变 量 名 标 识 符, 变 量 名 标 识 符,...; 例 如 : int a,b,c; (a,b,c 为 整 型 变 量 ) long x,y; (x,y 为 长 整 型 变 量 ) unsigned p,q; (p,q 为 无 符 号 整 型 变 量 ) 在 书 写 变 量 定 义 时, 应 注 意 以 下 几 点 : 允 许 在 一 个 类 型 说 明 符 后, 定 义 多 个 相 同 类 型 的 变 量 各 变 量 名 之 间 用 逗 号 间 隔 类 型 说 明 符 与 变 量 名 之 间 至 少 用 一 个 空 格 间 隔 最 后 一 个 变 量 名 之 后 必 须 以 ; 号 结 尾 变 量 定 义 必 须 放 在 变 量 使 用 之 前 一 般 放 在 函 数 体 的 开 头 部 分 例 3.2 整 型 变 量 的 定 义 与 使 用 main() int a,b,c,d; unsigned u; a=12;b=-24;u=10; c=a+u;d=b+u; printf( a+u=%d,b+u=%d\n,c,d); 4. 整 型 数 据 的 溢 出 例 3.3 整 型 数 据 的 溢 出 main() int a,b; a=32767; b=a+1; printf("%d,%d\n",a,b); 例 3.4 main() long x,y; int a,b,c,d; x=5; y=6; a=7; b=8; 32767: -32768 0 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 第 41 页
c=x+a; d=y+b; printf("c=x+a=%d,d=y+b=%d\n",c,d); 从 程 序 中 可 以 看 到 :x, y 是 长 整 型 变 量,a, b 是 基 本 整 型 变 量 它 们 之 间 允 许 进 行 运 算, 运 算 结 果 为 长 整 型 但 c,d 被 定 义 为 基 本 整 型, 因 此 最 后 结 果 为 基 本 整 型 本 例 说 明, 不 同 类 型 的 量 可 以 参 与 运 算 并 相 互 赋 值 其 中 的 类 型 转 换 是 由 编 译 系 统 自 动 完 成 的 有 关 类 型 转 换 的 规 则 将 在 以 后 介 绍 3.4 实 型 数 据 3.4.1 实 型 常 量 的 表 示 方 法 实 型 也 称 为 浮 点 型 实 型 常 量 也 称 为 实 数 或 者 浮 点 数 在 C 语 言 中, 实 数 只 采 用 十 进 制 它 有 二 种 形 式 : 十 进 制 小 数 形 式, 指 数 形 式 1) 十 进 制 数 形 式 : 由 数 码 0~ 9 和 小 数 点 组 成 例 如 : 0.0 25.0 5.789 0.13 5.0 300. -267.8230 等 均 为 合 法 的 实 数 注 意, 必 须 有 小 数 点 2) 指 数 形 式 : 由 十 进 制 数, 加 阶 码 标 志 e 或 E 以 及 阶 码 ( 只 能 为 整 数, 可 以 带 符 号 ) 组 成 其 一 般 形 式 为 : a E n(a 为 十 进 制 数,n 为 十 进 制 整 数 ) 其 值 为 a*10 n 如 : 2.1E5 ( 等 于 2.1*10 5 ) 3.7E-2 ( 等 于 3.7*10-2 ) 0.5E7 ( 等 于 0.5*10 7 ) -2.8E-2 ( 等 于 -2.8*10-2 ) 以 下 不 是 合 法 的 实 数 : 345 ( 无 小 数 点 ) E7 ( 阶 码 标 志 E 之 前 无 数 字 ) -5 ( 无 阶 码 标 志 ) 53.-E3 ( 负 号 位 置 不 对 ) 2.7E ( 无 阶 码 ) 标 准 C 允 许 浮 点 数 使 用 后 缀 后 缀 为 f 或 F 即 表 示 该 数 为 浮 点 数 如 356f 和 356. 是 等 价 的 例 3.5 说 明 了 这 种 情 况 main() printf("%f\n ",356.); printf("%f\n ",356); printf("%f\n ",356f); 第 42 页
3.4.2 实 型 变 量 1. 实 型 数 据 在 内 存 中 的 存 放 形 式 实 型 数 据 一 般 占 4 个 字 节 (32 位 ) 内 存 空 间 按 指 数 形 式 存 储 实 数 3.14159 在 内 存 中 的 存 放 形 式 如 下 : +.314159 1 数 符 小 数 部 分 指 数 小 数 部 分 占 的 位 (bit) 数 愈 多, 数 的 有 效 数 字 愈 多, 精 度 愈 高 指 数 部 分 占 的 位 数 愈 多, 则 能 表 示 的 数 值 范 围 愈 大 2. 实 型 变 量 的 分 类 实 型 变 量 分 为 : 单 精 度 (float 型 ) 双 精 度 (double 型 ) 和 长 双 精 度 (long double 型 ) 三 类 在 Turbo C 中 单 精 度 型 占 4 个 字 节 (32 位 ) 内 存 空 间, 其 数 值 范 围 为 3.4E-38~3.4E+38, 只 能 提 供 七 位 有 效 数 字 双 精 度 型 占 8 个 字 节 (64 位 ) 内 存 空 间, 其 数 值 范 围 为 1.7E-308~1.7E+308, 可 提 供 16 位 有 效 数 字 类 型 说 明 符 比 特 数 ( 字 节 数 ) 有 效 数 字 数 的 范 围 float 32(4) 6~7 10-37 ~10 38 double 64(8) 15~16 10-307 ~10 308 long double 128(16) 18~19 10-4931 ~10 4932 实 型 变 量 定 义 的 格 式 和 书 写 规 则 与 整 型 相 同 例 如 : float x,y; (x,y 为 单 精 度 实 型 量 ) double a,b,c; (a,b,c 为 双 精 度 实 型 量 ) 3. 实 型 数 据 的 舍 入 误 差 由 于 实 型 变 量 是 由 有 限 的 存 储 单 元 组 成 的, 因 此 能 提 供 的 有 效 数 字 总 是 有 限 的 如 下 例 例 3.6 实 型 数 据 的 舍 入 误 差 main() float a,b; a=123456.789e5; b=a+20 printf("%f\n",a); printf("%f\n",b); 注 意 :1.0/3*3 的 结 果 并 不 等 于 1 例 3.7 main() float a; double b; a=33333.33333; 第 43 页
b=33333.33333333333333; printf("%f\n%f\n",a,b); 从 本 例 可 以 看 出, 由 于 a 是 单 精 度 浮 点 型, 有 效 位 数 只 有 七 位 而 整 数 已 占 五 位, 故 小 数 二 位 后 之 后 均 为 无 效 数 字 b 是 双 精 度 型, 有 效 位 为 十 六 位 但 Turbo C 规 定 小 数 后 最 多 保 留 六 位, 其 余 部 分 四 舍 五 入 3.4.3 实 型 常 数 的 类 型 实 型 常 数 不 分 单 双 精 度, 都 按 双 精 度 double 型 处 理 3.5 字 符 型 数 据 字 符 型 数 据 包 括 字 符 常 量 和 字 符 变 量 3.5.1 字 符 常 量 字 符 常 量 是 用 单 引 号 括 起 来 的 一 个 字 符 例 如 : 'a' 'b' '=' '+' '?' 都 是 合 法 字 符 常 量 在 C 语 言 中, 字 符 常 量 有 以 下 特 点 : 1) 字 符 常 量 只 能 用 单 引 号 括 起 来, 不 能 用 双 引 号 或 其 它 括 号 2) 字 符 常 量 只 能 是 单 个 字 符, 不 能 是 字 符 串 3) 字 符 可 以 是 字 符 集 中 任 意 字 符 但 数 字 被 定 义 为 字 符 型 之 后 就 不 能 参 与 数 值 运 算 如 '5' 和 5 是 不 同 的 '5' 是 字 符 常 量, 不 能 参 与 运 算 3.5.2 转 义 字 符 转 义 字 符 是 一 种 特 殊 的 字 符 常 量 转 义 字 符 以 反 斜 线 "\" 开 头, 后 跟 一 个 或 几 个 字 符 转 义 字 符 具 有 特 定 的 含 义, 不 同 于 字 符 原 有 的 意 义, 故 称 转 义 字 符 例 如, 在 前 面 各 例 题 printf 函 数 的 格 式 串 中 用 到 的 \n 就 是 一 个 转 义 字 符, 其 意 义 是 回 车 换 行 转 义 字 符 主 要 用 来 表 示 那 些 用 一 般 字 符 不 便 于 表 示 的 控 制 代 码 常 用 的 转 义 字 符 及 其 含 义 转 义 字 符 转 义 字 符 的 意 义 ASCII 代 码 \n 回 车 换 行 10 \t 横 向 跳 到 下 一 制 表 位 置 9 \b 退 格 8 \r 回 车 13 \f 走 纸 换 页 12 第 44 页
\\ 反 斜 线 符 "\" 92 \' 单 引 号 符 39 \ 双 引 号 符 34 \a 鸣 铃 7 \ddd 1~3 位 八 进 制 数 所 代 表 的 字 符 \xhh 1~2 位 十 六 进 制 数 所 代 表 的 字 符 广 义 地 讲,C 语 言 字 符 集 中 的 任 何 一 个 字 符 均 可 用 转 义 字 符 来 表 示 表 中 的 \ddd 和 \xhh 正 是 为 此 而 提 出 的 ddd 和 hh 分 别 为 八 进 制 和 十 六 进 制 的 ASCII 代 码 如 \101 表 示 字 母 "A",\102 表 示 字 母 "B",\134 表 示 反 斜 线,\XOA 表 示 换 行 等 例 3.8 转 义 字 符 的 使 用 main() int a,b,c; a=5; b=6; c=7; printf( ab c\tde\rf\n ); printf( hijk\tl\bm\n ); 3.5.3 字 符 变 量 字 符 变 量 用 来 存 储 字 符 常 量, 即 单 个 字 符 字 符 变 量 的 类 型 说 明 符 是 char 字 符 变 量 类 型 定 义 的 格 式 和 书 写 规 则 都 与 整 型 变 量 相 同 例 如 : char a,b; 3.5.4 字 符 数 据 在 内 存 中 的 存 储 形 式 及 使 用 方 法 每 个 字 符 变 量 被 分 配 一 个 字 节 的 内 存 空 间, 因 此 只 能 存 放 一 个 字 符 字 符 值 是 以 ASCII 码 的 形 式 存 放 在 变 量 的 内 存 单 元 之 中 的 如 x 的 十 进 制 ASCII 码 是 120,y 的 十 进 制 ASCII 码 是 121 对 字 符 变 量 a,b 赋 予 'x' 和 'y' 值 : a='x'; b='y'; 实 际 上 是 在 a,b 两 个 单 元 内 存 放 120 和 121 的 二 进 制 代 码 : a: 0 1 1 1 1 0 0 0 b: 0 1 1 1 1 0 0 1 所 以 也 可 以 把 它 们 看 成 是 整 型 量 C 语 言 允 许 对 整 型 变 量 赋 以 字 符 值, 也 允 许 对 字 符 变 量 赋 以 整 型 值 在 输 出 时, 允 许 把 字 符 变 量 按 整 型 量 输 出, 也 允 许 把 整 型 量 按 字 符 量 输 出 整 型 量 为 二 字 节 量, 字 符 量 为 单 字 节 量, 当 整 型 量 按 字 符 型 量 处 理 时, 只 有 低 八 位 字 节 参 与 处 理 例 3.9 向 字 符 变 量 赋 以 整 数 第 45 页
main() char a,b; a=120; b=121; printf("%c,%c\n",a,b); printf("%d,%d\n",a,b); 本 程 序 中 定 义 a,b 为 字 符 型, 但 在 赋 值 语 句 中 赋 以 整 型 值 从 结 果 看,a,b 值 的 输 出 形 式 取 决 于 printf 函 数 格 式 串 中 的 格 式 符, 当 格 式 符 为 "c" 时, 对 应 输 出 的 变 量 值 为 字 符, 当 格 式 符 为 "d" 时, 对 应 输 出 的 变 量 值 为 整 数 例 3.10 main() char a,b; a='a'; b='b'; a=a-32; b=b-32; printf("%c,%c\n%d,%d\n",a,b,a,b); 本 例 中,a,b 被 说 明 为 字 符 变 量 并 赋 予 字 符 值,C 语 言 允 许 字 符 变 量 参 与 数 值 运 算, 即 用 字 符 的 ASCII 码 参 与 运 算 由 于 大 小 写 字 母 的 ASCII 码 相 差 32, 因 此 运 算 后 把 小 写 字 母 换 成 大 写 字 母 然 后 分 别 以 整 型 和 字 符 型 输 出 3.5.5 字 符 串 常 量 字 符 串 常 量 是 由 一 对 双 引 号 括 起 的 字 符 序 列 例 如 : "CHINA", C program, "$12.5" 等 都 是 合 法 的 字 符 串 常 量 字 符 串 常 量 和 字 符 常 量 是 不 同 的 量 它 们 之 间 主 要 有 以 下 区 别 : 1) 字 符 常 量 由 单 引 号 括 起 来, 字 符 串 常 量 由 双 引 号 括 起 来 2) 字 符 常 量 只 能 是 单 个 字 符, 字 符 串 常 量 则 可 以 含 一 个 或 多 个 字 符 3) 可 以 把 一 个 字 符 常 量 赋 予 一 个 字 符 变 量, 但 不 能 把 一 个 字 符 串 常 量 赋 予 一 个 字 符 变 量 在 C 语 言 中 没 有 相 应 的 字 符 串 变 量 这 是 与 BASIC 语 言 不 同 的 但 是 可 以 用 一 个 字 符 数 组 来 存 放 一 个 字 符 串 常 量 在 数 组 一 章 内 予 以 介 绍 4) 字 符 常 量 占 一 个 字 节 的 内 存 空 间 字 符 串 常 量 占 的 内 存 字 节 数 等 于 字 符 串 中 字 节 数 加 1 增 加 的 一 个 字 节 中 存 放 字 符 "\0" (ASCII 码 为 0) 这 是 字 符 串 结 束 的 标 志 例 如 : 字 符 串 "C program" 在 内 存 中 所 占 的 字 节 为 : C p r o g r a m \0 第 46 页
字 符 常 量 'a' 和 字 符 串 常 量 "a" 虽 然 都 只 有 一 个 字 符, 但 在 内 存 中 的 情 况 是 不 同 的 'a' 在 内 存 中 占 一 个 字 节, 可 表 示 为 : a "a" 在 内 存 中 占 二 个 字 节, 可 表 示 为 : a \0 3.6 变 量 赋 初 值 在 程 序 中 常 常 需 要 对 变 量 赋 初 值, 以 便 使 用 变 量 语 言 程 序 中 可 有 多 种 方 法 为 变 量 提 供 初 值 本 小 节 先 介 绍 在 作 变 量 定 义 的 同 时 给 变 量 赋 以 初 值 的 方 法 这 种 方 法 称 为 初 始 化 在 变 量 定 义 中 赋 初 值 的 一 般 形 式 为 : 类 型 说 明 符 变 量 1= 值 1, 变 量 2= 值 2, ; 例 如 : int a=3; int b,c=5; float x=3.2,y=3f,z=0.75; char ch1='k',ch2='p'; 应 注 意, 在 定 义 中 不 允 许 连 续 赋 值, 如 a=b=c=5 是 不 合 法 的 例 3.11 main() int a=3,b,c=5; b=a+c; printf("a=%d,b=%d,c=%d\n",a,b,c); 3.7 各 类 数 值 型 数 据 之 间 的 混 合 运 算 变 量 的 数 据 类 型 是 可 以 转 换 的 转 换 的 方 法 有 两 种, 一 种 是 自 动 转 换, 一 种 是 强 制 转 换 自 动 转 换 发 生 在 不 同 数 据 类 型 的 量 混 合 运 算 时, 由 编 译 系 统 自 动 完 成 自 动 转 换 遵 循 以 下 规 则 : 1) 若 参 与 运 算 量 的 类 型 不 同, 则 先 转 换 成 同 一 类 型, 然 后 进 行 运 算 2) 转 换 按 数 据 长 度 增 加 的 方 向 进 行, 以 保 证 精 度 不 降 低 如 int 型 和 long 型 运 算 时, 先 把 int 量 转 成 long 型 后 再 进 行 运 算 3) 所 有 的 浮 点 运 算 都 是 以 双 精 度 进 行 的, 即 使 仅 含 float 单 精 度 量 运 算 的 表 达 式, 也 要 先 转 换 成 double 型, 再 作 运 算 4) char 型 和 short 型 参 与 运 算 时, 必 须 先 转 换 成 int 型 5) 在 赋 值 运 算 中, 赋 值 号 两 边 量 的 数 据 类 型 不 同 时, 赋 值 号 右 边 量 的 类 型 将 转 换 为 左 边 量 的 类 型 如 果 右 边 量 的 数 据 类 型 长 度 左 边 长 时, 将 丢 失 一 部 分 数 据, 这 样 会 降 低 精 度, 丢 失 的 部 分 按 四 舍 五 入 向 前 舍 入 下 图 表 示 了 类 型 自 动 转 换 的 规 则 第 47 页
double long unsigned int char,short 例 3.12 main() float PI=3.14159; int s,r=5; s=r*r*pi; printf("s=%d\n",s); 本 例 程 序 中,PI 为 实 型 ;s,r 为 整 型 在 执 行 s=r*r*pi 语 句 时,r 和 PI 都 转 换 成 double 型 计 算, 结 果 也 为 double 型 但 由 于 s 为 整 型, 故 赋 值 结 果 仍 为 整 型, 舍 去 了 小 数 部 分 强 制 类 型 转 换 强 制 类 型 转 换 是 通 过 类 型 转 换 运 算 来 实 现 的 其 一 般 形 式 为 : ( 类 型 说 明 符 ) ( 表 达 式 ) 其 功 能 是 把 表 达 式 的 运 算 结 果 强 制 转 换 成 类 型 说 明 符 所 表 示 的 类 型 例 如 : (float) a 把 a 转 换 为 实 型 (int)(x+y) 把 x+y 的 结 果 转 换 为 整 型 在 使 用 强 制 转 换 时 应 注 意 以 下 问 题 : 1) 类 型 说 明 符 和 表 达 式 都 必 须 加 括 号 ( 单 个 变 量 可 以 不 加 括 号 ), 如 把 (int)(x+y) 写 成 (int)x+y 则 成 了 把 x 转 换 成 int 型 之 后 再 与 y 相 加 了 2) 无 论 是 强 制 转 换 或 是 自 动 转 换, 都 只 是 为 了 本 次 运 算 的 需 要 而 对 变 量 的 数 据 长 度 进 行 的 临 时 性 转 换, 而 不 改 变 数 据 说 明 时 对 该 变 量 定 义 的 类 型 例 3.13 main() float f=5.75; printf("(int)f=%d,f=%f\n",(int)f,f); 第 48 页
本 例 表 明,f 虽 强 制 转 为 int 型, 但 只 在 运 算 中 起 作 用, 是 临 时 的, 而 f 本 身 的 类 型 并 不 改 变 因 此,(int)f 的 值 为 5( 删 去 了 小 数 ) 而 f 的 值 仍 为 5.75 3.8 算 术 运 算 符 和 算 术 表 达 式 C 语 言 中 运 算 符 和 表 达 式 数 量 之 多, 在 高 级 语 言 中 是 少 见 的 正 是 丰 富 的 运 算 符 和 表 达 式 使 C 语 言 功 能 十 分 完 善 这 也 是 C 语 言 的 主 要 特 点 之 一 C 语 言 的 运 算 符 不 仅 具 有 不 同 的 优 先 级, 而 且 还 有 一 个 特 点, 就 是 它 的 结 合 性 在 表 达 式 中, 各 运 算 量 参 与 运 算 的 先 后 顺 序 不 仅 要 遵 守 运 算 符 优 先 级 别 的 规 定, 还 要 受 运 算 符 结 合 性 的 制 约, 以 便 确 定 是 自 左 向 右 进 行 运 算 还 是 自 右 向 左 进 行 运 算 这 种 结 合 性 是 其 它 高 级 语 言 的 运 算 符 所 没 有 的, 因 此 也 增 加 了 C 语 言 的 复 杂 性 3.8.1 C 运 算 符 简 介 C 语 言 的 运 算 符 可 分 为 以 下 几 类 : 1. 算 术 运 算 符 : 用 于 各 类 数 值 运 算 包 括 加 (+) 减 (-) 乘 (*) 除 (/) 求 余 ( 或 称 模 运 算,%) 自 增 (++) 自 减 (--) 共 七 种 2. 关 系 运 算 符 : 用 于 比 较 运 算 包 括 大 于 (>) 小 于 (<) 等 于 (==) 大 于 等 于 (>=) 小 于 等 于 (<=) 和 不 等 于 (!=) 六 种 3. 逻 辑 运 算 符 : 用 于 逻 辑 运 算 包 括 与 (&&) 或 ( ) 非 (!) 三 种 4. 位 操 作 运 算 符 : 参 与 运 算 的 量, 按 二 进 制 位 进 行 运 算 包 括 位 与 (&) 位 或 ( ) 位 非 (~) 位 异 或 (^) 左 移 (<<) 右 移 (>>) 六 种 5. 赋 值 运 算 符 : 用 于 赋 值 运 算, 分 为 简 单 赋 值 (=) 复 合 算 术 赋 值 (+=,-=,*=,/=,%=) 和 复 合 位 运 算 赋 值 (&=, =,^=,>>=,<<=) 三 类 共 十 一 种 6. 条 件 运 算 符 : 这 是 一 个 三 目 运 算 符, 用 于 条 件 求 值 (?:) 7. 逗 号 运 算 符 : 用 于 把 若 干 表 达 式 组 合 成 一 个 表 达 式 (,) 8. 指 针 运 算 符 : 用 于 取 内 容 (*) 和 取 地 址 (&) 二 种 运 算 9. 求 字 节 数 运 算 符 : 用 于 计 算 数 据 类 型 所 占 的 字 节 数 (sizeof) 10. 特 殊 运 算 符 : 有 括 号 (), 下 标 [], 成 员 (,.) 等 几 种 3.8.2 算 术 运 算 符 和 算 术 表 达 式 1. 基 本 的 算 术 运 算 符 加 法 运 算 符 + : 加 法 运 算 符 为 双 目 运 算 符, 即 应 有 两 个 量 参 与 加 法 运 算 如 a+b,4+8 等 具 有 右 结 合 性 减 法 运 算 符 - : 减 法 运 算 符 为 双 目 运 算 符 但 - 也 可 作 负 值 运 算 符, 此 时 为 单 目 运 算, 如 -x,-5 等 具 有 左 结 合 性 乘 法 运 算 符 * : 双 目 运 算, 具 有 左 结 合 性 除 法 运 算 符 / : 双 目 运 算 具 有 左 结 合 性 参 与 运 算 量 均 为 整 型 时, 结 果 也 为 整 型, 舍 去 小 数 如 果 运 算 量 中 有 一 个 是 实 型, 则 结 果 为 双 精 度 实 型 第 49 页
例 3.14 main() printf("\n\n%d,%d\n",20/7,-20/7); printf("%f,%f\n",20.0/7,-20.0/7); 本 例 中,20/7,-20/7 的 结 果 均 为 整 型, 小 数 全 部 舍 去 而 20.0/7 和 -20.0/7 由 于 有 实 数 参 与 运 算, 因 此 结 果 也 为 实 型 求 余 运 算 符 ( 模 运 算 符 ) % : 双 目 运 算, 具 有 左 结 合 性 要 求 参 与 运 算 的 量 均 为 整 型 求 余 运 算 的 结 果 等 于 两 数 相 除 后 的 余 数 例 3.15 main() printf("%d\n",100%3); 本 例 输 出 100 除 以 3 所 得 的 余 数 1 2. 算 术 表 达 式 和 运 算 符 的 优 先 级 和 结 合 性 表 达 式 是 由 常 量 变 量 函 数 和 运 算 符 组 合 起 来 的 式 子 一 个 表 达 式 有 一 个 值 及 其 类 型, 它 们 等 于 计 算 表 达 式 所 得 结 果 的 值 和 类 型 表 达 式 求 值 按 运 算 符 的 优 先 级 和 结 合 性 规 定 的 顺 序 进 行 单 个 的 常 量 变 量 函 数 可 以 看 作 是 表 达 式 的 特 例 算 术 表 达 式 是 由 算 术 运 算 符 和 括 号 连 接 起 来 的 式 子 算 术 表 达 式 : 用 算 术 运 算 符 和 括 号 将 运 算 对 象 ( 也 称 操 作 数 ) 连 接 起 来 的 符 合 C 语 法 规 则 的 式 子 以 下 是 算 术 表 达 式 的 例 子 : a+b (a*2)/c (x+r)*8-(a+b)/7 ++I sin(x)+sin(y) (++i)-(j++)+(k--) 运 算 符 的 优 先 级 :C 语 言 中, 运 算 符 的 运 算 优 先 级 共 分 为 15 级 1 级 最 高,15 级 最 低 在 表 达 式 中, 优 先 级 较 高 的 先 于 优 先 级 较 低 的 进 行 运 算 而 在 一 个 运 算 量 两 侧 的 运 算 符 优 先 级 相 同 时, 则 按 运 算 符 的 结 合 性 所 规 定 的 结 合 方 向 处 理 运 算 符 的 结 合 性 :C 语 言 中 各 运 算 符 的 结 合 性 分 为 两 种, 即 左 结 合 性 ( 自 左 至 右 ) 和 右 结 合 性 ( 自 右 至 左 ) 例 如 算 术 运 算 符 的 结 合 性 是 自 左 至 右, 即 先 左 后 右 如 有 表 达 式 x-y+z 则 y 应 先 与 - 号 结 合, 执 行 x-y 运 算, 然 后 再 执 行 +z 的 运 算 这 种 自 左 至 右 的 结 合 方 向 就 称 为 左 结 合 性 而 自 右 至 左 的 结 合 方 向 称 为 右 结 合 性 最 典 型 的 右 结 合 性 运 算 符 是 赋 值 运 算 符 如 x=y=z, 由 于 = 的 右 结 合 性, 应 先 执 行 y=z 再 执 行 x=(y=z) 运 算 C 语 言 运 算 符 中 有 不 少 为 右 结 合 性, 应 注 意 区 别, 以 避 免 理 解 错 误 3. 强 制 类 型 转 换 运 算 符 其 一 般 形 式 为 : ( 类 型 说 明 符 ) ( 表 达 式 ) 其 功 能 是 把 表 达 式 的 运 算 结 果 强 制 转 换 成 类 型 说 明 符 所 表 示 的 类 型 例 如 : 第 50 页
(float) a 把 a 转 换 为 实 型 (int)(x+y) 把 x+y 的 结 果 转 换 为 整 型 4. 自 增 自 减 运 算 符 自 增 1, 自 减 1 运 算 符 : 自 增 1 运 算 符 记 为 ++, 其 功 能 是 使 变 量 的 值 自 增 1 自 减 1 运 算 符 记 为 --, 其 功 能 是 使 变 量 值 自 减 1 自 增 1, 自 减 1 运 算 符 均 为 单 目 运 算, 都 具 有 右 结 合 性 可 有 以 下 几 种 形 式 : ++i i 自 增 1 后 再 参 与 其 它 运 算 --i i 自 减 1 后 再 参 与 其 它 运 算 i++ i 参 与 运 算 后,i 的 值 再 自 增 1 i-- i 参 与 运 算 后,i 的 值 再 自 减 1 在 理 解 和 使 用 上 容 易 出 错 的 是 i++ 和 i-- 特 别 是 当 它 们 出 在 较 复 杂 的 表 达 式 或 语 句 中 时, 常 常 难 于 弄 清, 因 此 应 仔 细 分 析 例 3.16 main() int i=8; printf("%d\n",++i); printf("%d\n",--i); printf("%d\n",i++); printf("%d\n",i--); printf("%d\n",-i++); printf("%d\n",-i--); i 的 初 值 为 8, 第 2 行 i 加 1 后 输 出 故 为 9; 第 3 行 减 1 后 输 出 故 为 8; 第 4 行 输 出 i 为 8 之 后 再 加 1( 为 9); 第 5 行 输 出 i 为 9 之 后 再 减 1( 为 8) ; 第 6 行 输 出 -8 之 后 再 加 1( 为 9), 第 7 行 输 出 -9 之 后 再 减 1( 为 8) 例 3.17 main() int i=5,j=5,p,q; p=(i++)+(i++)+(i++); q=(++j)+(++j)+(++j); printf("%d,%d,%d,%d",p,q,i,j); 这 个 程 序 中, 对 P=(i++)+(i++)+(i++) 应 理 解 为 三 个 i 相 加, 故 P 值 为 15 然 后 i 再 自 增 1 三 次 相 当 于 加 3 故 i 的 最 后 值 为 8 而 对 于 q 的 值 则 不 然,q=(++j)+(++j)+(++j) 应 理 解 为 q 先 自 增 1, 再 参 与 运 算, 由 于 q 自 增 1 三 次 后 值 为 8, 三 个 8 相 加 的 和 为 24,j 的 最 后 值 仍 为 8 3.9 赋 值 运 算 符 和 赋 值 表 达 式 1. 赋 值 运 算 符 简 单 赋 值 运 算 符 和 表 达 式 : 简 单 赋 值 运 算 符 记 为 = 由 = 连 接 的 式 子 称 为 赋 值 表 达 式 其 一 般 形 式 为 : 第 51 页