const指针六二维数组

《const指针六二维数组》由会员分享，可在线阅读，更多相关《const指针六二维数组（27页珍藏版）》请在装配图网上搜索。

1、1 2 五 、 const指 针 普 通 指 针 是 没 有 const约 束 的 指 针 ， 这 样 的 指 针 本 身 既可 以 变 动 ， 其 指 向 的 内 存 单 元 也 可 更 新 。 普 通 指 针 p进 行 两 种 运 算 ： 一 种 是 指 针 的 加 减 寻 址 运 算 ， 如 p = const 类 名 *只 读 指 针 = 数 据 区 的 地 址 ； 第 一 种 形 式 可 以 不 必 同 时 进 行 初 始 化 ， 即 可 以 先 定 义r， 然 后 再 将 该 指 针 指 向 某 个 同 类 型 的 变 量 或 数 组 。 只 读 指 针 可 以 在 一 片 只 读

2、 或 非 只 读 的 数 据 区 移 动 ， 以 便将 数 据 只 读 地 复 制 到 其 它 位 置 。 只 读 指 针 既 可 指 向 只 读 区 也可 指 向 变 量 或 左 值 区 。 定 义 中 的 关 键 字 const限 定 *r为 右值 ， 具 体 地 说 只 读 指 针 r是 左 值 指 针 ， 间 接 变 量 *(r+i)或 ri约束 为 右 值 表 达 式 。 4 第 二 种 形 式 定 义 的 指 针 称 为 固 定 指 针 或 右 值 指 针 。 第 二种 形 式 为 ： type *const s = 左 值 区 的 地 址 ; 类 名 * const 固 定 指

3、针 = 非 只 读 区 的 地 址 ； 第 二 种 形 式 必 须 同 时 用 变 量 或 左 值 的 地 址 进 行 初 始 化 ，除 非 作 为 形 参 。 定 义 中 的 关 键 字 const冻 结 指 针 s为 右 值 ， *s或 si是 左 值 。 一 维 数 组 名 a就 是 一 个 这 样 的 右 值 地 址 ， r=a是 可 以的 ， a=r是 错 误 的 ， 这 确 保 数 组 元 素 总 是 可 以 通 过 a来 索 引 。 右 值 指 针 可 以 用 来 接 受 new运 算 符 申 请 动 态 自 由 空 间 成功 后 的 结 果 值 ， 以 避 免 对 堆 指 针

4、加 减 的 误 操 作 。 5 例 固 定 指 针 和 只 读 指 针 (固 定 指 针 和 只 读 指 针 都 可 指 向 普通 (非 只 读 )的 数 组 )void intcpy (int *p,const int*q,int n) /只 读 指 针 形 参 q表 示 *q在 函 数 体 中 为 右 值 。 for (int k=0; kn; p+, q+, k+) *p = *q; /左 边 的 函 数 体 与 下 面 程 序 块 等 价 # include / int k=0; while(kn)*p=*q; p+;q+;k+; const int c5 = 1,2,3,4,5; /

5、定 义 只 读 全 局 数 组 ， 每 一 个 数 组 元 素 ck为 右 值 6 void main (void) int a10; int * const s=a; /定 义 固 定 指 针 s， 初 始 化 为 数 组 名 a const int *r=c; int k=0; for (; k5; k+, r+) sk=*r; intcpy (a+5,a,5); for (k=0; k10; k+) cout-ak; /输 出 结 果 ： -1-2-3-4-5-1-2-3-4-5 7 只 读 指 针 本 身 是 可 变 的 ， 只 读 指 针 的 间 接 访 问 不 得 改写 它 指 向

6、 的 存 储 单 元 。 固 定 指 针 本 身 是 不 变 的 ， 但 固 定 指 针 指 向 的 存 储 单 元 允许 更 新 。 固 定 指 针 只 读 指 针 都 可 以 指 向 变 量 ， 固 定 指 针 和 普 通 指针 不 指 向 只 读 数 据 区 而 仅 指 向 左 值 数 据 区 。 只 读 指 针 本 身 是 可 变 的 ， 只 读 指 针 的 间 接 访 问 不 得 改 写它 指 向 的 存 储 单 元 。 固 定 指 针 本 身 是 不 变 的 ， 但 固 定 指 针 指 向 的 存 储 单 元 允许 更 新 。 固 定 指 针 只 读 指 针 都 可 以 指 向 变

