c 重点难点复习题及答案.pdf

《c 重点难点复习题及答案.pdf》由会员分享，可在线阅读，更多相关《c 重点难点复习题及答案.pdf（53页珍藏版）》请在淘文阁 - 分享文档赚钱的网站上搜索。

1、1、数 据 共 享 与 保 护 一、选 择 题：1、在 下 面 存 储 类 中，（C）对 象 的 可 见 性 与 生 存 期 不 一 致。A.外 部 类 B.自 动 类 C.内 部 静 态 类 D.寄 存 器 类 2、在 下 面 存 储 类 中，（A）的 对 象 不 是 局 部 变 量。A.外 部 静 态 类 B.自 动 类 C.函 数 形 参 D.寄 存 器 类 3、关 于 局 部 变 量，下 面 说 法 正 确 的 是（C）0A.定 义 该 变 量 的 程 序 文 件 中 的 函 数 都 可 以 访 问 B.定 义 该 变 量 的 函 数 中 的 定 义 处 以 下 的 任 何 语 句 都

2、 可 以 访 问 C.定 义 该 变 量 的 复 合 语 句 中 的 定 义 处 以 下 的 任 何 语 句 都 可 以 访 问 D.定 义 该 变 量 的 函 数 中 的 定 义 处 以 上 的 任 何 语 句 都 可 以 访 问 4、一 个 类 的 静 态 数 据 成 员 所 表 示 属 性（C）。A.是 类 的 或 对 象 的 属 性 B.只 是 对 象 的 属 性 C.只 是 类 的 属 性 D.类 和 友 元 的 属 性 5、类 的 静 态 成 员 的 访 问 控 制（D）。A.只 允 许 被 定 义 为 privateB.只 允 许 被 定 义 为 private或 protect

3、edC.只 允 许 被 定 义 为 publicD.可 允 许 被 定 义 为 private、protected 或 public6、静 态 成 员 函 数 对 类 的 数 据 成 员 访 问（B）oA.是 不 允 许 的 B.只 允 许 是 静 态 数 据 成 员 C.只 允 许 是 非 静 态 数 据 成 员 D.可 允 许 是 静 态 数 据 成 员 或 非 静 态 数 据 成 员 7、被 非 静 态 成 员 函 数 访 问 的 类 的 数 据 成 员（A）。A.可 以 是 非 静 态 数 据 成 员 或 静 态 数 据 成 员 B.不 可 能 是 类 的 静 态 数 据 成 员 C.

4、只 能 是 类 的 非 静 态 数 据 成 员 D.只 能 是 类 的 静 态 数 据 成 员 8、静 态 数 据 成 员 的 初 始 化 是 在（D）中 进 行 的。A.构 造 函 数 B.任 何 成 员 函 数 C.所 属 类 D.全 局 区 9、当 将 一 个 类 A 或 函 数 f（）说 明 为 另 一 个 类 B 的 友 元 后，类 A 或 函 数 f（）能 够 直 接 访 问 类 B 的（D）oA.只 能 是 公 有 成 员 B.只 能 是 保 护 成 员 C.只 能 是 除 私 有 成 员 之 外 的 任 何 成 员 D.具 有 任 何 权 限 的 成 员 10、引 入 友 元

5、的 主 要 目 的 是 为 了（C）。A.增 强 数 据 安 全 性 B.提 高 程 序 的 可 靠 性 C.提 高 程 序 的 效 率 和 灵 活 性 D.保 证 类 的 封 装 性 11、一 个 类 的 成 员 函 数 也 可 以 成 为 另 一 个 类 的 友 元 函 数，这 时 的 友 元 说 明（A）oA.需 加 上 类 域 的 限 定 C.类 域 的 限 定 可 加 可 不 加 二、判 断 题 B.不 需 加 上 类 域 的 限 定 D.不 需 要 任 何 限 定1、类 的 静 态 数 据 成 员 需 要 在 定 义 每 个 类 的 对 象 时 进 行 初 始 化。F2、当 将 一

