第 3 章 数 组 和 字 符 串 上 一 章 讲 述 了 C++ 的 基 本 数 据 类 型, 但 仅 仅 靠 这 些 数 据 类 型 无 法 满 足 实 际 编 程 的 需 求 比 如 表 示 多 项 同 类 型 数 据, 就 必 须 有 相 同 个 数 的 变 量 来 存 储 这 些 数 据, 如 果 这 样 的 数 据 很 多, 那 么 单 单 变 量 的 个 数 就 会 让 人 抓 狂 这 时 就 需 要 有 一 种 变 量 来 表 示 这 些 同 类 型 数 据, 这 就 是 数 组 与 基 本 数 据 类 型 相 比, 数 组 是 一 种 复 合 数 据 类 型, 它 由 一 系 列 相 同 类 型 的 数 据 项 组 成 本 章 主 要 涉 及 的 知 识 点 有 : 一 维 数 组, 如 何 使 用 一 维 数 组 及 相 关 示 例 多 维 数 组, 了 解 多 维 数 组 原 理, 并 学 会 使 用 多 维 数 组 字 符 串, 理 解 字 符 串 和 数 组 的 关 系, 并 学 会 灵 活 使 用 字 符 串 3.1 一 维 数 组 话 说 计 划 经 济 体 制 下, 任 何 产 品 生 产 价 格 数 量 都 是 规 定 好 的 比 如 生 产 一 件 衣 服, 决 策 者 认 为 可 能 有 1000 个 人 会 需 要 这 种 衣 服, 那 么 生 产 1000 件 衣 服 就 好 了, 如 果 第 1001 个 人 想 买 这 种 衣 服 呢? 对 不 起, 这 不 在 计 划 之 内 引 用 计 划 经 济 这 个 例 子 的 目 的 就 是 为 说 明 数 组 也 具 有 类 似 的 性 质 数 组 必 须 事 先 估 计 好 同 类 型 数 据 的 规 模, 然 后 再 进 行 相 应 的 生 产 下 面 就 来 看 看 一 维 数 组 是 如 何 来 表 示 这 些 数 据 的 吧 3.1.1 一 维 数 组 定 义 数 组 的 本 质 是 一 组 连 续 的 内 存 位 置, 这 些 位 置 必 须 用 来 保 存 同 类 型 的 元 素 这 种 同 类 型 的 元 素 可 以 是 整 型 数 据 (int) 浮 点 类 型 数 据 (float double) 字 符 类 型 数 据 (char) 等 如 何 使 用 数 组 呢? 使 用 之 前 必 须 对 数 组 进 行 声 明, 其 语 法 格 式 如 下 : < 数 据 类 型 > 数 组 名 [< 数 组 元 素 个 数 >]; 与 已 经 学 过 的 基 本 数 据 类 型 声 明 相 比, 数 组 声 明 只 不 过 多 了 一 对 方 括 号, 在 方 括 号 中 要 指 明 该 数 组 的 元 素 个 数 但 这 是 必 需 的, 否 则 编 译 器 这 个 工 厂 就 不 知 道 到 底 要 生 产 多 少 个 元 素 了 根 据 数 组 的 语 法 格 式, 可 以 这 么 声 明 数 组 : int intarray[10]; // 声 明 元 素 个 数 为 10 的 int 型 数 组 double darray[20]; // 声 明 元 素 个 数 为 20 的 double 型 数 组 char carray[5]; // 声 明 元 素 个 数 为 5 的 char 型 数 组 注 意 : 按 照 维 数 划 分, 可 以 将 数 组 划 分 为 : 一 维 数 组 二 维 数 组 三 维 数 组 甚 至 是 高 维
第 1 篇 C++ 编 程 基 础 篇 数 组, 一 维 数 组 在 默 认 情 况 下 可 以 简 称 为 数 组, 但 其 他 维 的 数 组 则 需 全 称 按 照 上 述 声 明 方 式, 如 果 想 保 存 一 个 班 级 某 次 C++ 考 试 成 绩, 假 设 该 班 级 有 50 个 同 学, 那 么 就 不 用 声 明 50 个 变 量 了, 取 而 代 之 的 是 仅 仅 通 过 一 个 元 素 个 数 是 50 的 数 组 就 行 了 这 样 看 起 来 就 省 去 不 少 麻 烦 如 下 所 示 : int socre[50]; // 声 明 一 个 大 小 为 50 的 int 类 型 数 组 那 么 这 些 数 据 在 内 存 中 是 怎 么 进 行 存 储 的 呢? 具 体 可 参 见 图 3.1 图 3.1 数 组 元 素 内 存 分 布 从 图 3.1 可 以 看 出, 数 组 元 素 在 内 存 中 是 连 续 分 布 的 图 中 的 编 号 是 从 0~49, 而 不 是 平 常 认 为 的 1~50 C++ 中 规 定, 数 组 的 第 一 个 元 素 都 是 零 元 素 应 该 特 别 注 意 第 一 个 元 素 与 元 素 一 的 区 别, 两 者 是 不 同 的 第 一 个 元 素 指 的 就 是 零 元 素 ( 编 号 0), 而 元 素 一 指 的 是 数 组 的 第 二 元 素 ( 编 号 1) 3.1.2 一 维 数 组 的 初 始 化 数 组 在 声 明 的 同 时 还 可 以 进 行 初 始 化, 声 明 并 初 始 化 的 语 法 格 式 如 下 : < 数 据 类 型 > 数 组 名 [ 数 组 元 素 个 数 ]={ 初 始 值 1, 初 始 值 2, 初 始 值 3,.}; 如 以 上 语 法 格 式 所 示, 像 其 他 类 型 变 量 初 始 化 一 样, 数 组 变 量 初 始 化 也 是 通 过 赋 值 语 句 来 实 现 的 在 进 行 初 始 化 的 时 候 应 该 注 意 以 下 这 些 问 题 : 初 始 化 值 放 在 一 对 大 括 号 内, 每 个 初 始 值 之 间 是 通 过 逗 号 进 行 分 隔 的 利 用 这 种 方 式 来 实 现 元 素 编 号 和 元 素 值 一 一 对 应 该 大 括 号 内 初 始 化 值 的 个 数 不 能 大 于 声 明 的 元 素 个 数, 也 不 能 通 过 添 加 逗 号 的 方 式 跳 过 初 始 值 个 数 允 许 小 于 声 明 元 素 个 数, 那 么 没 有 对 应 初 始 值 的 元 素, 其 初 始 值 默 认 为 0 比 如 以 下 这 些 初 始 化 方 式 : int a1[4] = {1,2,3,4}; // 正 确 int a2[4] = {1,2,,4}; // 错 误, 不 能 用 逗 号 跳 过 赋 初 值 int a3[4] = {0,1,2,3,4}; // 错 误, 元 素 个 数 小 于 初 始 值 个 数 int a4[4] = {1,2}; // 正 确, 后 面 两 个 元 素 会 被 置 为 0 3.1.3 一 维 数 组 元 素 的 引 用 声 明 并 初 始 化 好 数 组 之 后, 就 可 以 引 用 该 数 组 元 素 了, 一 维 数 组 元 素 的 引 用 的 本 质 就 是 访 问 数 组 元 素, 比 如 上 文 记 录 一 个 班 级 C++ 成 绩 的 数 组, 想 要 访 问 该 数 组 第 13 个 元 素, 具 体 可 以 参 见 图 3.2 如 图 3.2 所 示, 访 问 数 组 由 3 个 部 分 组 成 : 数 组 名 下 标 及 数 组 下 标 运 算 符 其 中 数 组 下 标 运 算 符 具 有 最 高 优 先 级 方 括 号 内 的 图 3.2 数 组 访 问 方 式 68
第 3 章 数 组 和 字 符 串 编 号 其 实 应 该 称 为 下 标, 它 表 示 距 离 数 组 起 始 处 元 素 的 个 数 下 标 必 须 是 一 个 整 数 或 者 是 返 回 值 是 整 数 的 表 达 式 如 : score[5]; score[5*3]; // 下 标 是 表 达 式 例 子 3.1 具 体 介 绍 了 如 何 使 用 数 组, 该 例 子 实 现 了 数 组 的 声 明 并 进 行 了 初 始 化, 最 后 计 算 数 组 元 素 的 平 均 值 ----------------------------------------------Example3.1.cpp------------------------------------------------------------- 01 #include<iostream> 02 using namespace std; 03 void main(void) 04 { 05 int iarray1[8] = {32,45,12,54,65,76,59,70}; // 声 明 并 初 始 化 数 组 06 int iarray2[] = {1,6,10,5,8}; 07 int sum = 0; 08 for(int i=0;i<8;i++) 09 { 10 cout<<iarray1[i]<<" "; // 打 印 输 出 数 组 元 素 11 sum +=iarray1[i]; // 数 组 元 素 累 加 12 } 13 cout<<endl; 14 cout<<sum*1.0/8<<endl; 15 sum = 0; 16 for(i=0;i<5;i++) // 第 二 个 数 组 只 有 5 个 元 素 17 { 18 cout<<iarray2[i]<<" "; 19 sum +=iarray2[i]; 20 } 21 cout<<endl; 22 cout<<sum*1.0/5<<endl; 23 } 编 译 运 行 上 述 程 序 得 到 如 下 结 果 : 32 45 12 54 65 76 59 70 51.625 1 6 10 5 8 6 分 析 程 序, 上 述 程 序 首 先 声 明 并 初 始 化 了 两 个 数 组 第 一 个 数 组 声 明 方 式 在 上 一 小 节 已 经 介 绍 了, 但 是 第 二 种 声 明 方 式 也 是 可 以 的, 它 并 不 指 定 数 组 元 素 的 个 数, 数 组 元 素 个 数 由 等 式 右 边 的 初 始 值 个 数 决 定 因 此 第 二 种 声 明 方 式 必 须 有 初 始 值, 否 则 就 是 非 法 的 然 后, 程 序 通 过 循 环 逐 个 访 问 数 组 元 素 由 于 数 组 下 标 是 从 0 开 始 的, 所 以 循 环 的 控 制 变 量 需 要 从 0 开 始 判 断 条 件 可 以 有 两 种 写 法 :i<8 或 者 i<=7 最 后, 程 序 输 出 了 数 组 元 素 的 平 均 值, 变 量 sum 需 要 乘 以 1.0 的 原 因 是 为 了 转 换 为 浮 点 数 运 算, 提 高 精 度 3.1.4 一 维 数 组 示 例 到 此 为 止, 读 者 应 该 对 数 组 的 声 明 初 始 化 有 了 一 定 的 了 解 数 组 其 实 也 是 一 个 变 量, 只 不 过 它 存 储 的 值 个 数 比 别 的 变 量 多 一 些 罢 了 利 用 这 种 复 合 结 构, 可 以 实 现 更 多 丰 富 的 应 用 本 小 节 利 用 上 述 介 绍 的 知 识 来 实 现 一 个 稍 微 复 杂 的 程 序, 该 程 序 功 能 描 述 如 下 : 69
第 1 篇 C++ 编 程 基 础 篇 (1) 等 待 用 户 输 入 一 组 大 于 等 于 0 的 整 数 值, 并 且 这 组 整 数 个 数 不 大 于 20 个 (2) 用 户 首 选 输 入 一 个 整 数 n, 该 整 数 代 表 后 续 待 输 入 n 个 整 数, 如 果 输 入 的 是 0, 则 退 出 整 个 程 序, 否 则 依 次 输 入 n 个 整 数 (3) 对 输 入 的 n 个 整 数 从 小 到 大 依 次 进 行 排 序, 排 序 过 程 为 首 先 判 断 第 1 个 元 素 和 第 2 个 元 素 大 小, 如 果 第 1 个 元 素 大 于 第 2 个 元 素 则 相 互 交 换 位 置 接 着 判 断 第 2 个 元 素 和 第 3 个 元 素 大 小, 如 果 前 者 比 后 者 大 则 交 换 位 置 依 此 类 推 就 可 以 找 到 最 大 值, 且 最 大 值 在 数 组 末 尾, 然 后 再 从 头 开 始 进 行 下 一 轮 判 断, 直 到 判 断 出 所 有 元 素 (4) 打 印 输 出 排 序 的 结 果, 然 后 重 复 第 一 步 程 序 难 点 分 析 : 程 序 需 要 解 决 如 何 保 存 输 入 数 据 编 写 排 序 算 法 输 出 排 序 结 果 保 存 输 入 数 据 最 简 单 有 效 的 办 法 就 是 利 用 数 组 输 出 排 序 结 果 只 需 要 利 用 循 环 打 印 输 出 数 组 元 素 就 行 了 编 写 排 序 算 法 是 该 程 序 的 核 心, 如 果 对 上 述 功 能 描 述 还 是 不 太 清 楚, 那 么 可 以 参 考 图 3.3 图 3.3 排 序 过 程 从 图 3.3 中 可 以 看 出, 初 始 数 组 是 (4,7,2,6), 首 先 对 4 和 7 的 值 进 行 判 断,4 小 于 7 不 用 交 换 继 续 往 下 判 断, 现 在 判 断 7 和 2,7 是 大 于 2 的, 那 么 需 要 进 行 交 换, 交 换 结 果 如 第 3 步 所 示 接 着 判 断 7 和 6, 继 续 交 换 得 到 第 4 步 的 结 果 数 组 已 经 遍 历 完 了 一 遍, 同 时 也 确 定 了 最 大 值, 现 在 从 头 开 始 遍 历 到 倒 数 第 二 个 元 素 4 大 于 2, 进 行 交 换, 如 第 5 步 所 示 由 于 接 下 来 的 数 据 项 都 已 经 有 序 了, 所 以 判 断 步 骤 在 图 中 省 略, 但 过 程 还 是 一 样 的 例 子 3.2 具 体 实 现 了 上 述 程 序 的 功 能 程 序 代 码 如 下 所 示 : ----------------------------------------------Example3.2.cpp------------------------------------------------------------- 01 #include<iostream> 02 using namespace std; 03 void main(void) 04 { 05 int num = 0; 06 int ia[20] = {0}; 07 // 输 入 数 据 个 数 并 判 断 是 否 为 0 08 while(cout<<" 请 输 入 数 据 个 数 :"&&cin>>num&&num>0) 09 { 10 for(int i=0;i<num;i++) // 保 存 输 入 数 据 11 { 12 cin>>ia[i]; 13 } 14 for(i=0;i<num;i++) 15 { 16 for(int j=0;j<num-i-1;j++) // 防 止 数 组 越 界 17 { 18 if(ia[j]>ia[j+1]) 70
第 3 章 数 组 和 字 符 串 19 { 20 int tmp = ia[j]; // 数 组 元 素 交 换 21 ia[j] = ia[j+1]; 22 ia[j+1] = tmp; 23 } 24 } 25 } 26 cout<<" 排 序 结 果 如 下 :"; 27 for(i=0;i<num;i++) // 输 出 排 序 结 果 28 { 29 cout<<ia[i]<<" "; 30 } 31 cout<<endl; 32 } 33 cout<<" 退 出 程 序..."<<endl; 34 } 编 译 运 行 上 述 程 序 得 到 如 下 输 出 结 果 : 请 输 入 数 据 个 数 :4 4 7 2 6 排 序 结 果 如 下 :2 4 6 7 请 输 入 数 据 个 数 :6 32 90 67 12 50 88 排 序 结 果 如 下 :12 32 50 67 88 90 请 输 入 数 据 个 数 :0 退 出 程 序... 分 析 程 序, 程 序 按 照 功 能 进 行 划 分 可 分 为 3 个 部 分, 第 1 个 部 分 是 保 存 输 入 数 据, 对 应 的 代 码 是 10~12 行 第 2 部 分 是 实 现 排 序 功 能, 对 应 的 代 码 是 14~25 行 第 3 部 分 是 打 印 输 出 排 序 结 果, 对 应 的 代 码 是 27~30 行 应 该 特 别 注 意 第 2 部 分 的 实 现, 该 段 代 码 利 用 嵌 套 循 环 来 实 现 第 二 个 for 循 环 的 判 断 条 件 是 :j<num-i-1, 这 样 写 的 目 的 是 不 用 再 去 判 断 已 经 筛 选 出 来 的 前 i 个 大 值, 再 减 去 1 的 目 的 是 为 了 防 止 数 组 访 问 越 界, 后 面 的 判 断 条 件 是 :ia[j]>ia[j+1], 如 果 不 去 1 就 会 发 生 越 界 问 题 3.2 多 维 数 组 含 有 一 个 下 标 的 数 组 叫 做 一 维 数 组, 那 么 如 果 有 两 个 下 标 呢? 那 么 这 个 数 组 就 是 二 维 数 组, 甚 至 还 有 三 维 四 维 数 组 等, 这 些 数 组 都 是 多 维 数 组 但 是, 往 往 数 组 维 数 越 多, 其 表 示 意 义 越 复 杂, 也 就 越 容 易 出 错, 而 且 在 编 程 中 一 般 接 触 的 多 维 数 组 都 是 以 二 维 为 主 本 节 将 以 二 维 数 组 为 主, 详 细 介 绍 多 维 数 组 的 用 法 3.2.1 多 维 数 组 定 义 对 于 C++ 语 言 而 言, 数 组 的 维 数 是 视 具 体 编 译 程 序 决 定 的 多 维 数 组 的 定 义 格 式 如 下 : < 数 据 类 型 > 数 组 名 [ 元 素 个 数 1][ 元 素 个 数 2] [ 元 素 个 数 n] 同 样, 上 述 定 义 格 式 中 的 数 据 类 型 可 以 是 基 本 数 据 类 型 如 :int float double 等 数 71
第 1 篇 C++ 编 程 基 础 篇 组 名 需 要 满 足 标 志 符 命 名 规 则,n 对 方 括 号 来 表 示 n 维 数 组 按 照 这 种 定 义 格 式, 比 如 二 维 数 组 和 三 维 数 组 可 以 按 照 如 下 方 式 声 明 : int a1[6][5]; int a2[5][6][7]; // 声 明 一 个 二 维 数 组 // 声 明 一 个 三 维 数 组 对 于 一 维 数 组 而 言, 声 明 时 下 标 所 表 示 的 值 就 是 数 组 的 大 小, 那 么 二 维 数 组 大 小 是 怎 么 计 算 的 呢? 比 如 上 述 例 子 中 a1[6][5], 表 示 的 是 6+5 个 元 素 吗? 其 实, 计 算 多 维 数 组 元 素 个 数 需 要 将 各 个 方 括 号 内 元 素 个 数 相 乘, 那 么 a1 这 个 二 维 数 组 元 素 的 个 数 就 是 6*5=30 个 既 然 如 此, 二 维 数 组 在 内 存 中 是 如 何 分 布 的 呢? 是 不 是 也 和 一 维 数 组 一 样 是 一 块 连 续 区 域? 是 的, 无 论 是 几 维 数 组, 它 们 的 元 素 都 是 连 续 分 布 于 内 存 之 中 比 如 A[5][7] 这 个 二 维 数 组 内 存 分 布, 可 以 参 见 图 3.4 72 图 3.4 数 组 a[5][7] 的 内 存 分 布 注 意 : 为 了 形 象 化 说 明 二 维 数 组 在 逻 辑 上 元 素 分 布 情 况, 图 3.4 采 用 二 维 的 形 式 来 表 示 数 组 内 存 分 布, 但 是 实 际 上 二 维 数 组 ( 高 维 数 组 ) 在 内 存 分 布 上 和 一 维 数 组 一 样, 每 个 元 素 都 是 按 照 顺 序 排 列 的 图 3.4 确 切 地 说 应 该 是 一 个 二 维 数 组 逻 辑 分 布 图, 其 中 第 一 个 下 标 表 示 的 是 数 组 的 行, 第 二 个 下 标 表 示 的 是 数 组 的 列 那 么 想 要 访 问 任 意 一 个 数 组 元 素 时, 只 需 要 设 置 想 要 的 行 列 数 值 就 行 了 比 如 A[2][5] 表 示 访 问 的 是 第 3 行 第 6 列 元 素 注 意 数 组 下 标 是 从 零 开 始 的 3.2.2 初 始 化 多 维 数 组 如 何 初 始 化 多 维 数 组? 同 样 可 以 借 鉴 一 维 数 组 的 初 始 化 方 式 一 维 数 组 的 初 始 化 是 由 一 对 花 括 号 括 起 的 若 干 数 据 项 来 表 示 的, 这 些 数 据 项 之 间 通 过 逗 号 进 行 分 隔 同 样 多 维 数 组 就 需 要 多 对 花 括 号 包 含 数 据 项 来 表 示, 比 如 二 维 数 组 其 初 始 化 格 式 如 下 : < 数 据 类 型 > 数 组 名 [ 元 素 个 数 1][ 元 素 个 数 2] = {{ 初 始 值 表 },{ 初 始 值 表 }, }; 这 里, 初 始 值 表 指 的 是 由 若 干 个 数 据 元 素 组 成 的 表, 并 且 该 表 中 数 据 个 数 应 该 小 于 或 者 等 于 [ 元 素 个 数 2] 的 值 而 初 始 值 表 的 个 数 应 该 小 于 或 者 等 于 [ 元 素 个 数 1] 的 值 例 如 以 下 例 子 : int a[3][4] = {{1,2,3,4},{5,6,7,8},{9,10,11,12}}; // 声 明 并 初 始 化 一 个 int 类 型 二 维 数 组 double d[2][3] = {1.0,2.1,3.1,4.0,5.5,6,0}; // 声 明 并 初 始 化 一 个 double 类 型 二 维 数 组 int a2[4][5] = {{1,2,3}}; // 声 明 初 始 化 二 维 数 组 在 上 面 进 行 初 始 化 的 3 个 例 子 中, 前 2 个 例 子 中 数 组 每 个 元 素 都 对 应 了 初 始 值 在 第
第 3 章 数 组 和 字 符 串 二 个 例 子 中 只 有 一 对 花 括 号, 这 也 是 可 以 的, 编 译 器 会 为 数 组 元 素 存 放 顺 序 进 行 一 一 赋 值 所 以 d[0][0] 的 值 是 1.0,d[0][1] 的 值 是 2.1,d[0][2] 的 值 是 3.1, 依 此 类 推 第 3 个 例 子 中, 二 维 数 组 元 素 和 初 始 值 并 没 有 一 一 对 应, 那 么 编 译 器 会 给 没 有 对 应 的 数 组 元 素 设 置 默 认 值 0 初 始 化 后,a2[0][0] 的 值 是 1,a[0][1] 的 值 是 2,a[0][2] 的 值 是 3 其 余 元 素 的 值 都 是 0 同 理, 三 维 数 组 的 初 始 化 格 式 也 是 类 似 的, 只 不 过 需 要 的 花 括 号 就 要 达 到 三 层 了, 如 : int a[2][3][2] = {{{1,2},{3,4},{5,6}},{{7,8},{9,10},{11,12}}}; 3.2.3 多 维 数 组 应 用 举 例 经 过 前 几 个 小 节 的 学 习, 读 者 应 该 已 经 基 本 了 解 了 多 维 数 组 的 逻 辑 结 构 及 如 何 声 明 一 个 多 维 数 组 例 子 3.3 详 细 介 绍 了 使 用 二 维 数 组, 该 例 子 实 现 了 访 问 二 维 数 组 元 素, 并 将 二 维 数 组 的 元 素 值 打 印 输 出, 最 后 求 该 二 维 数 组 的 平 均 值 ----------------------------------------------Example3.3.cpp------------------------------------------------------------- 01 #include<iostream> 02 #include<iomanip> 03 using namespace std; 04 void main(void) 05 { 06 int a[4][6] = { {14, 38, 10, 65, 34, 29}, // 声 明 并 初 始 化 二 维 数 组 07 {12, 54, 9, 23, 17, 99}, 08 {43, -9, -70, 40, 33, -20}, 09 {-11, 8, 5, 10, 2, 15}}; 10 11 int sum = 0; 12 for(int i=0;i<4;i++) 13 { 14 for(int j=0;j<6;j++) 15 { 16 cout<<setiosflags(ios::left); // 设 置 左 对 齐 17 cout<<a[ I ][ j ]<<"\t"; 18 sum +=a[i][j]; // 元 素 值 累 加 19 } 20 cout<<endl; 21 } 22 cout<<sum*1.0/(4*6)<<endl; // 求 平 均 值 23 } 编 译 运 行 上 述 程 序 得 到 如 下 结 果 : 14 38 10 65 34 29 12 54 9 23 17 99 43-9 -70 40 33-20 -11 8 5 10 2 15 18.75 分 析 上 述 程 序, 程 序 首 先 声 明 了 一 个 二 维 数 组 并 进 行 初 始 化 接 着, 利 用 for 的 双 重 循 环 逐 个 访 问 数 组 元 素 ( 遍 历 ), 并 进 行 打 印 输 出 在 访 问 数 组 元 素 的 时 候, 可 以 先 一 行 行 73
第 1 篇 C++ 编 程 基 础 篇 遍 历, 也 可 以 一 列 列 地 遍 历 比 如 上 述 程 序 实 现 的 就 是 一 行 行 遍 历, 如 果 想 要 实 现 一 列 列 遍 历, 可 以 按 照 如 下 方 式 书 写 : for(int i=0;i<6;i++) { for(int j=0;j<4;j++) { cout<<a[ j ][ I ]<<"\t"; sum +=a[j][i]; } cout<<endl; } // 注 意 下 标 的 变 化 // 元 素 值 累 加 3.3 字 符 数 组 和 字 符 串 字 符 数 组 在 C++ 中 是 一 个 重 要 的 概 念, 因 为 实 际 应 用 中 常 常 涉 及 对 字 符 的 处 理 比 如 上 课 时 经 常 要 点 名, 那 么 在 点 名 之 前 必 须 知 道 每 个 学 生 的 姓 名, 而 每 个 学 生 的 姓 名 并 不 是 一 个 整 型 浮 点 型 数 据, 其 实 它 是 一 个 字 符 串, 那 么 保 存 字 符 串 就 要 用 到 字 符 数 组 了 通 过 字 符 数 组 来 管 理 每 个 学 生 的 名 字, 在 点 名 的 时 候 就 可 以 方 便 而 清 楚 地 知 道 哪 些 学 生 来 上 课, 哪 些 学 生 逃 课 了 看 来 字 符 数 组 真 的 很 重 要 啊 3.3.1 字 符 数 组 的 定 义 和 赋 值 字 符 数 组 的 定 义 格 式 和 前 面 介 绍 的 一 般 数 组 的 定 义 格 式 是 一 样 的, 只 不 过 字 符 数 组 的 数 据 类 型 是 字 符 类 型 (char) 而 已 字 符 数 组 中 每 一 个 元 素 存 放 一 个 字 符, 它 也 可 以 分 为 一 维 二 维 及 多 维 数 组 例 如 : char c[10] // 声 明 一 个 大 小 为 10 的 字 符 数 组 char c2[10][10] // 声 明 一 个 二 维 字 符 数 组, 其 元 素 个 数 是 10*10 char c3[2][3][4] // 声 明 一 个 三 维 字 符 数 组, 其 元 素 个 数 是 2*3*4 字 符 数 组 声 明 方 式 和 前 面 介 绍 的 数 组 声 明 方 式 类 似, 其 实 字 符 数 组 的 初 始 化 方 式 也 是 类 似 的 比 如 以 下 一 维 字 符 数 组 初 始 化 方 式 : char c1[15] = {'W','e','l','c','o','m','e','t','o','C','+','+'}; // 声 明 一 个 大 小 为 15 的 字 符 串 并 初 始 化 char c2[]={'h','e','l','l','0'}; // 声 明 一 个 字 符 数 组 并 初 始 化 char c3[] = Hello ; // 效 果 和 c2 一 样 上 面 有 三 种 初 始 化 方 式, 它 们 都 是 可 以 的 在 进 行 字 符 数 组 初 始 化 时 应 该 注 意 以 下 几 点 问 题 : 花 括 号 内 元 素 个 数 不 能 大 于 数 组 长 度, 否 则 编 译 器 将 会 提 示 错 误 信 息 如 果 花 括 号 内 的 初 始 值 个 数 小 于 预 定 的 数 组 长 度, 那 么 就 将 这 些 元 素 赋 给 数 组 前 面 的 元 素, 其 余 元 素 自 动 赋 为 空 字 符 ('\0') 如 上 述 声 明 的 c1 字 符 数 组, 其 内 存 分 布 参 见 图 3.5 在 初 始 化 字 符 数 组 的 时 候, 也 可 以 省 略 数 组 长 度, 编 译 器 会 自 动 根 据 花 括 号 内 初 始 值 个 数 来 确 定 数 组 的 长 度, 如 c2 这 个 字 符 数 组, 其 内 存 可 以 参 见 图 3.5 74
第 3 章 数 组 和 字 符 串 图 3.5 字 符 数 组 内 存 分 布 字 符 数 组 除 了 在 初 始 化 时 可 以 确 定 其 数 组 元 素 外, 还 可 以 通 过 赋 值 运 算 来 改 变 数 组 元 素 的 值 但 是 和 其 他 变 量 赋 值 操 作 不 同, 字 符 数 组 只 能 对 字 符 元 素 赋 值, 而 不 能 用 赋 值 语 句 对 整 个 数 组 赋 值 如 下 面 的 代 码 : char c[6]; c={'h','e','l','l','o'}; // 错 误, 不 能 对 整 个 数 组 一 次 赋 值 c[0] = 'H';c[1]='e';c[2]='l';c[3]='l';c[4]='o';c[5]='\0'; // 正 确 如 果 有 两 个 字 符 数 组, 它 们 的 长 度 是 相 同 的, 是 不 是 就 可 以 相 互 赋 值 了 呢? 答 案 是 否 定 的, 字 符 数 组 之 间 赋 值 也 需 要 通 过 引 用 元 素 一 个 一 个 地 赋 值 如 下 面 的 代 码 : char c1[6]; char c2[6]="hello"; c1=c2; // 错 误, 不 能 整 个 数 组 一 次 性 赋 值 c1[0]=c2[0];c1[1]=c2[1]; // 正 确 例 子 3.4 声 明 了 2 个 字 符 数 组 并 初 始 化, 最 后 交 换 2 个 数 组 元 素 并 打 印 输 出 ----------------------------------------------Example3.4.cpp------------------------------------------------------------- 01 #include<iostream> 02 using namespace std; 03 void main(void) 04 { 05 char c1[10] = {'H','e','l','l','o'}; // 声 明 一 个 字 符 数 组 并 初 始 化 06 char c2[10] = "Welcome"; // 同 上 07 cout<<" 交 换 前 :"<<endl; 08 cout<<"c1 的 内 容 是 :"<<c1<<endl; // 输 出 字 符 数 组 内 容 09 cout<<"c2 的 内 容 是 :"<<c2<<endl; 10 for(int i=0;i<10;i++) 11 { 12 char tmp; // 交 换 13 tmp = c1[i]; 14 c1[i] = c2[i]; 15 c2[i] = tmp; 16 } 17 cout<<" 交 换 后 :"<<endl; 18 cout<<"c1 的 内 容 是 :"<<c1<<endl; 19 cout<<"c2 的 内 容 是 :"<<c2<<endl; 20 } 编 译 运 行 上 述 程 序 得 到 如 下 结 果 : 交 换 前 : c1 的 内 容 是 :Hello c2 的 内 容 是 :Welcome 交 换 后 : 75
第 1 篇 C++ 编 程 基 础 篇 c1 的 内 容 是 :Welcome c2 的 内 容 是 :Hello 分 析 上 述 程 序, 首 先 程 序 安 装 按 照 规 则 声 明 了 2 个 字 符 数 组 并 初 始 化 这 2 个 数 组 的 长 度 是 一 样 的, 然 后 通 过 一 个 for 循 环 进 行 元 素 值 的 交 换 3.3.2 字 符 串 的 输 入 / 输 出 字 符 串 在 C++ 中 是 一 个 十 分 重 要 的 概 念, 常 常 用 到 而 且 字 符 串 的 操 作 有 很 多 ( 如 字 符 串 比 较 字 符 串 查 找 等 ), 在 这 里 只 介 绍 字 符 串 的 输 入 / 输 出 操 作, 字 符 串 的 其 他 操 作 会 在 后 续 章 节 进 行 介 绍 字 符 串 的 输 入 / 输 出 方 式 一 般 有 两 种 : (1) 逐 个 字 符 的 输 入 / 输 出, 一 般 使 用 函 数 getchar 和 putchar 如 下 面 的 程 序 段 : char c[10]; for(int i=0;i<10;i++) { c[i] = getchar(); } for(i=0;i<10;i++) { putchar(c[i]); } // 字 符 数 组 声 明 // 一 个 个 读 入 字 符 // 一 个 个 输 出 字 符 (2) 将 整 个 字 符 串 一 次 性 输 入 或 者 输 出, 这 种 方 式 一 般 只 有 C++ 标 志 输 入 / 输 出 函 数 cin 或 cout 例 如 下 面 程 序 段 : char c[10]; cin>>c; cout<<c; // 一 次 性 输 入 // 一 次 性 输 出 比 较 两 种 输 入 方 式, 第 二 种 看 起 来 简 洁 明 了, 不 过 面 向 不 同 的 应 用 需 要 选 择 不 同 的 输 入 方 式 如 果 想 要 在 输 入 时 就 判 断 输 入 的 是 不 是 小 写 字 母 ('a'~'z'), 显 然 采 用 单 个 输 入 的 方 式 是 最 好 的 那 么 如 果 想 要 通 过 输 入 字 符 串 来 查 询 名 字, 那 么 显 然 一 次 输 入 并 进 行 查 询 更 好 例 子 3.5 通 过 基 本 字 符 串 输 入 / 输 出 操 作 来 巩 固 上 述 知 识 点 76 ----------------------------------------------Example3.5.cpp------------------------------------------------------------- 01 #include<iostream> 02 using namespace std; 03 void main(void) 04 { 05 char c[10]; 06 for(int i=0;i<10;i++) 07 { 08 c[i] = getchar(); // 单 个 字 符 输 入 09 } 10 cout<<"c 的 内 容 是 :"; 11 for(i=0;i<10;i++) 12 { 13 putchar(c[i]); // 单 个 字 符 输 出 14 } 15 cout<<endl; 16 cin>>c; // 一 次 输 入 17 cout<<"c 的 新 内 容 是 :"<<c<<endl;
第 3 章 数 组 和 字 符 串 18 } 编 译 运 行 上 述 程 序 得 到 如 下 结 果 : Hello C++ c 的 内 容 是 :Hello C++ welcom c 的 新 内 容 是 :welcom 分 析 上 述 程 序, 通 过 一 个 循 环 来 一 个 个 读 入 字 符, 程 序 中 输 入 测 试 字 符 串 Hello C++, 这 里 只 有 9 个 字 符, 但 程 序 需 要 读 入 10 个 字 符 才 能 跳 出 循 环, 所 以 再 输 入 回 车 符 (' ') 后, 刚 好 读 到 了 10 个 字 符 那 么 此 时 字 符 数 组 c 的 内 存 分 布 如 图 3.6 所 示 putchar 函 数 的 功 能 就 是 将 字 符 数 组 c 里 面 的 字 符 一 个 个 地 打 印 输 出, 当 然 也 包 括 回 车 符 最 后 通 过 cin 函 数 一 次 图 3.6 字 符 数 组 c[10] 的 内 存 分 布 性 输 入 welcome 这 个 字 符 串, 并 打 印 输 出 3.3.3 字 符 串 应 用 示 例 现 在 已 经 介 绍 完 了 字 符 数 组, 通 常 用 字 符 数 组 来 存 储 字 符 串 内 容 下 面 通 过 字 符 串 来 实 现 一 个 较 为 全 面 的 示 例, 通 过 这 个 示 例 使 读 者 加 深 对 字 符 串 应 用 的 印 象 这 个 例 子 实 现 的 核 心 功 能 就 是 通 过 输 入 的 字 符 串 来 查 找 程 序 中 是 否 有 相 应 匹 配 的 字 符 串 程 序 具 体 功 能 描 述 如 下 : (1) 等 待 用 户 输 入 字 符 串, 如 果 整 个 字 符 串 就 是 一 个 0, 那 么 退 出 程 序, 否 则 进 入 步 骤 (2) (2) 利 用 循 环 将 内 存 中 保 存 的 字 符 串 逐 个 和 输 入 字 符 串 进 行 匹 配, 如 果 匹 配 成 功 就 输 出 存 在, 否 则 输 出 不 存 在 (3) 回 到 步 骤 (1) 程 序 难 点 分 析, 在 步 骤 (1) 中 只 需 要 通 过 cin 函 数 就 可 以 实 现 输 入 字 符 串 字 符 串 的 匹 配 是 一 个 难 点, 判 断 两 个 字 符 串 相 等 的 条 件 必 须 是 字 符 串 里 面 每 个 字 符 都 是 相 等 的 如 : abc 和 acb 不 是 相 等 的, abc 和 abc 才 相 等 所 以 根 据 上 述 理 解, 可 以 利 用 循 环 来 判 断 是 不 是 相 等 例 子 3.6 实 现 了 上 述 描 述 的 功 能, 具 体 代 码 如 下 : ----------------------------------------------Example3.6.cpp------------------------------------------------------------- 01 #include<iostream> 02 using namespace std; 03 void main(void) 04 { 05 char str[][10] = {"Hello","Welcome","C++","function","world"}; // 保 存 的 字 符 串 06 char inputstr[10]; 07 int i(0),j(0); 08 bool bsame; // 是 否 相 同 标 志 09 while(cin>>inputstr&&inputstr[0]!='0') // 输 入 字 符 串 10 { 11 bsame = false; 77
第 1 篇 C++ 编 程 基 础 篇 12 for(i=0;i<5;i++) 13 { 14 for(j=0;j<10;j++) 15 { 16 if(str[i][j]!=inputstr[j]) // 判 断 字 符 是 否 相 等, 不 相 等 退 出 循 环 17 break; 18 if(str[i][j]=='\0'&&inputstr[j]=='\0') // 判 断 两 个 字 符 串 是 否 结 束 19 { 20 bsame = true; 21 break; 22 } 23 } 24 if(j>=10 bsame) 25 break; 26 } 27 if(i<5) // 说 明 字 符 串 存 在 28 { 29 cout<<inputstr<<" 存 在 "<<endl; 30 } 31 else 32 { 33 cout<<inputstr<<" 不 存 在 "<<endl; 34 } 35 } 36 cout<<" 退 出 程 序 "<<endl; 37 } 编 译 运 行 上 述 程 序 得 到 如 下 结 果 : Welcome Welcome 存 在 hello hello 不 存 在 0 退 出 程 序 分 析 上 述 程 序, 程 序 的 核 心 是 需 要 用 到 两 个 嵌 套 的 for 循 环 来 实 现, 最 里 面 的 for 是 实 现 的 关 键, 比 如 要 判 断 输 入 字 符 串 Welcome 首 先 用 str 二 维 字 符 数 组 中 存 储 的 第 一 个 字 符 串 来 判 断 第 一 个 字 符 串 是 Hello, 那 么 进 入 第 二 个 for 循 环 以 后, 执 行 第 16 行 这 个 判 断, H 显 然 是 不 和 W 字 符 相 等 的, 所 以 执 行 break 语 句 退 出 循 环 接 着 执 行 第 二 次 循 环, 用 字 符 串 Welcome 来 判 断, 由 于 都 相 等, 所 以 最 后 判 断 来 到 第 18 行 代 码, 这 行 代 码 的 作 用 是 判 断 两 个 字 符 串 是 否 已 经 达 到 末 尾 显 然 成 立, 于 是 将 标 志 变 量 bsame 置 为 true, 然 后 跳 出 循 环 此 时, 执 行 到 了 第 24 行 代 码 这 里, 显 然 bsame 是 真 的 (true) 的, 那 么 等 式 成 立, 跳 出 第 一 个 for 循 环 最 后 由 于 i 的 值 是 小 于 5 的, 所 以 输 出 该 字 符 串 存 在 3.4 本 章 小 结 数 组 概 括 地 说 就 是 数 据 有 序 的 集 合, 这 些 数 据 必 须 是 同 一 种 类 型 的 数 组 是 一 个 大 小 固 定 的 复 合 数 据 类 型, 如 果 需 要 形 象 地 理 解 数 组, 那 么 可 以 把 数 组 比 喻 成 一 个 水 杯, 水 杯 78
第 3 章 数 组 和 字 符 串 的 大 小 是 固 定 的, 倒 入 的 水 不 能 太 多, 否 则 就 会 溢 出 本 章 主 要 介 绍 了 如 何 创 建 一 般 数 据 类 型 的 数 组 (int char double 等 ), 探 讨 了 这 些 数 组 的 特 性 同 时, 本 章 也 介 绍 了 字 符 串 这 个 特 殊 的 数 据, 一 般 通 过 字 符 数 组 来 存 储 字 符 串 第 18 章 还 会 介 绍 用 string 来 存 储 字 符 串 数 组 应 用 灵 活, 应 该 注 意 数 组 的 一 些 操 作, 特 别 是 数 组 操 作 是 不 能 越 界 的, 否 则 会 引 起 意 想 不 到 的 错 误 3.5 本 章 习 题 一 基 础 填 空 1. 数 组 元 素 之 间 的 关 系 是 它 们 必 须 具 有 类 型, 常 见 的 一 般 类 型 数 组 类 型 有 及 2. 访 问 数 组 元 素 需 要 通 过 数 组 下 标 进 行 访 问, 数 组 的 下 标 可 以 是 或 者 3. 已 知 一 个 数 组 :int ia[][4]={{2,10,7,8},{3,11,2},{1,0},{9}}; 这 个 数 组 是 一 个 维 数 组, 该 数 组 一 共 有 个 元 素, 每 个 元 素 的 类 型 都 是 数 组 元 素 ia[0][0] 的 值 是, 数 组 元 素 ia[3][1] 值 是, 数 组 元 素 ia[2][2] 的 值 是 4. 有 一 个 字 符 数 组 :char c[][10]={"hello","world","name"}; 这 是 一 个 维 的 字 符 数 组, 该 数 组 一 共 有 个 元 素, 数 组 元 素 c[0][0] 代 表 的 字 符 是, 数 组 元 素 c[1][4] 表 示 的 字 符 是, 数 组 元 素 c[2][5] 表 示 的 字 符 是 二 选 择 题 1. 下 列 一 维 数 组 初 始 化 正 确 的 是 A.int a[3]={1,2,3,4}; B.int a[]={0,1}; C.int a[3]={1,,2}; D.int a[3]={} 2. 已 知 一 个 数 组 :double d[5]={1,0.3,2,7.5,10.0}; 以 及 一 个 int 类 型 变 量 i=5, 那 么 访 问 该 数 组 d[(i++)/2+i%4] 的 结 果 是 A.1 B.7.5 C.10.0 D.0.3 3. 以 下 程 序 段 输 出 结 果 正 确 的 是 char c[10]={"hel\0lo,\0i\n"}; cout<<c; A.Hel B.Hello, C.Hello,I D.Hello,i\n 4. 下 列 对 字 符 数 组 描 述 错 误 的 是 A. 字 符 数 组 可 以 存 放 字 符 串 B. 字 符 数 组 的 字 符 串 可 以 整 体 输 入 输 出 C. 可 以 通 过 赋 值 语 句 对 字 符 数 组 整 体 赋 值 D. 不 可 用 关 系 运 算 符 对 字 符 数 组 中 的 字 符 串 进 行 比 较 5. 有 两 个 字 符 数 组 :char a[]="abc" 和 char b[]={'a','b','c'}; 则 下 列 叙 述 正 确 的 是 A.a 与 b 完 全 相 同 B.a 与 b 长 度 相 同 79
第 1 篇 C++ 编 程 基 础 篇 C.a 与 b 都 存 放 字 符 串 D.a 数 组 比 b 数 组 长 度 长 三 编 程 实 践 1. 在 程 序 中 声 明 一 个 大 小 为 20 的 字 符 数 组, 然 后 一 次 性 输 入 一 个 不 大 于 20 的 字 符 串, 最 后 一 次 性 输 出 所 输 入 的 字 符 串 2. 求 平 均 值 问 题, 要 求 程 序 求 出 输 入 一 串 整 数 的 平 均 值, 输 入 整 数 的 个 数 不 超 过 10 个 首 先 程 序 输 入 一 个 整 数 n 表 示 接 下 来 要 输 入 的 整 数 个 数, 如 果 输 入 的 n 为 0, 则 退 出 程 序, 否 则 输 入 n 个 整 数, 然 后 求 出 输 入 整 数 的 平 均 值, 最 后 输 出 求 出 的 平 均 值 输 入 格 式 举 例 如 下 : 4 2 4 5 7 平 均 值 :4 0 退 出 程 序 3. 判 断 输 入 的 整 数 是 否 是 回 文 数, 回 文 数 是 一 个 数 字, 这 种 数 字 的 特 点 就 是 正 着 读 和 逆 着 读 都 是 一 样 的 比 如 121 22 111 这 些 都 是 回 文 数 那 么 现 在 程 序 的 要 求 是, 输 入 整 数 判 断 其 是 否 是 回 文 数 输 入 的 格 式 : 2 回 文 数 123 不 是 回 文 数 80
第 4 章 指 针 与 引 用 指 针 无 疑 是 C++ 编 程 语 言 中 最 强 大 的 特 性 之 一, 它 使 程 序 更 富 有 灵 活 性 和 高 效 性 然 而, 指 针 也 是 C++ 语 言 中 最 难 掌 握 的 概 念 之 一 要 想 熟 练 地 掌 握 C++ 编 程 语 言, 必 须 理 解 掌 握 指 针 概 念, 并 且 学 会 灵 活 运 用 大 道 至 简, 本 章 力 求 通 过 一 些 通 俗 的 比 喻 和 简 明 的 示 例 来 一 步 步 揭 开 指 针 和 引 用 神 秘 的 面 纱 本 章 主 要 涉 及 的 知 识 点 有 : 声 明 指 针, 学 会 如 何 声 明 不 同 类 型 的 指 针 指 针 和 数 组, 学 会 使 用 指 针 访 问 数 组, 理 解 数 组 和 指 针 的 异 同 动 态 内 存 分 配, 学 会 如 何 动 态 申 请 内 存 空 间 及 一 些 应 该 注 意 的 问 题 引 用, 本 章 最 后 讲 解 了 引 用 的 基 本 概 念 以 及 和 指 针 的 关 系 注 意 : 引 用 的 具 体 应 用 会 在 函 数 这 一 章 进 行 详 细 阐 述 4.1 市 场 经 济 指 针 的 定 义 及 格 式 指 针 到 底 是 什 么? 市 场 经 济 体 制 不 是 吗? 相 比 于 计 划 经 济 来 说, 市 场 经 济 下, 每 个 人 的 需 求 都 是 按 需 进 行 分 配 的, 买 多 少 食 物 吃 什 么 东 西 都 是 根 据 个 人 意 愿 来 购 买, 需 求 决 定 市 场 指 针 跟 市 场 经 济 有 很 多 相 似 之 处 本 节 将 会 详 细 地 介 绍 指 针 的 基 本 概 念, 理 解 并 掌 握 这 个 概 念 是 后 续 C++ 语 言 学 习 的 基 础 了 解 指 针 概 念 后, 通 过 进 一 步 实 践 操 作 从 而 对 指 针 有 更 深 的 认 识 4.1.1 什 么 是 指 针 指 针 是 C++ 中 的 一 种 重 要 的 复 合 数 据 类 型, 与 其 他 数 据 类 型 不 同 的 是, 指 针 是 一 种 用 来 存 放 地 址 值 的 变 量 计 算 机 中, 数 据 是 存 放 在 存 储 单 元 里 面 的, 每 个 存 储 单 元 都 有 一 个 固 定 的 地 址, 地 址 也 是 一 个 数 要 想 读 出 某 个 存 储 单 元 的 数 据, 必 须 将 这 个 地 址 告 诉 访 存 指 令, 才 能 找 到 这 个 单 元 这 个 存 储 地 址 的 单 元 就 是 指 针 打 个 比 方 : 快 递 公 司 要 想 把 快 件 送 到 客 户 手 中, 必 须 知 道 客 户 的 详 细 地 址, 而 这 个 详 细 地 址 就 类 似 于 存 储 单 元 的 地 址 但 是, 仅 仅 知 道 数 据 存 储 位 置 是 不 够 的 如 图 4.1 所 示, 有 一 个 指 向 内 存 地 址 0xA010:F020 的 指 针, 指 令 根 据 该 地 址 就 可 以 读 出 0xA010:F020 的 数 据 但 是, 这 个 数 据 代 表 什 么 意 义 却 并 不 明 确 因 为 不 同 的 数 据 类 型 占 用 的 内 存 空 间 是 不 一 样 的, 比 如 : 在 32 位 计 算 机 上,int 类 型 数 据 占 4 个 字 节,short 类 型 则 占 2 个 字 节 指 针 必 须 指 定 需 要 访 问 的 是 哪 种 数 据 类 型, 如 果 是 int 类 型 则 获 取 到 的 数 据 是 0xF0340012 这 个 值, 如 果 是 short 类 型 数 据 值 则 为 0xF034
第 1 篇 C++ 编 程 基 础 篇 因 此, 指 针 中 所 包 含 的 不 仅 仅 是 存 放 地 址 值, 更 重 要 的 是 它 还 表 示 了 数 据 项 的 类 型 值 得 一 提 的 是, 为 什 么 指 针 占 用 了 4 个 字 节 的 内 存 空 间 Windows 采 用 的 是 一 种 叫 虚 拟 内 存 的 技 术, 每 个 应 用 程 序 在 理 论 上 有 4GB 的 内 存 空 间, 空 间 中 的 每 个 地 址 都 必 须 是 唯 一 的, 根 据 前 面 的 知 识 可 以 知 道 4(GB)=4*1024*1024*1024(B), 那 么 内 存 地 址 就 需 要 32(bit) 来 表 示 与 现 实 生 活 中, 如 果 地 址 不 唯 一, 那 么 快 递 公 司 就 不 知 道 该 往 哪 里 寄 包 裹 是 同 样 的 道 理 4.1.2 声 明 一 个 指 针 图 4.1 指 针 内 存 示 意 图 使 用 指 针 之 前 需 要 对 指 针 变 量 进 行 声 明, 指 针 的 声 明 类 似 于 一 般 的 变 量, 区 别 在 于 指 针 类 型 名 后 面 跟 了 一 个 星 号 (*) < 类 型 > * < 指 针 名 > // 如 int *pint; 其 中 < 类 型 > 表 示 的 是 指 针 的 类 型,< 指 针 名 > 是 标 识 符 * 是 一 个 修 饰 符, 表 示 声 明 了 一 个 指 针 变 量 除 了 例 子 给 出 的 声 明 int 类 型 指 针 外, 还 可 以 用 如 :long double float char 等 声 明 一 个 指 针 变 量 long* plong; // 声 明 一 个 long 类 型 的 指 针 double* pdouble; // 声 明 一 个 double 类 型 指 针 float* pfloat; // 声 明 一 个 float 类 型 指 针 char* pchar; // 声 明 一 个 char 类 型 指 针 注 意 : 指 针 变 量 名 通 常 在 其 前 面 加 个 p 字 符, 来 表 示 该 变 量 是 一 个 指 针, 利 于 后 期 程 序 维 护, 是 一 种 比 较 好 的 编 程 风 格 从 上 面 可 以 发 现 指 针 变 量 的 声 明 是 在 类 型 旁 边 加 星 号, 但 这 种 表 示 并 不 是 唯 一 的 还 可 以 把 星 号 放 在 指 针 名 旁 边 int *pint; 这 两 种 声 明 方 式 都 是 正 确 的 虽 然 第 一 种 方 式 比 较 常 用, 但 是 当 混 合 使 用 一 般 变 量 和 指 针 变 量 声 明 的 时 候 容 易 产 生 混 淆 比 如 下 面 的 语 句 : int* pint1,pint2; 这 种 声 明 方 式 并 不 是 声 明 了 两 个 int 类 型 的 指 针 变 量, 只 有 pint1 才 是 int 型 指 针 变 量, pint2 是 一 个 int 型 变 量 但 是 如 果 按 照 第 二 种 声 明 方 式 就 不 易 产 生 混 淆, 然 而 会 产 生 的 问 题 是 第 二 种 方 式 含 义 不 够 清 晰 : int *pint1,pint2; 因 此, 最 好 的 表 示 方 法 还 是 分 开 表 示, 且 利 于 程 序 对 各 个 变 量 的 注 释 int* pint1; // 声 明 了 一 个 int 型 指 针 变 量 int pint2; // 声 明 一 个 int 型 变 量 82
第 4 章 指 针 与 引 用 例 子 4.1 声 明 long short 类 型 的 指 针 和 变 量, 并 查 看 输 出 对 应 指 针 和 变 量 的 值 和 地 址 对 如 何 声 明 一 个 指 针 加 深 印 象 ----------------------------------------------Example4.1.cpp------------------------------------------------------------- 01 #include<iostream> 02 using namespace std; 03 void main(void) 04 { 05 long L; // 声 明 一 个 长 整 型 变 量 06 long* pl; // 声 明 一 个 长 整 型 指 针 07 short S; // 声 明 一 个 短 整 型 变 量 08 short* ps; // 声 明 一 个 短 整 型 指 针 09 pl = &L; //& 获 取 L 变 量 的 地 址 10 ps = &S; 11 cout<<"l 内 存 地 址 是 :\t"<<&l<<endl; 12 cout<<"pl 内 存 地 址 是 :\t"<<&pl<<endl; 13 cout<<"s 内 存 地 址 是 :\t"<<&s<<endl; 14 cout<<"ps 内 存 地 址 是 :\t"<<&ps<<endl; 15 cout<<"pl 的 值 是 :\t"<<pl<<endl; 16 cout<<"ps 的 值 是 :\t"<<ps<<endl; 17 // 获 取 L S 在 内 存 所 占 字 节 数 18 cout<<"l 占 内 存 字 节 数 :\t"<<sizeof(l)<< "\ts 占 内 存 字 节 数 : 19 \t"<<sizeof(s)<<endl; // 获 取 pl ps 在 内 存 所 占 字 节 数 20 cout<<"pl 占 内 存 字 节 数 :\t"<<sizeof(pl)<< "\tps 占 内 存 字 节 数 : \t"<<sizeof(ps)<<endl; 21 } 编 译 运 行 程 序 得 到 的 输 出 结 果 为 : L 内 存 地 址 是 : 0017F7A8 pl 内 存 地 址 是 : 0017F79C S 内 存 地 址 是 : 0017F790 ps 内 存 地 址 是 : 0017F784 pl 的 值 是 : 0017F7A8 ps 的 值 是 : 0017F790 L 占 内 存 字 节 数 : 4 S 占 内 存 字 节 数 : 2 pl 占 内 存 字 节 数 : 4 ps 占 内 存 字 节 数 :4 观 察 例 子 4.1 运 行 结 果, 分 析 总 结 得 到 : 变 量 L( 或 者 S) 地 址 和 指 向 变 量 的 指 针 地 址 pl( 或 者 ps) 是 没 有 对 应 直 接 关 系 的 变 量 L( 或 者 S) 的 地 址 和 指 向 变 量 pl( 或 者 ps) 指 针 值 是 一 致 的 无 论 哪 种 类 型 的 指 针, 其 所 占 内 存 空 间 在 32 位 的 Windows 操 作 系 统 下 都 是 4 个 字 节, 不 会 随 指 向 类 型 不 同 而 不 同 4.1.3 初 始 化 指 针 变 量 在 C++ 中, 指 针 声 明 时 并 不 会 对 其 进 行 初 始 化, 而 是 分 配 一 个 随 机 值, 操 作 未 初 始 化 的 指 针 是 很 危 险 的, 这 个 值 可 能 指 向 一 个 非 常 重 要 的 数 据, 不 当 的 操 作 可 能 会 引 起 程 序 崩 溃, 甚 至 是 系 统 的 崩 溃 所 以 把 声 明 的 指 针 初 始 化 就 好 比 要 把 不 用 的 枪 打 开 保 险 一 样, 枪 83
第 1 篇 C++ 编 程 基 础 篇 支 走 火 可 不 是 闹 着 玩 的 指 针 失 控 也 是 相 当 危 险 的 因 此, 指 针 应 该 在 声 明 或 赋 值 语 句 中 进 行 初 始 化 指 针 可 以 被 初 始 化 为 0 NULL( 符 号 化 常 量 ) 或 地 址, 其 中 值 为 0 或 者 NULL 的 指 针 不 指 向 任 何 内 容 变 量 的 地 址 则 是 通 过 & 符 号 把 地 址 赋 值 给 指 针 变 量 如 下 列 代 码 所 示 : int * pint = 0; // 或 者 用 *pint = NULL; long A = 10; long* plong = &A; // 初 始 化 plong 指 针 上 面 的 这 些 语 句 首 先 声 明 了 一 个 int 类 型 的 指 针 变 量, 并 初 始 化 为 空 接 着 又 声 明 一 个 long 类 型 的 变 量 A, 并 将 A 的 地 址 赋 值 给 一 个 long 类 型 的 指 针 变 量 plong 切 记, 在 用 另 一 个 变 量 对 指 针 进 行 初 始 化 时, 必 须 在 该 指 针 之 前 对 变 量 进 行 声 明, 否 则 会 引 起 编 译 错 误 注 意 : 符 号 常 量 NULL 在 标 准 库 中 定 义 为 0, 虽 然 可 以 初 始 化 指 针 变 量, 但 是,NULL 仅 同 C 兼 容, 在 C++ 中 最 好 使 用 0 还 有, 现 在 的 大 多 数 操 作 系 统 都 运 行 在 保 护 模 式 下, 会 阻 止 未 初 始 化 指 针 的 非 法 操 作, 但 是, 如 果 系 统 是 实 模 式 下 则 可 能 引 起 系 统 崩 溃 4.1.4 指 向 指 针 的 指 针 从 前 面 的 学 习 中 可 以 知 道, 指 针 可 以 指 向 任 何 数 据 类 型 的 对 象, 指 针 变 量 也 是 一 种 数 据 类 型 的 对 象, 从 而 可 以 用 另 外 一 个 指 针 指 向 它, 这 种 指 针 称 为 指 向 指 针 的 指 针 或 二 级 指 针 这 种 说 法 可 能 过 于 抽 象, 那 么 举 个 例 子 : 今 天 上 午 要 上 C++ 语 言 这 门 课 程 于 是, 学 生 们 查 询 他 们 的 课 表 找 到 了 上 课 地 址 是 在 教 学 楼 305 这 个 教 室, 可 是 等 他 们 到 达 的 时 候 发 现 这 个 教 室 黑 板 上 写 了 一 个 通 知, 由 于 某 些 原 因 上 课 地 址 改 为 407 这 个 教 室, 于 是 学 生 们 找 到 407 教 室, 终 于 赶 上 了 重 要 的 C++ 课 程 如 果 把 407 教 室 比 作 变 量 的 地 址 的 话, 那 么, 305 黑 板 上 的 通 知 就 是 指 向 这 个 变 量 的 一 级 指 针, 学 生 们 的 课 表 就 是 指 向 305 教 室 的 二 级 指 针 二 级 指 针 可 以 这 样 声 明 : int ** pint; // 声 明 了 一 个 int 类 型 的 二 级 指 针 因 此, 可 以 通 过 ** 来 声 明 一 个 二 级 指 针 那 么 可 以 这 样 初 始 化 一 个 二 级 指 针 : int * pint = 0; int** ppint = &pint; // 或 者 : int** ppint = 0; 观 察 图 4.2 二 级 指 针 的 内 存 布 局, 来 加 深 对 二 级 指 针 的 理 解 二 级 指 针 是 一 个 十 分 常 用 的 概 念, 经 常 和 二 维 数 组 在 一 起 使 用, 具 体 应 用 会 在 后 文 详 细 讲 述 例 子 4.2 主 要 通 过 查 看 二 级 指 针 指 针 及 变 量 之 间 的 关 系, 加 深 对 二 级 指 针 使 用 的 理 解 ------------------------------------------------Example4.2.cpp----------------------------------------------------------- 01 #include<iostream> 02 using namespace std; 84
第 4 章 指 针 与 引 用 03 void main(void) 04 { 05 int i = 10; 06 int* pint = &i; // 初 始 化 pint 指 针 07 int** ppint = &pint; // 初 始 化 ppint 二 级 指 针 08 cout<<"i 的 内 存 地 址 是 :\t"<<&i<<endl; 09 cout<<"pint 值 是 :\t"<<pint<<endl; 10 cout<<"pint 的 地 址 是 :\t"<<&pint<<endl; 11 cout<<"ppint 值 是 :\t"<<ppint<<endl; 12 cout<<"ppint 的 地 址 是 :\t"<<&ppint<<endl; 13 cout<<"ppint 访 问 i 的 结 果 :\t"<<**ppint<<endl; 14 } 编 译 运 行 输 出 结 果 为 : i 的 内 存 地 址 是 : 0028F830 pint 值 是 : 0028F830 pint 的 地 址 是 : 0028F824 ppint 值 是 : 0028F824 ppint 的 地 址 是 : 0028F818 ppint 访 问 i 的 结 果 : 10 上 面 这 段 程 序 声 明 了 一 个 pint 指 针 ppint 二 级 指 针, 并 都 进 行 初 始 化, 且 依 次 打 印 输 出 了 变 量 i 指 针 pint 及 指 针 ppint 的 地 址 和 值 从 输 出 结 果 上 看 pint 的 值 是 0x0028F830, 就 是 i 的 内 存 地 址 0x0028F830,pInt 的 地 址 0x0028F824 则 是 ppint 的 值 0x0028F824 可 以 看 出 指 针 地 址 和 它 所 指 向 变 量 的 值 是 没 有 对 应 联 系 的, 如 :i 的 值 是 10, 而 指 向 它 的 指 针 地 址 是 0x0028F824 如 果 有 一 个 指 针 指 向 二 级 指 针, 那 么 这 个 指 针 就 叫 三 级 指 针, 甚 至 还 有 更 高 阶 的 指 针, 但 这 些 指 针 都 很 少 使 用, 使 用 时 也 很 容 易 引 起 误 解 图 4.2 二 级 指 针 内 存 布 局 4.2 指 针 的 运 算 由 于 指 针 是 一 种 特 殊 的 数 据 类 型, 所 以 对 指 针 进 行 的 操 作 就 有 一 定 的 限 制 除 了 赋 值 运 算 外, 指 针 只 能 进 行 与 整 数 相 加 减 同 类 型 指 针 之 间 的 比 较 运 算, 以 及 同 类 型 指 针 之 间 的 相 减 运 算 本 节 将 详 细 讲 述 这 些 运 算 的 规 则 4.2.1 指 针 的 赋 值 运 算 和 增 减 值 运 算 1. 指 针 的 赋 值 运 算 指 针 在 定 义 或 者 声 明 的 时 候 可 以 被 赋 初 值, 指 针 变 量 也 可 以 被 赋 值 指 针 赋 值 运 算 在 C++ 编 程 中 是 经 常 用 到 的 指 针 在 进 行 赋 值 运 算 时 应 遵 守 一 定 的 规 则 : 只 能 将 类 型 相 同 级 别 一 致 的 变 量 或 者 对 85
第 1 篇 C++ 编 程 基 础 篇 象 的 地 址 赋 值 给 指 针 例 如 下 面 声 明 的 变 量 和 指 针 : 86 int * pint; // 声 明 一 个 指 针 int a = 10; double d = 1.0; 对 比 下 面 的 这 个 赋 值 操 作 : pint = &a; // 正 确 赋 值 操 作 pint = &d; // 编 译 出 错 因 为 指 针 的 类 型 是 int 型 的, 而 变 量 是 个 double 类 型, 违 反 了 类 型 相 同 原 则 又 比 如 下 面 的 例 子 : int a[10], b[2][10], *pint; pint = a; // 正 确 赋 值 操 作 pint = b; // 错 误 赋 值 操 作 数 组 a 代 表 的 是 一 个 常 量 指 针, 它 是 这 个 数 组 的 首 地 址 值, 所 以 是 可 以 赋 值 的 b 是 一 个 二 级 常 量 指 针, 而 p 是 一 级 指 针, 违 反 了 级 别 一 致 原 则 指 针 变 量 的 赋 值 如 : int * pint = 0; // 初 始 化 置 为 空 指 针, 以 免 发 生 致 命 错 误 int a(5); // 与 a=5; 效 果 一 致 pint = &a; // 用 变 量 a 给 pint 指 针 赋 值 *pint = 10; 调 试 一 下 查 看 运 行 结 果, 程 序 执 行 到 第 一 步 时, 查 看 pint 变 量 值 是 0, 也 就 是 这 是 一 个 空 指 针 接 着 执 行 第 二 步,a 的 值 是 5, 执 行 第 三 步 后 pint 值 变 成 了 a 的 地 址 (0x0028F71A, 不 同 计 算 机 可 能 不 一 样 ) 此 时 变 量 a 的 值 还 是 5, 执 行 完 第 四 步 后 pint 值 没 变, 而 a 的 值 变 成 了 10 这 说 明 通 过 指 针 也 可 以 修 改 指 向 变 量 的 内 存 空 间 还 有 一 点 值 得 注 意 的 是, 不 要 被 int *p=null 和 *p=null 迷 惑, 这 两 句 代 码 只 是 穿 的 衣 服 比 较 相 似 而 已 第 一 句 是 声 明 一 个 指 针 p 并 将 它 指 向 一 个 内 存 特 殊 位 置 0x00000000 而 第 二 句 话 则 是 将 p 所 指 内 存 空 间 值 置 为 0 如 果 p 指 向 的 是 合 法 地 址, 那 么 该 空 间 值 变 成 了 0, 如 果 地 址 不 合 法, 则 系 统 会 提 示 非 法 操 作 这 也 就 是 为 什 么 建 议 选 择 用 0 来 初 始 化 一 个 指 针 而 不 用 NULL 的 原 因 2. 增 值 和 减 值 运 算 指 针 可 以 和 一 个 int 型 变 量 进 行 加 减 运 算 ( 当 然 short 类 型 变 量 也 是 可 以 的 ),++ 和 运 算 符 也 适 用 于 指 针 运 算 由 于 指 针 值 是 一 个 内 存 地 址 值, 加 减 运 算 相 当 于 改 变 了 地 址 值, 也 就 是 移 动 了 指 针 在 内 存 所 指 向 的 位 置 注 意, 保 存 指 针 值 的 地 址 不 变 例 如 下 面 的 代 码 : short a[5]; // 声 明 一 个 short 类 型 的 数 组 short *ps = a; // 初 始 化 ps 指 针, 使 其 指 向 a 数 组 ps++; //ps 做 增 值 运 算 如 图 4.3 所 示 为 指 针 ps 指 针 位 置 变 化 情 况 图 中 虚 线 代 表 的 是 ps 指 针 在 没 有 进 行 自 增 操 作 时 指 向 了 内 存 的 0x0022F9CC 这 个 位 置, 实 线 代 表 ps 完 成 自 增 操 作 之 后 指 针 位 置