7、 量 ， 固 定 指 针 和 普 通 指针 不 指 向 只 读 数 据 区 而 仅 指 向 左 值 数 据 区 。 8 例 如 ： const int c5=1,2,3,4,5; / /错 误 ， 定 义 固 定 指 针 指 向 只 读 数 组 c， si可 以 是 左 值 int * p； /定 义 一 个 普 通 的 指 针 即 非 只 读 的 指 针 p， pi可 以 是 左 值 p= /错 误 ， p指 向 首 元 素 ， *p为 左 值 , 但 c0为 右 值 ， 矛 盾 9 固 定 指 针 s指 向 只 读 数 组 首 元 素 , *s可 为 左 值 ， 间 接 地 导致 c0为

8、左 值 ， 但 这 与 只 读 数 组 的 定 义 矛 盾 ； 类 似 地 普 通 指针 p不 指 向 只 读 数 组 。 不 可 以 对 只 读 指 针 进 行 左 值 访 问 ： const char * r=abc; /字 符 串 安 排 在 只 读 数 据 区 ， 其 首 地 址 具 有 char*属 性 *r=m; /错 误 ， *r是 右 值 表 达 式左 值 区 可 作 为 右 值 区 访 问 。 从 int*型 转 换 到 const int*型 是 默 许 的 。 但 是 反 之 不然 ， 即 不 将 const int*型 的 地 址 隐 含 地 转 换 为 int*型 或

9、int*const型 的 指 针 ， 除 非 强 制 类 型 转 换 。 10 例 指 针 的 强 制 类 型 转 换 攻 击 只 读 数 据 区#include void swap (int*const s) int t=*s;*s=s1;s1=t; void main() const int a2=1,2; printf (%d,%d;,a0,*(a+1); int* p= (int*) (a+1); printf (%d,%d-, p-1=3,*p=4); swap (int*) printf (%d, %d, *a, a 1); 11 第 三 种 形 式 定 义 的 指 针 可 称 为

10、 只 读 的 固 定 指针 ， 其 格 式 为 ： const type* const x=地 址 表 达 式 ; 语 句 限 定 x,*x都 为 右 值 ， 因 此 x+,x0+是 错 误 的 。例 如 ： const int c=0;int j=0; const int * const x= /x指 向 只 读 变 量 c， /y指 向 变 量 j， 类 型 数 组 名 常 数 1常 数 2； 常 数 1指 出 二 维 数 组 的 行 数 r ， 常 数 2指 出 二 维 数 组 的列 数 c。 行 数 r和 列 数 c是 静 态 确 定 的 正 整 数 。 例 如 : typedef i

11、nt type; const int r=8; int c=6; type dr sizeof c; 是 允 许 的 ，而 typedef int type; int r=8,c=6; type drc; 是 不 可 以 的 。 14 二 维 数 组 下 标 表 达 式 中 有 二 个 下 标 如 djk,第 一 个 下 标j用 于 索 引 数 组 的 行 ， 第 二 个 下 标 k指 出 相 对 于 数 组 某 行 的列 。 二 维 数 组 一 经 定 义 就 具 有 如 下 性 质 ： a. 行 数 r和 列 数 c一 起 确 定 数 组 的 元 素 个 数 为 r*c。 b. 数 组 元