6、 个 类 S 定 义 为 另 一 个 类 A 的 友 元 类 时，类 S 的 所 有 成 员 函 数 都 可 以 直 接 访 问 类 A 的 所 有 成 员。T3、静 态 数 据 成 员 必 须 在 类 外 定 义 和 初 始 化。T4、静 态 成 员 函 数 可 以 引 用 属 于 该 类 的 任 何 函 数 成 员 F。5、友 元 函 数 是 在 类 声 明 中 由 关 键 字 friend修 饰 说 明 的 类 的 成 员 函 数。F6、友 元 函 数 访 问 对 象 中 的 成 员 可 以 不 通 过 对 象 名 F三、填 空 题：1、若“double x=100;”是 文 件 F1.

7、CPP中 的 一 个 全 局 变 量 定 义 语 句，若 文 件 F2.CPP中 的 某 个 函 数 需 要 访 问 此 x，则 应 在 文 件 F2.CPP中 添 加 对 x 的 声 明 语 句 为 Extern double x;2、如 果 一 个 函 数 定 义 中 使 用 了 加 法 修 饰,则 该 函 数 不 允 许 被 其 它 文 件 中 的 函 数 调 用。3、定 义 外 部 变 量 时，不 用 存 储 类 说 明 符 Extern,而 声 明 外 部 变 量 时 用 它。4、调 用 系 统 函 数 时，要 先 使 用#include命 令 包 含 该 系 统 函 数 的 原 型

8、 语 句 所 在 的 头 文 件。5、C+程 序 运 行 时 的 内 存 空 间 可 以 分 成 全 局 数 据 区，堆 区，栈 区 和 代 码 区。6、局 部 变 量 具 有 局 部 生 存 期，存 放 在 内 存 的 栈 区 中。7、对 类 中 对 象 成 员 的 初 始 化 是 通 过 在 构 造 函 数 中 给 出 的 初 始 化 表 来 实 现 的。8、对 类 中 常 量 成 员 的 初 始 化 是 通 过 在 构 造 函 数 中 给 出 的 初 绐 化 表 来 实 现 的。9、对 类 中 引 用 成 员 的 初 始 化 只 能 通 过 在 构 造 函 数 中 给 出 的 初 始 化

9、 表 来 实 现。10、对 类 中 一 般 数 据 成 员 的 初 始 化 既 可 以 通 过 在 构 造 函 数 中 给 出 的 初 始 化 表 来 实 现，也 可 以 通 过 构 造 函 数 中 的 函 数 体 来 实 现。11、假 定 要 把 aa定 义 为 AB类 中 的 一 个 常 量 整 数 型 数 据 成 员，则 定 义 语 句 const int aa012、假 定 要 把 aa定 义 为 AB类 中 的 一 个 引 用 整 数 型 数 据 成 员,则 定 义 语 句 为 int&aa。F T l i 定 AB类 中 只 包 含 一 个 整 型 数 据 成 员 a,并 且 它

10、是 一 个 常 量 成 员，若 利 用 参 数 aa对 其 进 行 初 始 化，则 该 类 的 构 造 函 数 的 定 义 为 AB(int aa)a=aa；。14、假 定 AB类 中 只 包 含 一 个 整 型 数 据 成 员 a,并 且 它 是 一 个 引 用 成 员，若 利 用 引 用 参 数 a a 对 其 进 行 初 始 化，则 该 类 的 构 造 函 数 的 定 义 为 AB(int&aa)a=aa；。15、静 态 成 员 函 数 能 够 直 接 访 问 类 的 静 态 数 据 成 员，只 能 通 过 对 象 名 访 问 类 的 非 静 态 数 据 成 员。16、静 态 数 据 成

11、 员 必 须 在 所 有 函 数 的 定 义 体 外 进 行 初 始 化。17、一 个 类 的 成 员 函 数 也 可 以 成 为 另 一 个 类 的 友 元 函 数，这 时 的 友 元 说 明 必 须 在 函 数 名 前 加 上 类 域 的 限 定。四、修 改 程 序 题：下 列 程 序 段 中，A_class的 成 员 函 数 Variance。可 求 出 两 数 的 平 方 差，请 改 写 该 程 序 段，把 Variance。函 数 从 A_class类 中 分 离 出 来，用 友 元 函 数 来 实 现 该 函 数 的 功 能。class A_class private:int x,

12、y,t;public:A_class(int i,int j):x(i),y(j)if(yx)t=x;x=y;y=t;)int Variance()return x*x-y*y;其 它 函 数 从 略；void main()A_class A_obj(3,5);cout，Result:，zA_obj.Variance()x)t=x;x=y;y=t;)friend int Variance();其 它 函 数 从 略；int variance()return x*x-y*y;)void main()A_class A_obj(3,5);coutz，Result:zzA_obj.Variance(

13、)en d l;2、数 组、指 针 与 字 符 串、1、在 下 面 的 一 维 数 组 定 义 中，哪 一 个 有 语 法 错 误。(C)A.int a=l,2,3;B.int a10=0;C.int a;D.int a5;2、在 下 面 的 字 符 数 组 定 义 中，哪 一 个 有 语 法 错 误。(D)oA.char a 20=abcdefg”；B.char a口=”x+y=55.C.char a15;D.char a10=,5，;3、在 下 面 的 二 维 数 组 定 义 中，正 确 的 是(C)oA.int a5;B.int a 5;C.int a3=l,3,5,2;D.int a(

14、10);4、假 定 一 个 二 维 数 组 的 定 义 语 句 为“int a34=3,4,2,8,6;”，则 元 素 a 1 2的 值 为（C）oA.2 B.4 C.6 D.85、假 定 一 个 二 维 数 组 的 定 义 语 句 为“int a34=3,4,2,8,6;”，则 元 素 的 值 为（A）oA.0 B.4 C.8 D.66、若 定 义 了 函 数 double*function（）,则 函 数 function的 返 回 值 为（B）。A.实 数 型 B.实 数 的 地 址 C.指 向 函 数 的 指 针 D.函 数 的 地 址 7、以 下 函 数 的 返 回 结 果 是（A）

15、。int function（char*x）char*p=x;while（*p+）;return（p-x-l）;）A.求 字 符 串 的 长 度 B.将 字 符 串 x连 接 到 字 符 串 p后 面 C.将 字 符 串 x 复 制 到 字 符 串 p 中 D.将 字 符 串 x 反 向 存 放 8、设 有 如 下 函 数 定 义 int f（char*s）char*p=s;while（*p!=,0）p+;return（p-s）;）在 主 函 数 中 用。成。（*。十）调 用 上 述 函 数，则 输 出 结 果 为（B）oA.3 B.4 C.5 D.69、假 定 变 量 m 定 义 为“int

16、m=7;，则 定 义 变 量 p 的 正 确 语 句 为（B）。A.int p=&m;B.int*p=&m;C.int&p=*m;D.int*p=m;10、变 量 s 的 定 义 为“char*s=Hello world!”；”，要 使 变 量 p 指 向 s所 指 向 的 同 一 个 字 符 串，则 应 选 取（A）。A.char*p=s;B.char*p=&s;C.char*p;p=*s;D.char*p;p=&s11、关 于 void指 针，下 列 说 法 正 确 的 是（C）。A.void指 针 就 是 未 指 向 任 何 数 据 的 指 针 B.void指 针 就 是 已 定 义 而

17、 未 初 始 化 的 指 针 C.指 向 任 何 类 型 数 据 的 指 针 可 直 接 赋 值 给 一 个 void指 针 D.void指 针 值 可 直 接 赋 给 一 个 非 void指 针 12、假 定 一 条 定 义 语 句 为“int a10,x,*pa=a;，若 要 把 数 组 a 中 下 标 为 3的 元 素 值 赋 给 x,则 不 正 确 的 语 句 为（D）。A.x=pa3;B.x=*（a+3）;C.x=a3;D.x=*pa+3;13、假 定 有 定 义“int b10;int*pb;，则 不 正 确 的 赋 值 语 句 为（D）。A.pb=b;B.pb=&b0;C.*pb

18、=new int;D.pb=b5;14、假 定 p 是 具 有 double类 型 的 指 针 变 量，则 表 达 式+p使 p 的 值（以 字 节 为 单 位）增 加（C）。A.1 B.4 C.sizeof（double）D.sizeof（p）15、假 定 p指 向 的 字 符 串 为”string，则 coutp+3的 输 出 结 果 为（C）。A.string B.ring C.ing D.i16、假 定 p 指 向 的 字 符 串 为”string，若 要 输 出 这 个 字 符 串 的 地 址 值，则 使 用(D)oA.cout*s;B.couts;C.cout&s;D.cout假