12、 素 ， 二 维 数 组 第 j+1行 第 k+1列 的 元 素 表 示 为d j k ， j合 理 的 取 值 范 围 为 0r-1, k合 理 的 取 值 范 围 为 : 0c-1。 d j k 等 价 于 访 问 指 针 形 式 (*(*(d+j)+k)， 两 者 为type型 左 值 ， 其 作 用 相 当 于 变 量 。 数 组 元 素 占 住 内 存 的 字 节数 为 n = sizeof (type) = sizeof (d j k )。 15 c. 二 维 数 组 名 具 有 两 个 信 息 ， 数 组 名 d代 表 数 组 的 首 地址 和 大 小 。 d+j具 有 type

13、 (*)c型 的 属 性 ， 指 向 第 j+1行 即 d+j 等 价 于 double d43;就定 义 两 个 二 维 数 组 ， 它 们 都 有 12个 数 组 元 素 。 但 b占 有 sizeof (short)*3*4 = 24 个 字 节 的 内 存 ，d占 有 sizeof(double)*4*3=96 个 字 节 的 内 存 。b,d都 代 表 数 组 的 首 地 址 ， d具 有 类 型 属 性 double(*)3 ， b是 short (*)4 类 型 属 性 的 地 址 。 定 义 语 句 中 的 3和 4用 于 界 定 数 组 的 维 数 。 b23,d32分 别

14、是 这 两 个 数 组 的 最 后 一 个 元 素 ， b34,d43是 合 法 的 表 达 式 ， 但 导 致 越 界 ， 其 中 的 3和 4是 索 引 内 存 的 下 标 。 定 义 语 句 分 配 唯 一 的 一 片 内 存 ， 下 标 表 达 式 ai,dij等 用 于 访 问 或 操 作 内 存 ， 编 译 器 不 检 查 下 标 是 否 越 界 。 18 例 如 : 数 组 int x24与 char z42在 内 存 中 的 排 放 次序 分 别 为 ： x00， x01， x02， x03， x10， x11，x12 ， x13 z00， z01， z10， z11， z20

15、， z21， z30， z31 从 上 可 见 元 素 z12与 z20 距 离 数 组 z的 首 地 址 具 有相 同 的 偏 移 ， x04将 索 引 到 元 素 x10。 而 x14的 索 引 方 式 导 致 越 界 。 从 上 可 见 最 后 一 个 下 标变 化 最 快 。 19 x i 是 int*型 的 右 值 地 址 ， z i 是 char*型 的 右 值 地 址 。 x i 和 z i 是 不 同 类 型 的 地 址 。 x i j 是 int型 的 左 值 ， z i j 是 char型 的 左 值 。 因 此 存 在 x i j = z j i 和 z i j = x

16、j i 形 式的 表 达 式 ， 它 们 引 起 类 型 转 换 。 不 存 在 x i = z j 和 z i = x j 形 式 的 表 达 式 ， 右 值 不能 放 在 赋 值 符 号 的 左 边 ， 并 且 不 同 类 型 的 地 址 也 不 许 隐 含 类型 转 换 。 20 例 从 二 维 数 组 中 查 找 第 一 个 出 现 的 负 数 # include void main() const int n=3 , m=2; int d n m ; /定 义 二 维 数 组 coutinput n*m integers:; int j ; int I ; for ( i=0; in

17、; i+ ) for(j=0; jd i j ; for ( i=0; in; i+ ) for ( j=0; jm; j+ ) goto found; cout not found if ( * ( * ( d+I ) +j ) 0) ! endl; goto end; 21 found : coutd i j = dijendl; end: ; 某 次 运 行 的 结 果 : 另 一 次 运 行 的 结 果 :input 6 integers:2 3 -4 5 6 7 input 6 integers:2 3 4 5 6 7a02=-4 not found! 说 明 ： 在 负 数 没 有

18、 找 到 之 前 ， 双 重 循 环 正 常 运 行 ， 若 循环 结 束 时 未 找 到 负 数 ， 则 显 示 not found!， 然 后 执 行 goto end语 句 ， 转 至 end标 号 处 。 这 里 是 一 个 空 语 句 。 由 此 看 出 ， 使 用 goto语 句 转 移 至 某 个 没 有 语 句 的 位 置时 ， 这 个 位 置 应 放 置 一 个 空 语 句 。 这 是 空 语 句 的 一 种 用 法 。在 循 环 中 ， 若 找 到 第 一 个 出 现 的 负 数 时 ， 用 goto语 句 退 出 两层 循 环 ， 显 示 找 到 的 负 数 。 然 后

19、执 行 下 面 的 空 语 句 ， 进 而 结束 程 序 的 执 行 。 22 2. 二 维 数 组 的 初 始 化二 维 数 组 初 始 化 定 义 语 句 的 格 式 为 ： type drc= initialList; 类 型 数 组 名 常 数 1常 数 2=初 始 化 列 表 ； 在 初 始 化 列 表 的 初 值 个 数 足 以 确 定 二 维 数 组 的 大 小 时可 以 省 略 地 第 一 个 常 数 的 大 小 。 即 ： type d c= initialList; 类 型 数 组 名 常 数 2=初 始 化 列 表 ；二 维 数 组 的 初 始 化 相 当 于 多 个 一

20、 维 数 组 的 初 始 化 的 延 拓 ，例 如 : int d24=1,2,3,4,5,6,7,8; 23 可 省 去 左 边 第 一 个 定 界 的 维 数 ， 但 最 右 边 定 界 的 维 数 是必 须 的 : int d 4=1,2,3,4,5,6,7,8;也 可 以 加 上 花 括 号 : int d4=1,2,3,4,5,6,7,8;花 括 号 的 情 形 对 于 不 完 整 的 初 始 化 格 式 是 必 须 的 ; int d 4=1,2,5,6,7;等 价 于 : int d24; d00=1; d01=2; d02=0; d03=0; d10=5; d11=6; d12

21、=7; d13=0; 24 无 花 括 号 的 情 形 ： int d 4=1,2,5,6,7;对 应 ： int d 24; d00=1; d01=2; d02=5; d03=6; d10=7; d11=0; d12=0; d13=0; 类 似 地 ： int d34=1,2,3;导 致 数 组 第 一 列 的 元 素 分 别 初 始 化 为 1,2,3， 其 余 设 置 为 0。 类 似 地 ： int d34=1,2;导 致 数 组 第 一 列 的 元 素 分 别 初 始 化 为 1,2,0， 其 余 设 置 为 0。 不 可 以 写 为 ： int d34=1, ,3; 25 3.多

22、维 数 组 多 维 数 组 的 定 义 的 格 式 为 ：类 型 数 组 名 表 达 式 1 表 达 式 2 表 达 式 n; type array max1 max2 . maxn= 初 始 化 列 表 ; 初 始 化 语 句 定 义 多 维 数 组 时 ， 可 以 不 指 定 第 一 维 的 维 数 ,但 其 余 的 维 数 是 必 须 给 定 的 ： type array max2.maxn=初 始 化 列 表 ;n维 数 组 的 下 标 表 达 式 有 n个 下 标 ,如 下 :array sub1 sub2. subn 下 标 运 算 符 是 从 左 向 右 结 合 的 ， 最 左

23、下 标 表 达 式array sub1 首 先 求 值 ,然 后 求 下 标 表 达 arraysub1sub2,依 此 类 推 。 多 维 数 组 在 内 存 单 元 中 是 连 续 的 线 性 存 放 的 。 这称 为 多 维 空 间 到 一 维 内 存 单 元 的 映 射 。 C/C+对 数 组 元 素 的 安 排 按 照 第 一 个 下 标 优 先 的 顺 序 进 行 . 26 对 于 二 维 数 组 先 存 放 第 一 行 ， 接 着 存 放 第 二 行 。 对 于 三维 数 组 先 存 放 第 一 页 ， 接 着 存 放 第 二 页 。 这 也 意 味 最 后 一 个下 标 变 化

24、 最 快 。 例 如 : 对 于 三 维 数 组 type smrc; /*m,r,c是 预 先 静 态 给 定 的 正 数 */ 先 存 放 第 一 页 的 r*c个 元 素 s0rc;接 着 存 放 第 二 页 的r*c个 元 素 s1rc。 si的 地 位 相 当 于 二 维 数 组 名 d， 对 于特 定 的 一 页 ， 先 存 放 该 页 二 维 数 组 第 一 行 ， 接 着 存 放 第 二行 。 依 此 类 推 。 对 于 int s224在 内 存 中 的 排 放 次 序 为 ： s000 ,s001, s002, s003,s010, s011, s012 ,s013, s100 ,s101, s102, s103,s110, s111, s112 ,s113 27