19、定 指 针 变 量 p 定 义 为 int*p=new int(100);”,要 释 放 p 所 指 向 的 动 态 内 存，应 使 用 语 句(A)。A.delete p;B.delete*p;C.delete&p;D.delete p；23、假 定 指 针 变 量 p 定 义 为 int*p=new int30;w,要 释 放 p 所 指 向 的 动 态 内 存，应 使 用 语 句(D)。A.delete p;B.delete*p;C.delete&p;D.delete p；24、当 类 中 一 个 字 符 指 针 成 员 指 向 具 有 n 个 字 节 的 存 储 空 间 时，它 所 能

20、 存 储 字 符 串 的 最 大 长 度 为(C)。A.n B.n+1 C.n-1 D.n-225、在 一 个 用 链 表 实 现 的 队 列 类 中，假 定 每 个 结 点 包 含 的 值 域 用 elem表 示，包 含 的 指 针 域 用 next表 示，链 队 的 队 首 指 针 用 elemHead表 示，队 尾 指 针 用 elemTail表 示，若 链 队 非 空，则 进 行 插 入 时 必 须 把 新 结 点 的 地 址 赋 给(D)。A.elemHead B.elemTailC.elemHead-next 和 elemHead D.elemTail-next elemTail2

21、6、在 一 个 用 链 表 实 现 的 队 列 类 中，假 定 每 个 结 点 包 含 的 值 域 用 elem表 示，包 含 的 指 针 域 用 next表 示，链 队 的 队 首 指 针 用 elemHead表 示，队 尾 指 针 用 elemTail表 示，若 链 队 为 空，则 进 行 插 入 时 必 须 把 新 结 点 的 地 址 赋 给(C)。A.elemHead B.elemTailC.elemHead和 elemTail D.elemHead 或 elemTail27、当 类 中 的 一 个 整 型 指 针 成 员 指 向 一 块 具 有 n*sizeof（int）大 小 的

22、存 储 空 间 时，它 最 多 能 够 存 储（A）个 整 数。A.n B.n+128、假 定 AB为 一 个 类，则 执 行 A.动 态 分 配 一 个 数 组 C.静 态 分 配 一 个 数 组 C.n-1 D.1AB*px=new ABn;w 语 句 时 将（AB.动 态 分 配 一 个 对 象 D.静 态 分 配 一 个 对 象）。29、设 px是 指 向 一 个 类 对 象 的 指 针 变 量，则 执 行“delete px;”语 句 时，将 自 动 调 用 该 类 的（C）oA.无 参 构 造 函 数 B.带 参 构 造 函 数 C.析 构 函 数 D.拷 贝 构 造 函 数 30

23、、当 一 个 类 对 象 离 开 它 的 作 用 域 时，系 统 自 动 调 用 该 类 的（D）oA.无 参 构 造 函 数 B.带 参 构 造 函 数 C.拷 贝 构 造 函 数 D.析 构 函 数 31、假 定 一 个 类 对 象 数 组 为 An,当 离 开 它 定 义 的 作 用 域 时，系 统 自 动 调 用 该 类 析 构 函 数 的 次 数 为（C）。A.0 B.1 C.n32、假 定 AB为 一 个 类，则 执 行“AB次 数 为（D）。A.0 B.1 C.933、假 定 AB为 一 个 类，则 执 行“AB造 函 数 的 次 数 为（A）。A.n B.n-1 C.34、假

24、定 AB为 一 个 类，则 执 行“AB数 的 次 数 为（A）oA.2 B.3 C.435、假 定 AB为 一 个 类，则 执 行“AB构 造 函 数 的 次 数 为（B）oA.3 B.4 C.536、假 定 AB为 一 个 类，则 执 行“AB a,类 无 参 构 造 函 数 的 次 数 为（D）A.5 B.6 C.3D.n-1语 句 时 调 用 该 类 无 参 构 造 函 数 的 D.10*px=new ABn;“语 句 时 调 用 该 类 无 参 构 1 D.0a,b（3）,*p;”语 句 时 共 调 用 该 类 构 造 函 D.5a（2）,b,*p4;”语 句 时 共 调 用 该 类

25、 D.9b（2）,c3,*p=&a;语 句 时 共 调 用 该 D.437、假 定 AB为 一 个 类，则 执 行 AB*p=new AB（1,2）;”语 句 时 共 调 用 该 类 构 造 函 数 的 次 数 为（B）。A.0 B.1 C.2 D.338、假 定 AB为 一 个 类，px为 指 向 该 类 的 一 个 含 有 n 个 对 象 的 动 态 数 组 的 指 针,则 执 行“delete px;”语 句 时 共 调 用 该 类 析 构 函 数 的 次 数 为（C）。A.0 B.1 C.n D.n+1二、填 空 题：1、用 于 存 储 一 个 长 度 为 n 的 字 符 串 的 字

26、符 数 组 的 长 度 至 少 为 _n+l o2、若 a 是 一 个 字 符 数 组，则 从 键 盘 上 向 该 数 组 输 入 一 个 字 符 布 的 表 达 式 为 _getline（cin,a）;。一 3、若 a 是 一 个 字 符 数 组,则 向 屏 幕 输 出 a 中 所 存 字 符 串 的 表 达 式 为 couta o4、一 个 二 维 字 符 数 组 a1020能 够 存 储 _ 1 0 个 字 符 串，每 个 字 符 串 的 长 度 至 多 为 _ 1 9 o5、对 一 个 二 维 字 符 数 组 a 进 行 初 始 化 的 数 据 为“123“，“456“，“789”,则

27、 a l 元 素 对 应 的 字 符 串 为 456 o6、strle n(a p p le)的 值 为 _ 5 strcm p(a,A)的 值 为 _1_7、假 定 对 数 组 a进 行 初 始 化 的 数 据 为 2,7,9,6,5,7,1 0,则 a2 和 a5分 别 被 初 始 化 为 _ 9 和 _ 7_ o8、假 定 对 二 维 数 组 a3 4 进 行 初 始 化 的 数 据 为 3,5,6,2,8,7,则 a l 1和 a2 3分 别 被 初 始 化 为 8_ 和 _ 0。9、若 二 维 数 组 a 有 m歹!,设 a0 0位 于 数 组 的 第 一 个 位 置 上，则 计 算

28、 任 一 元 素 a i j 在 数 组 中 位 置 序 号 的 公 式 为*m+j+1 o10、若 有 定 义“double a 3 5;w,则 a 数 组 中 行 下 标 和 列 下 标 的 最 大 值 分 别 为 2 和 _ 4 o11、一 个 指 针 类 型 的 对 象 占 用 内 存 的 _ 4 _ 个 字 节 的 存 储 空 间。12、一 个 指 针 指 向 一 个 数 据 对 象，它 保 存 着 该 数 据 对 象 的 也 址 若 数 据 对 象 为 DataType类 型，则 相 应 的 指 针 类 型 为 D a t a t y p e*。13、若 要 把 一 个 整 型 指

29、 针 p 转 换 为 字 符 指 针，则 采 用 的 强 制 转 换 表 达 式 为 _(char*)p_ o14、假 定 一 个 数 据 对 象 为 in t*类 型，则 指 向 该 对 象 的 指 针 类 型 为 _int*_O75 假 定 p 是 一 个 指 向 整 数 对 象 的 指 针，则 用 _*P 表 示 该 整 数 对 象，用 P _ 表 示 指 针 变 量 P 的 地 址。16、假 定 p 是 一 个 指 针，则*p+运 算 首 先 访 问*p，然 后 使 P_的 值 增 lo17、假 定 p 是 一 个 指 针，则(*p)+运 算 首 先 访 问 一*p _,然 后 使 _

30、*P的 值 增 lo18、假 定 p 所 指 对 象 的 值 为 25,p+1所 指 对 象 的 值 为 4 2,则*p+的 值 为 _ 2 5 _ o19、假 定 p 所 指 对 象 的 值 为 25,p+1所 指 对 象 的 值 为 4 2,则*+p的 值 为 _42_ o20、假 定 p 所 指 对 象 的 值 为 25,p+1所 指 对 象 的 值 为 4 2,则 执 行(*p)+运 算 后，p 所 指 对 象 的 值 为 一 26 o21、假 定 p所 指 对 象 的 值 为 25,p+1所 指 对 象 的 值 为 4 2,则 执 行*(p+)或*p+运 算 后，P所 指 对 象 的

31、 值 为 42 o22、假 定 a 是 一 个 一 维 指 针 数 组，则 a+i所 指 对 象 的 地 址 比 a 大 _4*i_字 节。23、假 定 a 是 一 个 一 维 数 组，则 a i 的 指 针 访 问 方 式 为 _*(a+i)_。24、假 定 a 是 一 个 一 维 数 组，则 a i 对 应 的 存 储 地 址(以 字 节 为 单 位)为 _ a+i*size o f(a i j)。25、一 个 数 组 的 数 组 名 实 际 上 是 指 向 该 数 组 首 元 素 的 指 针，并 且 在 任 何 时 候 都 不 允 许 _ 修 改 它。26、假 定 指 向 一 维 数 组

32、 b10中 元 素 b4的 指 针 为 p,则 p+3所 指 向 的 元 素 为 _ b 7,p-2所 指 向 的 元 素 为 _ b 2 o27、若 要 定 义 整 型 指 针 p 并 初 始 指 向 x,则 所 使 用 的 定 义 语 句 为_int*p=&x_o28、若 p 指 向 x,则 _*p 与 x 的 表 示 是 等 价 的。2 9 在 一 个 二 维 数 组 int 中，包 含 的 一 维 元 素 ai的 类 型 为 一 i n t n,访 问 ai时 返 回 值 的 类 型 为 _i n t*。30、假 定 一 个 二 维 数 组 为 c5 8,则 c3的 值 为 二 维 元

33、 素 c3 0的 地 址，c3+2的 值 为 二 维 元 素 _c3 2 的 地 址。31、假 定 p 为 指 向 二 维 数 组 int d4 6的 指 针，则 p 的 类 型 为 _inl(*)6 o32、假 定 a 是 一 个 二 维 数 组,则 的 指 针 访 问 方 式 为 _*(*(a+i)+j)33、执 行 int p=new int操 作 得 到 的 一 个 动 态 分 配 的 整 型 对 象 为 _*p。34、执 行 int*p=new 操 作，使 p 指 向 动 态 分 配 的 数 组 中 下 标 为。的 元 素，该 元 素 可 表 示 为 _*p 或 _ p 0。35、执

34、 行 char*p=new char。a，)操 作 后，p 所 指 向 的 数 据 对 象 的 值 为 _ a o36、执 行 new char m n操 作 时 的 返 回 值 的 类 型 为 char(*)n。37、执 行 一 delete p 操 作 将 释 放 由 p所 指 向 的 动 态 分 配 的 数 据 空 间。38、执 行 _deletep 操 作 将 释 放 由 p所 指 向 的 动 态 分 配 的 数 组 空 间。39、NULL是 一 个 符 号 常 量，通 常 作 为 空 指 针 值，它 的 具 体 值 为 _ 0。40、变 量 v 定 义 为 double v=23.4

35、;”,要 使 指 针 pv指 向 v,则 定 义 pv的 语 句 为 _ double*p v=&v。41、已 知 语 句 coutp;w的 输 出 是 Hello!”,则 语 句 cout*p;“输 出 的 是 _H o42、,已 知 语 句 couts;v的 输 出 是 apple”,则 执 行 语 句 name等 价 的 表 达 式 是 _(*p).name 046、与 结 构 成 员 访 问 表 达 式(*fp).score等 价 的 表 达 式 是 _ f p-score o47、已 知 有 定 义“int x,a=5,7,9),*pa=a;,在 执 行 x=+*pa;“语 句 后，

36、x 的 值 是 _ 6 o48、已 知 有 定 义“int x,a=6,10,12),*pa=a;,在 执 行 x=*+pa;”语 句 后，*pa的 值 是 0 o49、已 知 有 定 义“int x,a=15,17,19),*pa=a;,在 执 行 x=*pa+;”后，*pa的 值 是 _17_ o50、若 采 用 p-abc(y)表 达 式 调 用 一 个 成 员 函 数，在 成 员 函 数 中 使 用 的 _this_就 代 表 了 类 外 的 p 指 针。51、在 一 个 用 数 组 实 现 的 队 列 类 中，包 含 有 两 个 数 据 成 员，一 个 指 明 队 首 元 素 位 置

37、，另 一 个 指 明 队 列 长 度。52、在 一 个 用 数 组 实 现 的 队 列 类 中，包 含 有 两 个 数 据 成 员，一 个 指 明 队 列 长 度，另 一 个 指 明 队 首 _ 元 素 的 位 置。53、在 一 个 用 数 组 实 现 的 队 列 类 中，假 定 数 组 长 度 为 MS,队 首 元 素 位 置 为 first,队 列 长 度 为 length,则 插 入 个 新 元 素 的 位 置 为 _(f irst+length)M S。54、在 一 个 用 数 组 实 现 的 队 列 类 中，假 定 数 组 长 度 为 MS,队 首 元 素 位 置 为 first,队

38、 列 长 度 为 length,则 删 除 一 个 元 素 后 队 首 的 位 置 为 一(f i r s t+l)M S。55、定 义 类 动 态 对 象 数 组 时，其 元 素 只 能 靠 自 动 调 用 该 类 的 无 参 构 造 函 数 来 进 行 初 始 化。56、为 了 释 放 类 对 象 中 指 针 成 员 所 指 向 的 动 态 存 储 空 间，则 需 要 为 该 类 定 义 _ 析 构 函 数 o57、假 定 AB为 一 个 类，则 执 行“AB 语 句 时,系 统 自 动 调 用 该 类 构 造 函 数 的 次 数 为 1058、假 定 一 吊 羹 对 象 数 组 为 AN

39、,当 离 开 它 的 作 用 域 时，系 统 自 动 调 用 该 类 析 构 函 数 的 次 数 为 一 N o60、假 定 指 针 p 指 向 一 个 动 态 分 配 的 类 对 象，则 当 执 行“delete p;语 句 时，在 释 放 p 所 指 向 的 动 态 存 储 空 间 之 前 将 自 动 调 用 该 类 的 析 构 函 数 61、假 定 AB为 一 个 类，该 类 中 含 有 一 个 指 向 动 态 数 组 空 间 的 指 针 成 员 pa,则 在 该 类 的 析 构 函 数 中 应 该 包 含 仃-条 _ delelepa;语 句。三、程 序 填 空 题：1、采 用 指 针

40、 访 问 方 式 从 键 盘 给 数 组 aN输 入 数 据，然 后 对 元 素 值 重 新 按 逆 序 存 放 并 输 出。include const int N=8;void mainO(int aN,*p,*q;for(p=a;pa+N;p+)cin*p;p=a;q=a+N-l;while(pq)int r=*p;*p=*q;*q=r;p+；q+；)for(p=a;pa+N;p+)cout*p，;coutendl;1、(1)cin*p(2)p+(或+p)(3)q(或 一 q)2、假 定 有 定 义 为 struct NODEint data;NODE*n e x t 下 面 算 法 根

41、据 table数 组 中 的 n 个 元 素 建 立 一 个 表 头 指 针 为 L 的 链 表，链 表 中 结 点 值 的 顺 序 与 数 组 元 素 值 的 顺 序 正 好 相 反。void f6(N0DE*&L,int tabled,int n)L=NULL;if(ndata=_(2)_;p-next=L;一(3);i+；)2、(1)in(2)tablei(3)L=p3、已 知 一 维 数 组 类 ARRAY的 定 义 如 下，构 造 函 数 的 作 用 是 把 参 数 n 的 值 赋 给 s,给 v动 态 分 配 长 度 为 n 的 数 组 空 间，接 着 利 用 数 组 参 数 a初

42、 始 化 v所 指 向 的 数 组。class ARRAYint*v;指 向 存 放 数 组 数 据 的 空 间 int s;数 组 大 小 public:ARRAY(int a,int n);ARRAY()delete Jv;int size()return s;int&operator(int n);)；_ ARRAY(int a,int n)Fif(n=0)v=NULL;s=0;return;s=n;v=_(2)_;for(int i=0;in;i+)_(3)_;3、(1)ARRAY:(2)new intn(3)vi=ai4、下 面 是 一 维 数 组 类 ARRAY的 定 义，ARRA

43、Y与 普 通 一 维 数 组 区 别 是：（a）用（）而 不 是 进 行 下 标 访 问，（2）下 标 从 1而 不 是 从 0 开 始，（c）要 对 下 标 是 否 越 界 进 行 检 查。class int*v;指 向 存 放 数 组 数 据 的 空 间 int s;数 组 大 小 public:ARRAY(int a,int n);ARRAY()delete v;int size()return s;int&operator()(int n);_(1)_ operator()(int n)7()辰 算 符 函 数 定 义 if(_(2)_)cerrX”下 标 越 界！；exit(l);)

44、return _(3)_;)4、(1)int&ARRAY:(2)ns(3)vn-l(或*(v+nT)5、已 知 一 个 类 的 定 义 如 下：#includeclass AA int a10;int n;public:void SetA(int aa,int nn);用 数 组 aa初 始 化 数 据 成 员 a,用 nn初 始 化 数 据 成 员 nint MaxA();从 数 组 a 中 前 n个 元 素 中 查 找 最 大 值 void SortA();采 用 选 择 排 序 的 方 法 对 数 组 a 中 前 n 个 元 素 进 行 从 小 到 大 排 序 void InsertAO

45、;采 用 插 入 排 序 的 方 法 对 数 组 a 中 前 n 个 元 素 进 行 从 小 到 大 排 序 void PrintAO;依 次 输 出 数 组 a 中 的 前 n 个 元 素 该 类 中 MaxA()函 数 的 实 现 如 下，请 在 标 号 位 置 补 充 适 当 的 内 容。int_(1)(int x=a0;for(int i=l;ix)_(2)_;一(3);)5(1)AA:MaxA()(2)x=ai(3)return x6、已 知 一 个 类 的 定 义 如 下：#includeclass AA int a10;int n;public:void SetA(int aa,

46、int nn);用 数 组 a a初 始 化 数 据 成 员 a,用 nn初 始 化 数 据 成 员 nint MaxA();从 数 组 a 中 前 n个 元 素 中 查 找 最 大 值 void SortAO;采 用 选 择 排 序 的 方 法 对 数 组 a 中 前 n个 元 素 进 行 从 小 到 大 排 序 void InsertAO;采 用 插 入 排 序 的 方 法 对 数 组 a 中 前 n 个 元 素 进 行 从 小 到 大 排 序 void PrintAO;依 次 输 出 数 组 a 中 的 前 n个 元 素 void AA:SortAO(int i,j;for(i=0;_(

47、1)_;i+)int x=ai,k=i;for(j=i+l;jn;j+)if(ajx)_ _(2)ak=ai;一 一)6、(1)in-l(或 i=n-2)(b)x=aj;k=j;(c)ai=x7、已 知 一 个 类 的 定 义 如 下：#includeclass A A int a10;int n;public:void SetA(int aa,int nn);用 数 组 a a初 始 化 数 据 成 员 a,用 nn初 始 化 数 据 成 员 nint MaxA();从 数 组 a 中 前 n个 元 素 中 查 找 最 大 值 void SortAO；采 用 选 择 排 序 的 方 法 对

48、数 组 a 中 前 n个 元 素 进 行 从 小 到 大 排 序 void InsertAO;采 用 插 入 排 序 的 方 法 对 数 组 a 中 前 n 个 元 素 进 行 从 小 到 大 排 序 void PrintAO；依 次 输 出 数 组 a 中 的 前 n个 元 素 void _(1)int i,j;for(i=l;i=0;j)if(xaj)(2)_else _(3)_;aj+l=x;)7、(1)AA:InsertA()(2)aj+l=aj(3)break8、已 知 一 个 类 的 定 义 如 下：#includeclass AA int a10;int n;public:voi

49、d SetA(int aa,int nn);用 数 组 aa初 始 化 数 据 成 员 a,用 nn初 始 化 数 据 成 员 nint MaxA();从 数 组 a 中 前 n 个 元 素 中 查 找 最 大 值 void SortAO;采 用 选 择 排 序 的 方 法 对 数 组 a 中 前 n 个 元 素 进 行 从 小 到 大 排 序 void InsertA();采 用 插 入 排 序 的 方 法 对 数 组 a 中 前 n 个 元 素 进 行 从 小 到 大 排 序 void PrintAO;依 次 输 出 数 组 a 中 的 前 n 个 元 素 最 后 输 出 一 个 换 行)

50、：使 用 该 类 的 主 函 数 如 下：void main()(int a10=23,78,46,55,62,76,90,25,38,42;AA x;,一 int m=_(2)_;一 coutmendl;)该 程 序 运 行 结 果 为：23 78 46 55 62 76788、(1)x.SetA(a,6)(2)x.MaxA()(3)x.PrintA()9、已 知 一 个 类 的 定 义 如 下：#includeclass AA int a10;int n;public:void SetA(int aa,int nn);用 数 组 aa初 始 化 数 据 成 员 a,用 nn初 始 化 数