无忧答案网

搜索

东农18秋《面向对象程序设计》离线作业

[复制链接]
作业帮 发表于 2018-11-18 14:51:32 | 显示全部楼层 |阅读模式
作业帮
2018-11-18 14:51:32 167 0 看全部
扫码加无忧答案客服
东北农业大学网络教育学院) l  e+ {; \2 m& [! b& ?4 \
面向对象程序设计网上作业题& L, Y0 [  m0 `7 Z
第一章 C++语言概述" v/ q" G* j6 |0 Q' b9 ~
单项选择题:# v) R8 F* [: x. U# |/ K5 v6 V$ H
1.下列说法中正确的是(  )。 * p( f+ [4 Y7 C  _$ E! {7 I% c, J0 @
A.a=10不是一个语句                B.常量标识符必需用大写字母表示; G: r: a  H0 g* H7 g
C.符号常量的值是可以重新赋值的     D.所有的变量在未赋初值时都有固定的值08 e. L4 V4 q  b  t. s) X3 k: R$ K" P
2.每个指令都是由二进制代码组成的只有计算机能读懂的语言是(  )。, e7 E9 ^; ?1 ]( O5 ~
A.机器语言     B.汇编语言     C.高级语言     D.自然语言. v; v8 o0 @$ @  P; e2 @  n: W
3.用人们比较熟悉的符号来代替指令编码的计算机语言是(  )。
4 q2 ~! A" z" |9 {8 B  p% D4 @A.机器语言      B.汇编语言     C.高级语言     D.自然语言
1 n( m/ I4 `0 _' g* @9 C  T) B6 F4.能够把高级语言写出的程序翻译为机器语言的指令序列的是(  )。
  V; c+ l& x/ e1 |A.可执行程序     B.编译程序     C.解释程序    D.系统程序% m0 \' o) c  w: H  V2 a6 k
5.汇编语言和机器语言都属于(  )。( z8 I9 t4 N7 U3 _1 G8 v
A.高级语言      B.中级语言     C.低级语言     D.自然语言) p. b, g7 j4 i: J
6.体现结构程序设计思想的代表语言是(  )。  I3 |6 k+ y: @, e' w9 y
A.COBOL语言      B.C++语言      C.C语言      D.BASIC语言- n" r" z3 u* k* e
7.体现面向对象程序设计思想的代表语言是(  )。
  t6 V% M! ]" n# I3 cA.COBOL语言      B.C++语言      C.C语言      D.BASIC语言
. Q& S# Z* e6 t& j! j8.用计算机解决问题的方法和步骤通常称为(  )。
; \* `& b$ s6 A( VA.程序       B.程序设计       C.程序设计语言      D.算法
0 y( n2 P4 r% P0 ^8 ]; @9.C++语言程序中其右侧的所有符号都为注释的符号是(  )。! F. J5 v0 D6 U6 |7 [- g# }. ~
A. **      B. &&        C. ##        D. //+ h  J# u6 t+ L& M7 L
10.在一个C++程序中,main所代表的意义是(  )。
' ~3 k! t- N+ ?1 EA.变量名称      B.主函数     C.符号常量     D.注释
3 c' K2 d& P; w8 P& R7 Y11.在一个C++程序中,void main()一行中的void所代表的意义是(  )。, r7 {( K. d/ e
A.无返回值     B.主函数      C.程序开始     D.注释
, h- {" @$ e: P1 x; N7 M12.在C++程序中,用来做为函数体开始结束标志的一对符号是(  )。0 z$ c; z) u- e, G$ `5 o
A.[]      B.{}       C.<>       D.()
5 o* M  G; T7 _8 K2 _13.在C++程序中,用来做为数组下标开始结束标志的一对符号是(  )。1 j* I! h9 Z2 J
A.[]       B.{}       C.<>       D.()7 j' L& B# _: F  P" d
14.在C++程序中,用来做为函数参数开始结束标志的一对符号是(  )。6 C; ?- {4 M; E( k* M' Z
A.[]       B.{}       C.<>       D.()/ ]- E. w* a( b/ c  \
15.C++中表示标准输入的标识符是(  )。4 Y/ P2 G% a* _
A.input      B.scan      C.cin      D.get
8 {3 _0 D+ I. \9 @% l) @& \16.C++中表示标准输出的标识符是(  )。
+ C4 c( x4 t4 A& @# U7 M0 zA.output      B.print     C.put     D.cout' }9 z: O, L3 ~/ h$ a
17.在C++的标准输出语句中使用的插入运算符是(  )。/ B0 K; D4 [1 i( L
A.<<       B.>>      C.**      D.//
9 P3 g) F, |- f# k- S18.在C++的标准输入语句中使用的提取运算符是(  )。8 G7 \: `3 e6 \; ?/ D6 R: e3 T' d
A.<<      B.>>      C.**      D.//# B+ B9 T# x, \) k$ S" P+ u
19.在C++中包含cin和cout这两个标识符说明的头文件是(  )。
3 @# l$ W% L% n8 MA.io.h      B.stdio.h     C.iostream.h     D.inout.h) i4 |* F& l, Q7 B8 C5 j
20.在C++中包含printf()和scanf()这两个函数说明的头文件是(  )。
7 z% ?; b; W' A4 \A.io.h     B.stdio.h  C.iostream.h  D.inout.h8 {6 k' ]) J/ r% t! O
21.C++程序预处理命令的开始字符是(  )。(﹡*); z3 x2 ]2 b1 h# ^
A.*      B./      C.&      D.#
2 J, I1 \) w, `+ r' ]! U22.下列说法正确的是(  )。5 B- d4 c' e& ^! j; e. n! D
A.C++程序是从主函数开始执行的     B.C++程序中一定要定义变量
7 _7 E/ |5 d2 y. e* aC.C++程序中一定要有输入           D.C++程序中可以从用户定义的函数开始执行
  f. D0 N+ |2 {. o% j23.下列说法正确的是(  )。
/ S+ j  f7 G# D. z" a& {! SA.C++程序是不是从主函数开始执行的           B.C++程序中一定要定义变量6 I# E, j( S& x
C.C++程序中不可以从用户定义的函数开始执行   D.C++程序中一定要有用户乍定义的函数才能执行
. q( j; p2 O) d5 S, R! @8 H24.下列数据类型中属于基本类型的是(  )。( [% t  i" Q6 {) z2 S& O
A.long int       B.long float      C.unsigned int      D.void( j0 z# f% \% A
25.下列数据类型中属于派生类型的是(  )。1 `  O6 g- E: b6 Y
A.int       B.float      C.char      D.double
" d0 B2 n1 P; L26.C++程序中用来说明常量的关键字是(  )。: {& a, i) j+ U, D# m' v8 P: ~' g
A.const    B.enum      C.char        D.cout6 d# T5 Q' `9 d0 G
27.C++程序中用来包含头文件的关键字是(  )。
/ ?& U& S9 s2 p& nA.input     B.enum       C.include     D.cout! b9 n+ z2 A7 r" ?" l- n8 M$ J! u
28.C++程序中用来说明某一变量为静态变量的关键字是(  )。3 s; j# x- {5 y/ s$ [  R8 {
A.define       B.enum       C.extern   D.static! }% S% ?* X% j/ ?: h# s
29.C++程序中用来说明某一变量为外部变量的关键字是(  )。
- f" t% C) x. N- V% `2 Q7 }7 _A.extern      B.enum          C.output     D.static0 G/ L& z3 D: {6 x5 w$ [
30.下列C++程序中变量定义的语句中,正确的是(  )。
1 d9 _3 _0 D2 w$ ?A.int a;b;        B.int a,b;      C.a,b:int;      D.int a,b
1 b8 L. b7 Q4 H- t& M0 J, @31.下列C++程序中数组定义的语句中,正确的是(  )。- R+ A' l7 X# A0 E& v
A.int a[0..10];      B.int a(10);    C.int a[10];     D.int a<10>;- {& ^& i. v4 h, Z, j1 R, c
32.下列程序main(){printf("%d",null);} 输出结果是(  )。
) i7 h5 {* \5 `% J- z  lA.0   B.变量无定义    C.-1    D.1
4 ?$ Q, u" J* Y! D7 Z  Q% t" a% m% B33.以下数据中,不正确的数值或字符常量是(   )。3 b; L1 d" [4 ~+ S+ l+ F$ q: u
A.011      B.3.987E-2     C.018  D.0xabcdg
4 _; u! ^8 F! C, m! J* O% l34.假设所有变量均为整型,表达式(a=2,b=5,a>b?a++:b++,a+b)的值是(   ) 。5 z# b& b( c  h+ K( i3 S+ E
A.7   B.8   C.9   D.2
6 L! Q6 o: z( P6 |1 d: E35.在C语言中,能代表逻辑值"真"的是(       )。( k' ?1 g+ S  ?
A.true    B.大于0的数    C.非0整数    D.非0的数
: x; u2 t" Q- F1 U( j36.以下程序4 r+ t9 ^+ ^! [2 P! i
main(): z/ z9 s4 A5 ~, Z) z( R
{int i,j,k,a=3,b=2; i=(--a==b++)?--a:++b; j=a++;k=b; printf("i=%d,j=%d, k=%d\n",i,j,k); }
7 U+ T+ U' N, p输出结果是(      )。0 F& x6 S/ B2 |& q4 Q
A.i=2,j=1,k=3      B.i=1,j=1,k=2     C.i=4,j=2,k=4      D.i=1,j=1,k=3
, [2 D  w8 ?% {7 |37.将用高级语言编写的源程序转换成目标程序的是(      )。! ]) m1 @$ U/ ~) W2 v
A.连接程序    B.汇编程序    C.编译程序     D.可执行程序
" J; S( h: T' O; _" s$ \3 {38.程序设计语言可以分为机器语言、汇编语言和(      )。/ l1 q, m' t& x; N7 Z8 ~$ L; n
A.ALGOL语言     B.FORTRAN语言      C.C++语言        D.高级语言
8 Q- K1 ^) Z* @9 `1 [% n39.C++对C语言作了很多改进,即从面向过程变成为面向对象的主要原因是(  )。
0 M% T  `! ]" G7 V$ oA.增加了一些新的运算符       B.允许函数重载,并允许设置缺省参数
. z# J& }8 u; i$ N. V/ P# @9 KC.规定函数说明符必须用原型   D.引进了类和对象的概念
( |6 c% X' X3 L; x" a40.一个C++程序至少包含的函数个数为(      )。
, _7 ]8 s- x8 l; L5 eA.0    B.1    C.2    D.3  w8 C& r# W  t  D" I6 f9 }+ y
41.以下标识符中,不能作为合法的C++用户定义标识符的是(       ). f0 P, J" a! L$ h
A.For     B.Printf     C.WORD     D.sizeof
" a/ H0 w4 h8 v9 X: j% c$ h42.下列符号不能组成标识符的是(    )。! k8 ~2 m8 [! E! H, z6 o
A.连接符                B.下划线   C.大小写字母      D.数字字符
& z! T, P+ u  `3 e/ m5 ^  j43.在下列符号中,不是分隔符的是(      )。5 n: W4 U' \: F) T
A.[]    B.//    C.()     D.{}3 [$ z3 d; f* T; A, \
44.下列标识符中,不合法的用户标识符为(      )。
2 x5 S0 j) P$ z- ]A.a#b    B._int    C.a_10    D.PAd
( x* M  e  s/ I# G: M$ i45.由C++目标文件连接而成的可执行文件的缺省扩展名为(      )。" X2 w+ W4 x( Y7 M* v! T
A.cpp       B.exe       C.obj       D.lik  i* v9 D1 j6 J8 z! |1 Z
46.无符号基本整型数据的取值范围是(  )。7 ]; l. @1 w& b; m! X  u. \
A.-127至128       B.0至65535     C.-32768至32767      D.0至65536" H$ c) Y+ H, w  {
47.字符型数据的取值范围是(  )。
2 q, h# p% ]$ q* a& k: rA.-127至128      B.-32767至32768      C.-128至127  D.32768至32767* x8 |, R6 j, l) f" g
48.无符号字符型数据的取值范围是(  )。* N$ U* \1 n: n
A.0至128      B.0至256      C.0至65535     D.0至255- _+ l2 t* f1 x8 N9 s; c& A
49.下列表示空类型的关键字是(  )。4 O5 Q9 i: [4 I4 ]
A.char     B.void      C.space  D.include
" w' J+ M1 g* O- u' v2 G50.用来表示水平制表的字符常量是(  )。
! @# E4 S, d6 |' X  B7 N3 ]% H& LA.'\t'  B.'\b'  C.'\n'  D.'\f'  # c0 Y8 i( L+ U5 q$ @( F& h
51.类型修饰符unsigned不能修饰(      )。: w+ o, j8 u9 \) D% F1 h
A. char    B. int   C. long int  D. float
) y; Y. b& H% k$ {52.在微型机上,一个unsigned int型变量在内存中所占的字节数是(      )。
7 @5 R% _2 f2 b% Z6 {+ oA.1    B.2    C.3    D.4
% y* t) q8 a& T53.在微型机上,一个char型变量在内存中所占的字节数是(     )。; G( m# w5 W* `3 ?5 R
A.1    B.2    C.3    D.4
4 I  `4 C* X/ B+ j54.在微型机上,一个float型变量在内存中所占的字节数是(      )。
/ Q" l( s) \, ?+ v. w0 L7 ~- h6 p$ bA.1    B.2    C.3    D.4
/ r* [% X3 x7 W/ T55.在定义变量时省略存储类的说明,则系统按哪个存储类处理(  )。
! h- [0 u3 k7 E# {. S7 w3 AA.auto  B.register  C.static  D.extern+ c6 S2 d% J, f* I' o+ ?% q* [
56.下列语句中是常量定义的语句是(  )。7 e2 p+ k% X* o
A.#define PI 3.14159265   B.double a=3.14159265;   C.const PI=3.14159265;    D.a=3.14159265;4 M" E: z% s8 ~, o, P
57.下列数据属于八进制整型常量的是(  )。
( H  C  r* @! a! G1 IA.01.2      B.123     C.0123     D.X1234 R- X8 J- H/ M/ J; S' _( N
58.下列数据属于十六进制整型常量的是(  )。
3 \3 y1 j: ~4 ?& _3 q/ CA.01.2     B.123      C.0123     D.0X123
# |7 @1 p% W# b4 }1 O" j1 r59.下面不正确的字符串常量是(      )。- x: Q; V! m( w
A.'abc' B."12'12"  C."0"    D." "
6 a# A$ N+ T9 w% h( ~; n- v60.设有整型变量x和指针变量p,已知p的值为a的地址,则表达式*p==a的值是(  )
# ]+ W% F# E/ w0 u5 ]7 hA.0  B.1  C.2  D.3
2 n# x3 p: j' q, H# F" X# v61.设有整型变量x和指针变量p,则要使指针p指向变量a的表达式是(  )
+ p5 H% h, L" \' e. w% T- K4 X2 ~A.p=&a  B.p=&a;  C.*p=a  D.*a=p
6 r: l( c' g+ I62.下列运算符中表示逻辑非运算的是(  ) 7 t4 I1 ?( C& u4 P/ ]
A.&  B.|  C.!  D.*
. r  d% T1 k* X2 |63.下列运算符中表示逻辑与运算的是(  ) 8 S4 U: A4 [4 Y" n2 y) U- G3 l6 }
A.&&  B.||  C.!!  D.**
. S3 N1 p' y8 i% a7 E64.下列运算符中表示逻辑或运算的是(  ) & O  i, G) _: u. d* F, C  R
A.&&  B.||  C.!!  D.**- ^* e" u8 d1 l' n1 {/ e
65.下列运算符中是关系运算符的是(  ) 1 h. A: _/ }3 I
A.&&  B.||  C.!!  D.==
" o3 c* C4 F6 u7 G2 f% j/ V8 v66.下列运算符中是算术运算符的是(  )
  c% U6 S8 z! V% x( m$ GA.&&  B.++  C.!!  D.==# }4 H9 }$ ]& p2 ~- p% Y& m
67.下列运算符中表示释放指针所指内存单元的是(  )
- L1 h. G: U' R, J4 G; eA.sizeof  B.new  C.delete  D.break;3 o9 z/ B$ a% U2 b! k# Y0 W
68.下列运算符中表示为某指针申请内存单元的是(  ) 6 N# N1 T' L# u8 R
A.sizeof  B.new  C.delete  D.break;
0 b: t$ ^, [- q$ ?' |69.下列运算符中功能为字长提取符的是(  ) $ t5 G: o4 S0 {0 F5 k/ b
A.sizeof  B.new  C.delete  D.break;) {' A( h$ b% h7 I- x& x
70.为表示关系x>=y>=z,应使用C语言表达式(       )
( T/ M, c9 c4 rA.(x>=y)&&(y>=z)      B.(x>=y)AND(y>=z)    C.(x>=y>=z)           D.(x>=y)&(y>=z)" v# g& }+ g( s- a; I
71.若要求在if后一对圆括号中表示a不等于0的关系, 则能正确表示这一关系的表达式为(       )
2 `" l  I* ?, \9 j& F5 PA.a<>0    B.! a    C.a=0    D.a- X" r5 a6 T' t" j6 L9 j* H
72.C++语言中最简单的数据类型包括(     )5 S  _  P4 ?% n7 N5 N+ _
A.整型、实型、逻辑型       B.整型、实型、字符型
' o) {; p2 G9 m& XC.整型、字符型、逻辑型     D.整型、实型、逻辑型、字符型6 h0 ^" }, x8 Z  U) u* ~- T: ^" E$ N
73.C++语言中,运作对象必须是整型数的运算符是(     )
2 ~$ x5 ~4 R' E1 h! l+ G) R+ q) |A.%     B.\     C)%和\      D.* *, `- X3 _( Y9 a+ E$ K8 a* E
74.设a=12,n=5,则表达式a%=(n%=2)运算后,a的值为(      )。
( @; ~) t6 R, h0 a! q- Y2 b1 [. S1 {A.0    B.1    C.6    D.12
! g8 a5 a6 e. |8 R0 p9 @7 _75.条件运算符是(  ) $ Y4 V' I6 c7 T
A.?:    B.:?    C./:   D.:/
2 ?0 n9 o  C- ]+ g2 l* c8 A76.地址运算符是(  ) & ?' u- v6 j, g7 [+ V( }
A.*    B.:    C.&   D.#
4 m# D) `3 V; M1 }* J) m77.设a=3,b=2,c=l,则表达式a=b>c的值为(      )。
  x* r2 Q, d7 ^" j; MA.0    B.1    C.2    D.3" M$ i+ t: |: r% L1 m# c5 H0 j. F
78.以下程序段 int a=10; printf("%d\n",-a,); 输出结果是(       )
, n( S7 t3 X3 qA.01    B.-11    C.-10    D.-5
  X9 A1 d2 A) V* C79.当a=1,b=2,c=3时,执行以下if语句a,b,c各为(      )。) v5 g! @, R# u) g2 R
if(a>c);b=a;a=c;c=b;7 w9 \7 ]- T. C) a6 L
A.a=1 b=2 c=3    B.a=2 b=3 c=1    C.a=3 b=1 c=1    D.a=3 b=1 c=2
1 \) e; _8 ]# p3 m1 |6 M80.下面关于条件语句的叙述中,错误的是(      )。
  w6 N+ m8 d( K7 f, ZA.if语句只有一个else语句            B.if语句中可以有多个else if语句
2 N6 E0 p/ t0 o% H& ^3 C  x  qC.if语句中if体内不能是switch语句   D.if语句的if体中可以是循环语句
6 M/ Q5 ~  t/ u& k81.以下程序段的输出结果是(       ) int x=3; do { printf("%3d",x-=2); } while(!(--x));           
# o4 M0 b# ~4 o) D, g0 A' f; ^! EA.1      B.30     C.1 -2     D.死循环
' p  y# }! [( V2 t6 }, v& T' }82.下述语句
. |/ R: K' w4 D0 U5 dint k=10;
6 T6 s  P- g7 a7 ]& P, G3 \while(k=0)k=k-1;
, T3 V4 }$ j. W: |$ ~, B则下面描述正确的是(      )。5 `* O, H1 z1 k- W
A.while循环执行10次         B.循环是无限循环& f, M$ P$ }8 `% z$ ]$ f
C.循环体语句一次也不执行     D.循环体语句执行一次
0 ~8 ^9 L. O8 @+ b) x# `5 ]83.语句while(!E);中的表达式!E等价于(      )。, w2 }! J: x% R! `0 h: c+ ?
A.E==0    B.E!=1    C.E!=0    D.E==1
5 A- K- q! q' S) J4 X  V2 i84.在C++语言程序中跳出循环结构的语句是(  )。( r' O" C' h5 P& x
A.continue;  B.break;  C.return;  D.goto;$ G" n. e; n5 s7 v2 Q4 Z( r
85.在C++语言程序的继续语句是(  ) 5 S4 L, J+ x4 I
A.continue;  B.break;  C.return;  D.goto;9 A" ~: X6 `: {% k; A( }5 X
86.在C++语言程序的返回语句是(  ) 4 P! Q0 L2 [/ g0 U
A.continue;  B.break;  C.return;  D.goto;
8 _' Q0 B# J2 B" `87.在C++语言程序的转向语句是(  )
! _0 \8 n. F# ]A.continue;  B.break;  C.return;  D.goto;
% K0 ^* m* j" D! M( T% E5 k6 S88.设有数组定义语句int a[10];则a[5]是数组中的第几个元素(  ) ) u5 U4 h5 J  c$ V# V
A.3  B.4  C.5  D.6
" ^& g( c7 N+ ?6 z+ B89.设有数组定义语句int a[10];则a[1]是数组中的第几个元素(  )
! I8 ^3 \: E! M) x$ x8 ^A.1  B.2  C.3  D.46 x/ ?" \+ R( q9 n: x- G
90.设有数组定义语句int a[2][2];则a[1][1]是数组中的第几个元素(  )
: c" a! a6 K1 K% P& s! yA.1  B.2  C.3  D.4
6 l/ I( f9 c" K0 L# [1 [9 A91.设有数组定义语句int a[2][2],p=2;则为数组a第3个元素赋值为5的语句是(  )
5 [' o6 \0 q4 J" a& W+ l/ Q8 b' IA.a[p-1][0]=p;  B.a[1][p-2]=p+3;   C.a[3]=5;       D.a[p+1]=p+3;4 k$ `! U8 Z" C/ l7 V3 B+ K
92.下面程序 int aa[3][3]={2},{4},{6}}; main() { int i,* p=&aa[0][0]; for(i=0;i<2;i++) {if(i==0) aa[i][i+1]= * p+1; else ++p; printf("%d",* p+1);} } 输出结果是(       )  
% b& D  p) q& ~! }! MA.23     B.26     C.33     D.36
! X1 n' @$ O8 a, d93.在下面的一维数组定义中,有语法错误的是(      )。  ^9 W5 x1 ]/ ?2 c
A.int a[]={1,2,3}; B.int a[10]={0};  C.int a[]; D.int a[5];
- d% j4 b* }# B  v94.在下面的函数声明中,存在着语法错误的是(      )。# O! T& l. d' F4 E3 ]1 Q9 T
A.void BC(int a, int);          B.void BD(int, int);
. V4 P+ I5 ?1 MC.void BE(int, int=5);          D.int BF(int x; int y);
' ?" q3 z3 X. k4 Q95.C++语言程序中,当调用函数时(    )
9 [, X7 d+ V& F! J6 ~  \6 A0 jA.实参和虚参各占一个独立的存储单元     B.实参和虚参可以共用存储单元6 H! r8 e4 }/ F- |3 r0 c- }8 |
C.可以由用户指定是否共用存储单元       D.由计算机系统自动确定是否共用存储单元 0 p! V2 k. ~% ]; k( G
96.在int a=3,int *p=&a;中,*p的值是(    )。
+ S" ~1 f$ `, U3 @/ f( Y0 zA.变量a的地址值        B.无意义  C.变量p的地址值  D.3- b5 E9 v5 F+ _2 Y& N) G6 g
97.C++语言程序中取某地址中的值的运算符是(    )。
5 |2 I# c. {7 ^6 S, s. k' y) PA.#  B.&  C.*  D.%
( K, b4 u# r1 @5 n4 g6 w98.C++语言程序中取某变量地址的运算符是(  ) 5 S6 |6 }& S) ?' f" [7 {! l
A.#  B.&  C.*  D.%
/ y+ B/ L  k6 {' T; m# n6 U0 o99.已知函数fread的调用形式为fread(buffer, size, count, fp), 其中buffer代表的是(   )
- s) R7 W$ w6 R# U0 q3 g: w' I. mA.存放读入数据项的存储区                   B.一个指向所读文件的文件指针
+ [& z: X% A' LC.存放读入数据的地址或指向此地址的指针     D.一个整型变量,代表要读入的数据项总数
& h7 e0 ^; F6 ^$ q" f7 C100.下列(    )的调用方式是引用调用。" `3 _# r5 _2 W& F0 g
A. 形参和实参都是变量                          B.形参是指针,实参是地址值0 v: `2 b$ q) r  y4 u" d7 w6 e% \6 y
C. 形参是引用,实参是变量                      D.形参是变量,实参是地址值
( B$ S) o1 \$ E) M3 H' Z) w. c' Q101.C++源程序文件的缺省扩展名为(    )。) f* Y- {4 K4 q' Q( X) b- `
A. cpp              B. exe                C. obj                 D. lik
' I. X6 H% t5 T9 E8 ^102.由C++源程序文件编译而成的目标文件的缺省扩展名为(    )。5 w; q4 }' ]4 N- p1 \/ P
A. cpp                  B. exe                C. obj                 D. lik
+ a; z. ~: j0 L103.由C++目标文件连接而成的可执行文件的缺省扩展名为(    )。
& k4 V# W9 R$ ?% A+ u! \. ZA. cpp            B. exe                C. obj                 D. lik, H0 ?+ ^5 X( l: ]8 D5 y0 o
104.编写C++程序一般需经过的几个步骤依次是(      )。
- i, G5 h) N; O" y& f/ @, YA. 编译、编辑、连接、调试             B. 编辑、编译、连接、调试- P  v$ ?9 L7 L1 b" n1 Q! S6 N9 n
C. 编译、调试、编辑、连接             D. 编辑、调试、编辑、连接9 R! [) P% y: a
105.以下标识符中不全是保留字的是(    )。, {7 P7 g. k5 ]  J7 S
A. case    for    int               B. default  then   while
% T# m1 d$ G' t/ v2 V. iC. bool    class   long             D. goto   return  char
& V0 r7 ^, D9 X2 E7 _106.能作为C++程序的基本单位是(    )。! c6 F; A1 K4 D
A. 字符            B. 语句                C. 函数     D. 源程序文件$ V; n0 c4 R- t- N  L
107.程序中主函数的名字为(    )。$ X, `) ^+ L, g/ J
A. main            B. MAIN                C. Main   D. 任意标识符
- W2 r6 B4 }9 n108.C++程序的基本模块为(    )。
7 O" W+ e7 e( KA. 表达式           B. 标识符                C. 语句          D. 函数
0 v) N$ Z$ ~) _0 w# J109.可用作C++语言用户标识符的一组标识符是(    )。
! b+ L* @, U8 A0 ]( o6 v* ^" g$ zA. void    define    +WORD        B. a3_b3    _123     YN6 S  X! M' x% H+ \0 o; ^2 j- I% L
C. for      -abc      Case          D. 2a      DO      sizeof
/ a% o1 o3 W1 ]6 m110.存储以下数据,占用存储字节最多的是(    )。$ m" a" d2 K" E  _$ J, |) u
A. 0            B. ‘0’        C. “0”             D. 0.05 @: ~6 p5 i5 k$ f$ ~; c* f
111.程序运行中需要从键盘上输入多于一个数据时,各数据之间应使用(    )符号作为分隔符。
1 W. e4 Q% b3 e7 BA. 空格或逗号            B. 逗号或回车                C. 逗号或分号          D. 空格或回车
; V$ L# [8 e* [1 x5 l4 H. i. @112.设”int a=12;”,则执行完语句”a+=a*a;”后,a的值是(    )。2 ^5 i% b& T" e' Q3 I
A. 12                      B. 144                        C. 156                    D. 288# M( K" P$ t! ^- j. S7 l) c
113.假设在程序中 a、b、c 均被定义成整型,所赋的值都大于1,则下列能正确表示代数式的表达式是(    )。   
9 O1 G6 r+ V# K( h2 K9 ]A. 1.0/a*b*c            B. 1/(a*b*c)      C. 1/a/b/(float)c    D. 1.0/a/b/c  J! R$ r4 i3 m/ t8 l
114.设”int a=15,b=26;”,则”cout<<(a,b);”的输出结果是(    )。
. m) X( d+ v- s& wA. 15            B. 26,15        C. 15,26             D. 26
& i3 K8 ^% a, r0 x% I& \115.设x是一个bool型的逻辑量,y的值为10,则表达式 x && y的值为(    )。+ M6 a, L" b& r; d5 B% E! _" o* ?
A. 1              B. 0        C. 与x值相同             D. 与x值相反
3 e- y$ s- f. e) [2 }9 @7 l7 O) S. V116.x>0 && x<=10的相反表达式为(    )。
5 C1 V( j) Z2 [! z# [A. x<=0 || x>10            B. x<=0 && x>10     C. x<=0 || x<=10             D. x>0 && x>10
  X: l; z2 M; k; v% g( G6 W117.x>0 || y==5的相反表达式为(    )。; ~. {$ B3 C& Z; o2 B; }' a, X
A. x<=0 || y!=5           B. x<=0 && y!=5     C. x>0 || y!=5            D. x>0 && y==5% b; _6 R& t0 j. X2 N
118.设x和y均为bool量,则x && y为真的条件是(    )。
/ J8 [* q' T2 T7 ?) w5 @A. 它们均为真           B. 其中一个为真   C. 它们均为假           D. 其中一个为假! W( e! O1 p' w& R/ h- B
119.设x和y均为bool量,则x || y为假的条件是(    )。0 ?7 z2 k8 A' k! r. s- m
A. 它们均为真           B. 其中一个为真   C. 它们均为假     D. 其中一个为假) J1 n" {& z  \# j
120.字符串”a+b=12\n”的长度为(    )。
- w7 j. n5 f2 d# RA. 6           B. 7     C. 8            D. 9* E; Y% I! l; v( P, G$ Y3 k
121.假定下列x和y均为int型变量,则不正确的赋值为(    )。
5 s' M# `( @  b* Z; c" K- lA. x+=y++           B. x++=y++    C. x=++y             D. ++x=++y2 y8 ^' O3 d- f/ ~
122.下列的符号常量定义中,错误的定义是(    )。" [! K* Y* m& c( o! s9 s& G
A. const M=10;                                 B. const int M=20;$ i" {( K7 W, w
C. const char ch;                              D. const bool mark=true;
% ]. g. N/ c5 @8 Y123.循环语句“for(int i=0; i<n; i++) cout<<i*i<<’ ’;”中循环体执行的次数为(    )。/ Q8 u! g5 u. i( }3 t# E& x
A. 1            B. n-1      C. n             D. n+1; H4 L8 b7 I3 B3 N" R
124.在下面循环语句中循环体执行的次数为(    )。' L' p  {7 U9 Q( w
for(int i=0; i<n; i++)6 o6 l* l5 ^  T: O+ N4 L7 t
if(i>n/2) break;6 e& f2 ^+ w' z7 Z' B
A. n/2           B. n/2+1     C. n/2-1             D. n-1
, i5 D8 G1 \+ n: F( z, I% p125.在下面循环语句中内层循环体S语句的执行总次数为(    )。
. u, H( ]& h( f, Nfor(int i=0; i<n; i++)
1 n! g  k1 F9 N7 l8 `for(int j=i; j<n; j++) S;
1 e/ f6 X* L, f& q0 SA. n2              B. (n+1)/2     C. n(n-1)/2             D. n(n+1)/2( P  d6 L" o3 A5 {  @( q8 k4 Y5 E
126.在下面循环语句中循环体执行的次数为(    )。
8 r8 c3 q- _6 {1 m9 I+ e3 Sint i=0,s=0; while(s<20) {i++; s+=i;}& a) Q1 `3 \2 D& e5 c
A. 4            B. 5     C. 6            D. 7  B. S5 c" V  c$ m! N- r
127.在下面循环语句中循环体执行的次数为(    )。
: z8 o; W+ b9 q' K, J! a0 @int i=0; do i++; while(i*i<10);5 g9 z9 m1 X" y3 A3 b
A. 4            B. 3    C. 5              D. 2
, }7 _' t2 O" T$ R+ t128.当处理特定问题时的循环次数已知时,通常采用(    )来解决。
6 w$ P+ _1 U# Y* _8 G9 D) kA. for循环            B. while循环    C. do循环           D. switch语句
8 X& P$ n3 c9 A) [9 g2 z129.循环体至少被执行一次的语句为(    )。0 K1 W0 Z1 m" g8 W8 d( d! @, S
A. for循环           B. while循环    C. do循环            D. 任一种循环
. D+ t0 T. v1 I5 q$ D0 e2 l130.switch语句能够改写为(    )语句。
' m4 U% F; @0 w3 U6 z2 m( EA. for          B. if     C. do             D. while7 Z$ G" l; Q6 m! q
131.do语句能够改写为(    )语句。
  c3 p% o5 Q. t0 j) o$ iA. 复合                    B. if     C. switch             D. while
5 D7 c/ w" c8 q) ?3 }132.. 在下面的一维数组定义中,哪一个有语法错误。(    )/ |" s5 J+ p1 }2 X8 M
A. int a[]={1,2,3};            B. int a[10]={0};    C. int a[];           D. int a[5];; |$ e7 h9 |) H. P
133.在下面的字符数组定义中,哪一个有语法错误。(    )。
* Y' p. \5 d8 p) `A. char a[20]=”abcdefg”;              B. char a[]=”x+y=55.”;9 H) `2 W' X$ f" u" J7 S! }# c0 S* [
C. char a[15];                                D. char a[10]=’5’;2 a0 ?3 o8 m% Z
134.在下面的二维数组定义中,正确的是(    )。
7 s% m+ b: v  E) cA. int a[5][];          B. int a[][5];    C. int a[][3]={{1,3,5},{2}};            D. int a[](10);
. z7 r; v; n& C4 N% `% y4 N135.假定一个二维数组的定义语句为“int a[3][4]={{3,4},{2,8,6}};”,则元素a[1][2]的值为(    )。/ T1 t( H  [) H, W: q* Q) M. F- h3 f
A. 2              B. 4       C. 6              D. 8
9 @0 P$ U" _1 F* F0 B7 ?136.假定一个二维数组的定义语句为“int a[3][4]={{3,4},{2,8,6}};”,则元素a[2][1]的值为(    )。
  [# p! n2 V: V  n" a1 LA. 0              B. 4     C. 8              D. 64 t% l) b4 x) A  K5 f( ~; W) a
137.若定义了函数 double *function(), 则函数function的返回值为(    )。
% H0 ~  W  I* [( |% g  q; t- PA. 实数型            B.实数的地址    C.指向函数的指针            D.函数的地址  t3 F5 d: H2 z3 S8 k3 S2 o8 Z. P
138.以下说法中正确的是(    )。9 h. c- _& T' ^1 L! J) M
A. C++程序总是从第一个定义的函数开始执行
8 R$ x% W6 j* a2 cB. C++程序总是从main函数开始执行6 p  Y( i8 b9 l
C. C++函数必须有返回值,否则不能使用函数' u/ L0 L) |; l5 z
D. C++程序中有调用关系的所有函数必须放在同一个程序文件中
# T& R9 a- A) C5 d1 K% u139.以下叙述中不正确的是(    )。" }- X& H# |! _6 x/ w6 ?
A. 在一个函数中,可以有多条return语句
* Z+ ^. ^0 l$ ^: p4 Y+ t5 sB. 函数的定义不能嵌套,但函数的调用可以嵌套
. x& J6 ^2 y4 ~' K* UC. 函数必须有返回值
. C& S0 {, G  B0 _, ?$ ]3 bD. 不同的函数中可以使用相同名字的变量
0 x8 c% T" ^, U1 W3 G  N: s1 M, i8 ~140.函数重载是指(    )。4 G3 _, z. `" I# l
A. 两个或两个以上的函数取相同的函数名,但形参的个数或类型不同4 X) l$ C4 C% t/ o% M
B. 两个以上的函数取相同的名字和具有相同的参数个数,但形参的类型可以不同; E4 x  }" `6 F/ s) c
C. 两个以上的函数名字不同,但形参的个数或类型相同2 B, p- ^9 |0 ]3 ^
D. 两个以上的函数取相同的函数名,并且函数的返回类型相同  q, M: }4 ?$ O! ~3 v0 a: m# `  o
141.C++语言的编译系统对宏命令的处理是(    )。
2 I$ }$ x# W# O( y, @$ NA. 在程序运行时进行                    B. 在程序连接时进行
* W' Q$ E* A  P8 r# U- u' EC. 和C++程序的其它语句同时进行编译   D. 在对源程序中其它成分正式编译之前进行7 P, _5 K% k& F) o3 w( _; @
142.当#include后面的文件名用双引号括起来时,寻找被包含文件的方式是(    )。  b- F1 ~* i9 d# t' I9 `
A. 直接按系统设定的标准方式搜索目录
* e  S% a; u/ a" k, ~B. 先在源程序所在目录搜索,再按系统设定的标准方式搜索目录8 x2 n2 w  y7 h0 I, m
C. 仅仅搜索源程序所在目录9 \7 v' y/ r' P9 E5 g
D. 搜索当前逻辑盘上的所有目录
0 n0 C3 i' Q9 ~143.为了提高程序的运行速度,可将不太复杂的功能用函数实现,此函数应选择(    )。0 a5 A8 F6 `6 b1 E. z: C
A. 内联函数                  B.重载函数             C.递归函数                  D.函数模板9 _7 y: c8 k; L8 Y8 l: X( J2 B
144.函数原型语句正确的是(    )。; z0 E8 a1 D6 I! y
A. int Function(void a);          B.void Function (int);   C. int Function(a);          D.void int(double a);
) p; A! u3 W  Z145.C++中函数返回值的类型是由(    )决定的。$ f+ U& K& j4 n0 H# O1 K% W- Q& H( W
A. return语句中表达式的类型                   B.该函数定义时的类型
3 a; m- P. k7 u! I, y/ H+ q' e9 aC.调用函数时的调用语句                         D.系统根据结果
2 K( ~/ S1 P" E2 L4 O9 i146.以下函数的返回结果是(    )。
$ }4 G) ^! @, \int function(char *x) {. s% c+ h0 j& G+ R
char *p=x; while(*p++); return(p-x-1);
, b: l! z/ z1 `}
# p8 D& O, U8 ~: H4 b( n) XA. 求字符串的长度                       B.将字符串x连接到字符串p后面
: S7 |' k( k: g1 U" C7 Q+ Y9 KC. 将字符串x复制到字符串p中           D.将字符串x反向存放
. |- ]1 y+ i/ P147.函数调用func((exp1,exp2),(exp3,exp4,exp5))中所含实参的个数为(    )个。
' z# A2 i$ |8 U: Q) v5 y9 @A.  1             B.  2     C.  4             D.  5* W8 T) K1 V) Y2 a
148.设有如下函数定义6 m& |6 \( b! X3 Z& j
int f(char *s) {( r) X' a2 c; S
char *p=s;
  E4 M8 ^/ ~# g+ m* ?9 u2 S) Y  Fwhile(*p!=’\0’) p++;
4 X0 p" u8 t: Rreturn(p-s);
) ?, i& J5 K& K* e3 g}
, v6 v( Q+ \! `) J* j3 l# m在主函数中用cout<<f(“good”)调用上述函数, 则输出结果为(    )。, o2 C- ^9 Y2 D
A. 3           B. 4      C. 5            D. 6# f: j0 b2 x/ A6 A; B
149.以下正确的函数原型语句是(    )。
7 t4 W+ c/ ]+ [. O9 y- _* C3 uA. double fun(int x,int y)                    B. double fun(int x;int y)
: \4 x  u  ^5 ~$ F' N+ nC. double fun(int,int);                            D. double fun(int x,y);8 _2 R3 q% N: V( w- q0 ^
150.以下正确的说法是(    )。
# k+ ~, F2 e/ x9 B! `- BA. 用户调用标准库函数前,必须重新定义
' @! @8 d/ A" c9 t, Y3 i; EB. 用户可以重新定义标准库函数,若如此,该函数将失去原有含义6 @" P3 w7 m$ @! N- J3 o, D
C. 系统不允许用户重新定义标准库函数8 ~, A) N$ {. Q- t
D. 用户调用标准库函数前,不必使用预编译命令将该函数所在文件包括到用户源文件中
' W9 S4 q/ r8 u- |+ B% Z6 s5 M* m0 W151.函数调用不可以(    )。! Z4 f7 C+ ?3 C: h. \
A. 出现在一个表达式中          B. 出现在执行语句中 C. 作为一个函数的实参  D. 作为一个函数的形参
  t) b8 F% @( f! e9 f2 d/ h" N! K1 P152.以下正确的描述是(    )。
; d: ]* \  R- y+ S/ a7 N" }+ ^7 YA. 函数的定义可以嵌套,函数的调用不可以嵌套
+ o1 f& w& U4 q6 HB. 函数的定义不可以嵌套,函数的调用可以嵌套
5 l( r9 W1 |+ e/ S' ]2 D% sC. 函数的定义和函数的调用均可以嵌套2 K# F1 ?2 E8 u; {0 {' X
D. 函数的定义和函数的调用均不可以嵌套
. t  A& ]1 ^! O153.若用数组名作为函数调用的实参,传递给形参的是(    )。
8 n; _/ |+ M! Y0 ?- GA. 数组的首地址                                        B. 数组中第一个元素的值4 k5 P4 i" P1 o; w) K
C. 数组全部元素的值                                    D. 数组元素的个数: Y+ n+ R! o6 J6 E4 ?( |+ |  x
154.以下错误的描述是(    )。- E% z/ n& {" X1 s1 E0 h
A. 被调用函数中可以不用return语句
5 ^5 p+ x3 H; a4 T1 e1 E# B, j; k) eB. 被调用函数中可以用多个return语句* v: i; U0 h( j( i
C. 被调用函数中,如果有返回值,就一定要有return语句
& u' Z- C$ p5 z, DD. 被调用函数中,一个return语句可返回多个值给调用函数  P3 _6 K# W1 `; h) z" |" l
155.以下正确的描述是(    )。
8 @" s0 x6 f+ Z) e) V' }A. 不允许设置参数的默认值# J* v7 c8 @: W
B. 设置参数的默认值只能在定义函数时设置3 G, c9 [! M3 ?. q7 @) ]
C. 设置参数的默认值时,应该设置右边的参数/ w  s  z! h+ ]0 o  B7 O5 k$ N8 i* p0 u
D. 设置参数的默认值时,应该全部参数都设置3 v4 A2 w+ l/ B1 P3 C' J
156.采用重载函数的目的是(    )。
' o6 B8 {! I4 @, q" s" X/ YA. 实现共享           B. 减少空间   C. 提高速度   D. 使用方便,提高可读性
: P# }. x8 s  {- `1 D157.将两个字符串连接起来组成一个字符串时,选用(    )函数。
+ Q. p( I0 H" g& S5 fA. strlen()           B. strcap()    C. strcat()            D. strcmp()) w9 B3 Z7 b0 ]  C6 C
158.以下叙述中正确的是(    )。& R" f& {% ]" O- G1 n" K1 \" E
A. 使用#define可以为常量定义一个名字,该名字在程序中可以再赋另外的值& i  a2 g' y5 L; z2 N
B. 使用const定义的常量名有类型之分,其值在程序运行时是不可改变的
" |1 b: q  h! `& w4 UC. 在程序中使用内联函数使程序的可读性变差& F% O, G+ f# n; b
D. 在定义函数时可以在形参表的任何位置给出缺省形参值
/ ?, k# k  S- k3 ?, T. Y159.下面的标识符中,(    )是文件级作用域。- Z1 V1 T' R' {/ \, y# j' W
A. 函数形参          B.语句标号    C.外部静态类标识符          D.自动类标识符( P) n# [, d1 V  P7 |- p7 b
160.以下叙述不正确的是(    )。
; Q0 j; B% j+ f$ @A. 宏替换不占用运行时间                    B. 宏名无类型3 ?' y9 f8 {' t1 o
C. 宏替换只是字符替换                      D. 宏名必须用大写字母表示
9 c  F' M, H, u$ R& }. R# |161.下列对引用的陈述中不正确的是(   )。& G% I& @( {% M
A. 每一个引用都是其所引用对象的别名,因此必须初始化- c# i; j. ~  b- r8 S/ t
B. 形式上针对引用的操作实际上作用于它所引用的对象: B0 h$ R2 Q9 T4 L4 \
C. 一旦定义了引用,一切针对其所引用对象的操作只能通过该引用间接进行! Z' `/ X% U0 I; s) I  Y& E
D. 不需要单独为引用分配存储空间6 ^: g" ?6 W( Y* ?( ~7 _! T
162.假定变量a和pa定义为“double a[10], *pa=a;”,要将12.35赋值给a中的下标为5的元素,不正确的语句是(    )。
1 I; `, J  [5 {. R1 Y& q' L; |A. pa[5]=12.35;          B. a[5]=12.35;    C. *(pa+5)=12.35;          D. *(a[0]+5)=12.35;) `. ]: P" y* ]: {0 U
163.假定变量b和pb定义为“int b[10], *pb=b;”,要将24赋值给b[1]元素中,不正确的语句是(    )。- A7 A5 C/ P# C, o5 |8 z
A. *(pb+1)=24;           B. *(b+1)=24;    C. *++b=24;           D. *++pb=24;0 l- I2 S# D3 y7 E  o6 [, ?2 f
164.假定指针变量p定义为“int *p=new int(100);”,要释放p所指向的动态内存,应使用语句(    )。) ~# F& B# S# G
A. delete p;            B. delete *p;      C. delete &p;           D. delete []p;
& ?2 z1 h  m/ q; t& F$ m165.假定指针变量p定义为“int *p=new int[30];”,要释放p所指向的动态内存,应使用语句(    )。7 p' b+ M. V, k% l/ |# h" I. b
A. delete p;           B. delete *p;     C. delete &p;             D. delete []p;) I9 E6 a! v5 J  |  G
166.关于局部变量,下面说法正确的是(    )。. w8 P2 j" w- V7 M4 e
A. 定义该变量的程序文件中的函数都可以访问
+ O  o5 ^+ g# B( RB. 定义该变量的函数中的定义处以下的任何语句都可以访问2 H' u, y1 y, }, R1 U+ R, L
C. 定义该变量的复合语句中的定义处以下的任何语句都可以访问1 C9 m8 }: G& h+ C3 ^
D. 定义该变量的函数中的定义处以上的任何语句都可以访问
) I; @5 n0 Z2 f; V+ `' w& A167.文件包含命令中被包含的文件的扩展名(    )。- m; R- b! `1 c) _9 ~1 y9 m
A. 必须是.h            B. 不能是.h    C. 可以是.h或.cpp           D. 必须是.cpp
: O" b, r; K7 \2 x168.预处理命令在程序中都是以(    )符号开头的。# t% _* ^: Y; x% j2 U5 c
A. *             B. #      C. &             D. @
% N  ?& |: z- n8 ~! N169.设array为一个数组,则表达式sizeof(array)/sizeof(array[0])的结果为(    )。2 \/ E! ]# C/ l( V1 S- g5 h
A. array数组首地址                       B. array数组中元素个数  x0 U2 y5 W: q+ z9 m
C. array数组中每个元素所占的字节数       D. array数组占的总字节数
, U. r& D% c5 L' v2 I170.用new运算符创建一个含10个元素的一维整型数组的正确语句是(    )。+ \* J7 S# @6 O+ \6 C6 O: b
A. int *p=new a[10];                              B. int *p=new float[10];' Q" q( S1 g* n
C. int *p=new int[10];                            D. int *p=new int[10]={1,2,3,4,5}2 H7 N9 m, A# w9 y) F
171.下列给字符数组赋初值时,正确的是(    )。7 A: f- R' A/ m( q
A. char s1[]=”abcdef”;                   B. char s2[4]=”abcd”;
! D- J( e. a, O2 t3 B! [C. char s3[2][3]={“abc”,”xyz”};        D. char s4[4][]={‘a’,’x’,’s’,’t’};
* }- z/ H1 Z6 d172.设有定义“static int data[5][6];”,设该数组在静态存储区中的起始地址为十进制的100,若每个int型数占4个字节,则数组元素data[2][3]的地址为(    )。
9 s4 [/ p) P6 o5 ]A. 115            B.124     C.130             D.160
# b# e7 O# T# Y$ _8 s173.假定变量m定义为“int m=7;”,则定义变量p的正确语句为(   )。
3 _0 b. A+ o! [A.  int p=&m;    B.  int *p=&m;    C.  int &p=*m;     D.  int *p=m;* q- h. H! h7 |
174.. 假定k是一个double类型的变量,则关于变量p的正确定义语句为(   )。6 G' P/ d" s' Y: s1 h/ j
A. double p=&k;                                 B. int *p=&k;: i$ i3 P; {: a( W. X7 q
C. double &p=*k;                                D. char *p=”Thank you!”;
: f. t# {0 _8 N5 N175.变量s的定义为“char *s=”Hello world!”;”,要使变量p指向s所指向的同一个字符串,则应选取(   )。# F, ?6 `/ G9 T; @
A. char *p=s;            B. char *p=&s;     C. char *p;p=*s;          D. char *p; p=&s;  X( P& t% Y, Q) B, s
176.关于void 指针,下列说法正确的是(   )。% f" X  Z$ p( F+ p. C" X3 J
A. void 指针就是未指向任何数据的指针7 e! z+ I: [4 U6 G! _$ T; {
B. void 指针就是已定义而未初始化的指针. M5 s# ]1 E; ~
C. 指向任何类型数据的指针可直接赋值给一个void 指针
6 f0 ~# A& L& A$ RD. void 指针值可直接赋给一个非void 指针
# Z* ?; R6 g$ U9 h# @2 _177.假定一条定义语句为“int a[10], x, *pa=a;”,若要把数组a中下标为3的元素值赋给x,则不正确的语句为(   )。
/ w* Y& z3 V8 G! z, H4 i0 MA. x=pa[3];           B. x=*(a+3);     C. x=a[3];   D. x=*pa+3;
% |& u3 t1 ?' w; c  v4 c3 o178.假定有定义“int b[10]; int *pb;”,则不正确的赋值语句为(   )。
' e: v7 h& z+ w& J2 KA. pb=b;           B. pb=&b[0];     C. *pb=new int;           D. pb=b[5];9 J/ @* B: V4 ]$ i+ _+ E
179.假定p是具有double类型的指针变量,则表达式++p使p的值(以字节为单位)增加(   )。
# G: D. Q- ?0 i( RA. 1            B. 4      C. sizeof(double)          D. sizeof(p): h  C7 |. T4 ?
180.假定p指向的字符串为”string”,则cout<<p+3的输出结果为(    )。
" p8 U  w; l) S9 J! n. CA. string            B. ring     C. ing            D. i
5 q+ b6 A) q  h181.假定p指向的字符串为”string”,若要输出这个字符串的地址值,则使用(    )。# |: k! A9 q$ ^/ L% [, R. @
A. cout<<*s;        B. cout<<s;     C. cout<<&s;          D. cout<<(void *)s;# h# M! h0 T9 D( G- h* j' }
182.定义p并使p指向动态空间中的包含30个整数的数组所使用的定义语句为(   )。# x9 Z4 _* B: n3 H3 [7 W) A
A. int *p=new int[30];                        B. int *p=new int(30);
) B1 B1 [- j" c+ jC. int *p=new [30];                           D. *p=new int[30];
" g" u5 k: N7 ~4 H+ |9 C2 d0 u" p$ A183.假定p是具有int**类型的指针变量,则给p赋值的正确语句为(    )。* n9 P, X: a/ |) W3 b# p, V
A. p=new int;           B. p=new int*;     C. p=new int**;   D. p=new int[10];; Q  S: Z, f5 l' k
184.要使语句“p=new int[10][20];”能够正常执行,p应被事先定义为(   )。6 ?  T2 u- g- Y$ c
A. int *p;           B. int **p;     C. int *p[20];    D. int(*p)[20];
* D8 O8 q" a$ R185.假定有“struct BOOK{char title[40]; float price;}; BOOK *book=new BOOK;”,则正确的语句为(   )。
* n" h, f  D" M9 ZA. strcpy(book->title,”Wang Tao”);     B. strcpy(book.title,”Wang Tao”);# t7 W7 L: i/ T: D" A4 g( H
C. strcpy(*book.title,”Wang Tao”);     D. strcpy((*book)->title,”Wang Tao”);
; @, Z+ K7 J1 l2 a186.假定有“struct BOOK{char title[40]; float price;}; BOOK *book;”,则不正确的语句为(   )。
( n) r. ^" D4 l( y- L% [A. BOOK *x=new book;                               B. BOOK x={"C++ Programming",27.0};
# d- b' e  ^% zC. BOOK *x=new BOOK;                       D.  BOOK *x=book;
$ U  r0 S) L0 v7 M187.假定有“struct BOOK{char title[40]; float price;}book;”,则正确的语句为(   )。
8 g4 B  |) J- |3 F; ^A. BOOK &x= &book;                                 B. BOOK &x=book;: s! c, X* M) s* L; d% R
C. BOOK &x=new BOOK;                       D. BOOK &x=BOOK;0 L" \/ U- s: C* J! j. \
188.假定变量x定义为“int x=5;”,要使rx成为x的引用(别名),rx应定义为(   )。: @4 |1 F0 q# H$ l! y
A. int rx=x;           B. int rx=&x;     C. int *rx=&x;          D. int &rx=x;
% L5 |/ f% a; h填空题:
6 X' K% Y2 u6 f' I" E2 s: N1.C++语言是在(   )语言的基础上发展起来的。* p* s/ M! p1 i
2.C++语言的编译单位是扩展名为(     )的(     )文件。+ X2 }% H3 X* F
3.行尾使用注释的开始标记符为(  )。2 q! s9 L$ N: S# b7 N
4.多行注释的开始标记符和结束标记符分别为(  )和(  )。' e5 g4 T0 t/ {8 S- r, K
5.用于输出表达式值的标准输出流对象是(  )。
+ N. Y! i; f! {2 q2 S. q6.用于从键盘上为变量输入值的标准输入流对象是(  )。# F7 [. G4 g) L  r
7.一个完整程序中必须有一个名为(   )的函数。
, w! P3 O* l/ I8 f% s8.一个函数的函数体就是一条(  )语句。
8 @' n% T' J% }9.当执行cin语句时,从键盘上输入每个数据后必须接着输入一个(  )符,然后才能继续输入下一个数据。6 D+ R8 n/ b$ T
10.在C++程序中包含一个头文件或程序文件的预编译命令为(     )。
* r2 V' T$ K. ^; n% X0 ~0 B1 A' J' [11.程序中的预处理命令是指以(   )字符开头的命令。
9 l, K* ~1 t) {. V3 h+ ~12.一条表达式语句必须以(  )作为结束符。
1 z( Z* G* i8 G; ?0 U, l13.在#include命令中所包含的头文件,可以是系统定义的头文件,也可以是( 用户(   ) )定义的头文件。
5 [# @0 B5 c# k3 b# \1 ~& |4 h; {: y8 ]14.使用#include命令可以包含一个头文件,也可以包含一个(  )文件。0 N8 Q9 Y6 L; Z) _9 ~: Q
15.一个函数定义由(  )和(  )两部分组成。2 e- w3 P2 T+ Y& e2 R7 t
16.若一个函数的定义处于调用它的函数之前,则在程序开始可以省去该函数的( 原型() )语句。
7 z9 _( a, g/ m. l# T$ }* i# ~17.C++头文件和源程序文件的扩展名分别为(  )和(   )。0 J2 A1 U7 s( _) E: X; g3 H& a
18.程序文件的编译错误分为(    )和( 致命(     ) )两类。
) z2 B) u+ T5 ?6 D6 N19.当使用(   )保留字作为函数类型时,该函数不返回任何值。5 u/ z3 o0 Y' @* r8 J
20.当函数参数表用(  )保留字表示时,则表示该参数表为空。( D& h, E0 F- p! D0 s
21.从一条函数原型语句“int fun1(    );”可知,该函数的返回类型为(    ),该函数带有( )个参数。
6 n: X# \3 f* u/ _+ A22.当执行cout语句输出endl数据项时,将使C++显示输出屏幕上的光标从当前位置移动到(  )的开始位置。3 B4 a0 z3 W0 j
23.假定x=5,y=6,则表达式x++*++y的值为(  )。/ `0 e. n. V5 W5 c
24.假定x=5,y=6,则表达式x--*--y的值为(  )。
9 L! ?" p% {" L* y25.假定x=5,y=6,则执行表达式y*=x++计算后,x和y的值分别为(  )和(  )。9 V) t' p+ U6 `7 w) }3 o
26.假定x=5,y=6,则执行表达式y+=x--计算后,x和y的值分别为(   )和(  )。
  s  z- @# }: `3 |+ @27.C++常数0x145对应的十进制值为(  )。- J0 ]  Z3 b- r6 v6 T( L  |: S5 `0 g
28.C++常数0345对应的十进制值为(  )。
+ N$ K$ l; f6 a% t29.十进制常数245对应的十六进制的C++表示为(       )。
- B& N5 {# @5 @0 Q0 a' ^30.十进制常数245对应的八进制的C++表示为(    )。 1 Z3 J7 @7 l6 `) v
31.signed char类型的值域范围是(     )至(  )之间的整数。
+ S5 N- j# H2 B, x32.int和float类型的数据分别占用(  )和(  )个字节。7 y! b. B$ V! L8 _/ s
33.float和double类型的数据分别占用(   )和(  )个字节。, M' L8 Z+ V0 P, I1 p# I% h% s( h
34.bool和char类型的数据分别占用(  )和(    )个字节。
1 j. I. z" p" Y% [" @8 ^" ^35.unsigned short int和int类型的长度分别为(  )和(  )。
$ \0 d( x& B0 |  P1 J36.字符串”This\’s a book.\n”的长度为(    )。6 `/ K- R+ Y: F6 X" U, {4 H  E
37.字符串”\nThis\’s a pen\n\n”的长度为(  )。
; \. o( ^8 m3 m6 }% I) ^! e# h38.在C++中存储字符串”abcdef”至少需要(  )个字节。3 |$ Y9 i9 v4 X6 R5 p
39.在C++中存储字符串”a+b=c”至少需要(  )个字节。1 v* e+ B  z3 R) ^& m
40.假定x和y为整型,其值分别为16和5,则x%y和x/y的值分别为(  )和( )。- s/ C6 M; U5 z  I6 _% Q+ e0 P
41.假定x和y为整型,其值分别为16和5,则x/y和double(x)/y的值分别为(  )和(  )。4 d; Y- r" k" O0 A
42.假定x是一个逻辑量,则x && true的值为(  )。1 R0 I; N1 R' _# h( {8 \
43.假定x是一个逻辑量,则x || true的值为(      )。
  y  k' t4 R# T: c1 z+ d$ M" o9 S44.假定x是一个逻辑量,则x && false的值为(     )。
- u1 a% I, ^, w4 z& ?45.假定x是一个逻辑量,则x || false的值为(   )。8 L( y3 G8 a& z% K- L  X
46.假定x是一个逻辑量,则!x || false的值为( )。  U! f5 K8 K! }" J  p. V
47.假定x是一个逻辑量,则x && !x的值为(       ) 。! V- g2 ]+ _9 `2 o) p" T1 |
48.假定x是一个逻辑量,则x || !x的值为(      )。2 k' @& g- L6 K6 R3 H, o
49.?数学算式?的C++表达式为( (x+y)/(     )。: {9 g; p+ K4 `% S$ r% `6 d" J' g
50.?数学算式?的C++表达式为( 3*x*y/(      )。
& I5 |, g( G/ y" A51.?数学算式?的C++表达式为( 1/(      )。
: G+ |, q- s5 B) `0 b! `3 s52.?设enum?Printstatus{ready,busy,error};?则?cout<<busy的输出结果是(  )。3 P! a1 ~3 P% D$ }- q
53.?设enum?Printstatus{ready=2,busy,error};?则cout<<busy的输出结果是(  )。1 i. R) i, x' D0 H9 D( R
54.?常数-4.205和6.7E-9分别具有(  )和(  )位有效数字。
4 V/ B9 r- w( j5 ^6 t& N  `55.?枚举类型中的每个枚举值都是一个(     ),它的值为一个(  )。) C" |/ r& \$ x8 ?
56.?常数100和3.62的数据类型分别为(    )和(    )。: p9 I$ r+ w( E: y) V" r# @6 s$ m
57.?若x=5,?y=10,?则计算y*=++x表达式后,x和y的值分别为(  )和(  )  。
  K9 r& Q) n% a* L5 |6 g" w& E58.?假定x和ch分别为int型和char型,则sizeof(x)和sizeof(ch)的值分别为(  )和(  )。1 s; z2 s! |, B' L; S" Z. T% M
59.?假定x=10,则表达式x<=10?20:30的值为(  )。+ N- M/ `, D. J: s: L
60.?表达式sqrt(81)和pow(6,3)的值分别为(  )和( )。
0 `4 a4 M$ E' v61.?含随机函数的表达式rand()20的值在(    )至(     )区间内。; U+ j2 }# s) M0 W7 q, X6 h. P
62.?在switch语句中,每个语句标号所含关键字case后面的表达式必须是(  )。: K! U. X) W1 L3 {
63.?在if语句中,每个else关键字与它前面同层次并且最接近的(  )关键字相配套。?# `$ d7 O) L3 ?9 m
64.?作为语句标号使用的C++保留字case和defaule只能用于(      )语句的定义体中。: _- @3 J8 v" Q% ~- j0 ]* u' Z4 @6 S
65.?执行switch语句时,在进行作为条件的表达式求值后,将从某个匹配的标号位置起向下执行,当碰到下一个标号位置时(     )(      )执行。% B% x6 C1 F" m7 v
66.?若while循环的“头”为“while(i++<=10)”,并且i的初值为0,同时在循环体中不会修改i的值,则循环体将被重复执行(    )次后正常结束。
  W& N+ [% L% _# m5 ?4 R67.?若do循环的“尾”为“while(++i<10)”,并且i的初值为0,同时在循环体中不会修改i的值,则循环体将被重复执行(      )次后正常结束。# E! T6 L) @/ L1 m- v
68.?当在程序中执行到(      )语句时,将结束本层循环类语句或switch语句的执行。
- V/ X1 _' D; |- y1 C" T7 c5 o69.?当在程序中执行到(      )语句时,将结束所在循环语句中循环体的一次执行。7 Y8 ~0 k6 m! p8 Q
70.?在程序中执行到(      )语句时,将结束所在函数的执行过程,返回到调用该函数的位置。: G9 O) M3 `  s0 A6 n5 \' b+ U
71.在程序执行完(     ) )函数调用后,将结束整个程序的执行过程,返回到C++集成开发窗口。' @, M1 q1 ]8 M0 f/ K
72.?元素类型为int的数组a[10]共占用(  )字节的存储空间。/ \, B, k9 z7 k% c) N+ k
73.?元素类型为double的二维数组a[4][6]共占用(   )字节的存储空间。
0 C2 Y" V6 B3 q  K' M6 n5 A! g0 {74.?元素类型为char的二维数组a[10][30]共占用(    )字节的存储空间。9 s" Q9 g1 J% ^
75.?存储字符’a’和字符串”a”分别需要占用(  )和(  )个字节。- ^$ R. f( F7 C4 v' ~3 k3 N9 I- V
76.?空串的长度为(  ),存储它需要占用(  )个字节。
  M$ Y7 e8 w! v4 A6 R' x- F/ Q77.?字符串”\’a\’xy=4\n”的长度为(  )。+ \2 `% p  c% |0 w  {
78.?字符串”a:\\xxk\\数据”的长度为(  )。
5 @. X! U% @- h% b  ]79.?用于存储一个长度为n的字符串的字符数组的长度至少为(     )。
: h& F! e2 C! e; _) R% P, W7 _6 b80.?若a是一个字符数组,则从键盘上向该数组输入一个字符串的表达式为(     )。
( p0 q: T5 i# N% g8 C8 _! g8 s81.?若a是一个字符数组,则向屏幕输出a中所存字符串的表达式为(      )。
9 p, y  ]; f, o# j82.?一个二维字符数组a[10][20]能够存储(  )个字符串,每个字符串的长度至多为(  )。
  H, v+ _" V4 G* f83.?对一个二维字符数组a进行初始化的数据为{”123”,”456”,”789”},则a[1]元素对应的字符串为(    )。
1 |2 ?3 I4 u7 l! W84.?若需要把一个字符串”aaa”赋值到字符数组a中,则需要执行(    )函数的调用来实现。6 Y" q; \/ W; h$ }, |
85.?假定对数组a[]进行初始化的数据为{2,7,9,6,5,7,10},则a[2]和a[5]分别被初始化为(  )和(  )。$ {1 s6 B) N2 X( M/ r
86.?假定对二维数组a[3][4]进行初始化的数据为{{3,5,6},{2,8},{7}},则a[1][1]和a[2][3]分别被初始化为(  )和(  )。& N# Q2 Z$ V$ y9 n
87.?在C++语言中,一个函数由函数头和(  )组成。
% x  Y5 V: `, p" l0 C88.?重载一个函数的条件是:该函数必须在参数的个数或参数的(  )上与其它同名函数有所不同。  G! L, }) O" m7 P1 s+ u9 t* m
89.?如果一个函数只允许同一程序中的函数调用,则应在该函数定义前加上(  ) C++保留字。
0 J. W/ W( k8 o7 a5 d  M90.?若“double?x=100;”是文件F1.CPP中的一个全局变量定义语句,若文件F2.CPP中的某个函数需要访问此x?,?则应在文件F2.CPP中添加对x的声明语句为(      )。
4 K' m3 t" j& t( K4 Y9 ~91.C++中约定源文件使用扩展名 (*.cpp),头文件使用扩展名  (     ) 。
# N7 k+ n2 u2 \' x8 U92.C++中标准的输入输出流是 (    ) 和 (    ),它们是在 (  ) 头文件中定义。4 q( L; S; W5 y2 g
93.C++既是面向 (    ) ,又是面向 (     ) 。/ [* n8 {- G+ z* B& y9 A
94.在C++中有两种类型的注释符,一种是C语言中使用的注释符(     ),另一种是( )。1 U# F* _3 j: E; g
95.?对于无返回值函数,定义函数时要用(    )修饰函数类型。$ d/ S( z# B: }
96.?如果一个函数定义中使用了(  )修饰,则该函数不允许被其它文件中的函数调用。: K  [! Y/ H- a1 `
97.?如果一个函数中有多个默认参数,则默认参数必须全部处在形参表的( 右边(    ) )部分。) h8 Y9 X9 f, ~) F
98.?定义外部变量时,不用存储类说明符(    ),而声明外部变量时用它。( i$ w- _4 ^! A$ N! Q
99.调用系统函数时,要先使用#include命令包含该系统函数的原型语句所在的(    )。
; k: s2 o1 K( K' Z; ~  o100.?函数形参的作用域是该函数的(   )。
5 R7 L, G# y! K8 H/ h; n) D101.?C++提供的预处理命令有宏定义命令,条件编译命令和(      )。0 ~$ U8 H0 p: H9 C5 |
102.?程序的编译是以(    )为单位进行的。
2 n/ r& k& O6 o" Z0 D& }103.?C++程序运行时的内存空间可以分成全局数据区,堆区,栈区和( 代码区(     )。
* Z7 }8 l$ Y) P, y1 M104.?全局变量和静态局部变量具有静态生存期,存放在内存的(      )区中。
: C- P0 x; _4 Z; `7 z3 B105.?局部变量具有局部生存期,存放在内存的(   )区中。" N  Q2 f/ ^1 N
106.?若二维数组a有m列,设a[0][0]位于数组的第一个位置上,则计算任一元素a[i][j]在数组中位置序号的公式为(       )。?) A' m5 G" ^; S! m4 _2 r2 @
107.?若有定义“double?a[3][5];”,则a?数组中行下标和列下标的最大值分别为(  )和(  )。# J' j, C1 d) w/ ~
108.?若有定义“struct?AA?{int?a;?char?b;?double?c;}x;”,则x占用空间大小为(  )字节。
0 L- @9 Q' z* c6 U109.?当定义一个结构体变量时,系统分配给该变量的内存大小等于各成员所需内存大小的(  )。
/ y" ^& T9 U# n110.?一个指针类型的对象占用内存的(  )个字节的存储空间。" {$ q* D- z4 C7 x/ Q+ J5 _
111.?一个指针指向一个数据对象,它保存着该数据对象的(     ),若数据对象为DataType类型,则相应的指针类型为(  )。
/ Z1 J4 T1 j2 ?. h& H/ c4 C! {112.?若要把一个整型指针p转换为字符指针,则采用的强制转换表达式为(  )。
8 s+ s, B* e/ U$ j& w  ]113.?假定一个数据对象为int*类型,则指向该对象的指针类型为(    )。
6 P1 z. E, z# a5 V4 l. B114.?假定p是一个指向整数对象的指针,则用(  )表示该整数对象,用(  )表示指针变量p的地址。; }$ h! k1 `( e: B9 k8 m& d7 _
115.?假定p是一个指针,则*p++运算首先访问(  ),然后使(  )的值增1。6 A9 ?; W3 z% B4 u( g- r% X( c. K1 b
116.?假定p是一个指针,则(*p)++运算首先访问(  ),然后使(    )的值增1。) \5 \, a, U+ [
117.?假定p所指对象的值为25,p+1所指对象的值为42,则*p++的值为(     )。
/ W1 T9 t. }7 h( F/ `& q! U118.假定p所指对象的值为25,p+1所指对象的值为42,则*++p的值为(     )。3 k" C( C+ E* @
119.?假定p所指对象的值为25,p+1所指对象的值为42,则执行(*p)++运算后,p所指对象的值为(  )。
$ g; K( m- J" Q6 h9 H120.假定p所指对象的值为25,p+1所指对象的值为42,则执行*(p++)或*p++运算后,p所指对象的值为(    )。$ ?# O7 E# w- p+ o% D" v2 Y2 r
121.假定a是一个一维指针数组,则a+i所指对象的地址比a大(     )字节。?
3 Y; N2 T8 ]" m- s+ P! {3 v+ B122.?假定a是一个一维数组,则a[i]的指针访问方式为(     )。
$ c; U) S& n% S2 K4 n0 N( k$ y3 m4 N123.?假定a是一个一维数组,则a[i]对应的存储地址(以字节为单位)为(         )。
1 T% w5 T" Y* g; e% r" S/ q124.?一个数组的数组名实际上是指向该数组(  )元素的指针,并且在任何时候都不允许(    )它。
+ O& u1 |6 G! {125.?假定指向一维数组b[10]中元素b[4]的指针为p,则p+3所指向的元素为(   ),p-2所指向的元素为(     )。& R# r. t2 D9 a+ [7 s4 @% \' V2 \
126.若要定义整型指针p并初始指向x,则所使用的定义语句为(     )。
! Y9 B1 q4 N- N! U2 b127.?若p指向x,则(   )与x的表示是等价的。
1 G$ D3 w* I+ v128.?在一个二维数组int?a[m][n]中,包含的一维元素a[i]的类型为( int[n] ),访问a[i]时返回值的类型为(     )。
8 [5 J% Z5 g/ l129.?假定一个二维数组为c[5][8],则c[3]的值为二维元素( c[3][0] )的地址,c[3]+2的值为二维元素(     )的地址。* _) a4 r/ M7 [, q7 z& y
130.?假定p为指向二维数组int?d[4][6]的指针,则p的类型为(      )。
9 R# @3 p4 S0 Y, `. |, U131.?假定a是一个二维数组,则a[i][j]的指针访问方式为( *(a[i]+j) 或*(             )。
! s2 e9 f  l3 M132.?若要把整型变量y定义为x的引用,则所使用的定义语句为(       )。
0 J. e1 S* L+ }: f6 m" Z8 |133.?若y是x的引用,则对y的操作就是对(  )的操作。3 t9 [1 I8 ~6 y( w6 z) V5 p
134.?若y是x的引用,则y和x的值(  ),即为变量(  )的地址。
( a3 z3 G0 D( \) n0 |8 U+ A. ^135.?执行int?p=new?int操作得到的一个动态分配的整型对象为(  )。% s8 r6 W; J/ V3 |
136.?执行int?*p=new?int[10]操作,使p指向动态分配的数组中下标为0的元素,该元素可表示为(    )或(  )。! C( P0 h# ~0 H$ m! Z4 ]( a
137.?执行char?*p=new?char(     )操作后,p所指向的数据对象的值为(     )。
  W& g: i; k2 v9 n2 z- B138.?执行new?char[m][n]操作时的返回值的类型为(    )。* O  r, F" ?9 T# i9 N
139.?执行(     )操作将释放由p所指向的动态分配的数据空间。
5 w3 ~' ]! b/ m- E140.?执行(      )操作将释放由p所指向的动态分配的数组空间。
/ }* D3 W: F1 T9 f" u5 H  j141.?NULL是一个符号常量,通常作为空指针值,它的具体值为(      )。2 ?8 z) a" h# _3 Q! m5 @- b) U5 Z
142.?变量v定义为“double?v=23.4;”,要使指针pv指向v,则定义pv的语句为(       )。8 e& d9 R5 @2 X  h# A, F3 O
143.?已知语句“cout<<p;”的输出是“Hello!”,则语句“cout<<*p;”输出的是(     )。" O, F7 ~  L* v- k$ q
144.?已知语句“cout<<s;”的输出是“apple”,则执行语句“cout<<s+2;”的输出结果为( ple )。
& @$ P2 A$ [, O6 I! h* U. J/ J145.?指针变量pv和pc定义为“void?*pv?=”Hello,?word!”;?char?*pc;”,要将pv值赋给pc,则正确的赋值语句是(         )。$ L2 k* G( T2 S3 A& P$ y
146.?数组a定义为“int?a[100];”,要使p[j]?与a[j]?等效,则指针p应定义为( int (*p)[100]=b; )。int?*p=a;??(         )
! K+ B- e7 u1 ]0 Y# C147.?与结构成员访问表达式p->name等价的表达式是( (        )。; G7 p, [, Y1 v7 P6 @
148.?与结构成员访问表达式(*fp).score等价的表达式是(          )。: m5 q5 f- E! z: y( x
149.?已知变量a定义为“int?a=5;”,要使ra成为a的引用,则ra应定义为(         )。1 s0 i; {/ d% n3 b- {- g
150.?已知有定义“int?x,?a[]={5,7,9},?*pa=a;”,在执行“x=++*pa;”语句后,x的值是(  )。
  o" _' F; F- [; w151.已知有定义“int?x,?a[]={6,10,12},?*pa=a;”,在执行“x=*++pa;”语句后,*pa的值是(  )。
/ M/ T5 f6 l, @, K* M, K% D8 g152.?已知有定义“int?x,?a[]={15,17,19},?*pa=a;”,在执行“x=*pa++;”后,*pa的值是(  )。程序填空题:% t- R+ z6 f' R" p
1.下列递归函数计算(1+2+3+…+n), 请填空完成程序。
5 {' Y. u( u: p# [int sum(int n)  % S1 k' M" z( R7 N
{, P! U/ T( e6 D: m
  ____(1)____ m;4 _' L4 E4 x/ F& G8 Z' T: N. h
  if(n<1) ____(2)____;
; k& R9 h# w5 J4 u: i  else m=n + sum(n-1);
0 X" m7 y% |8 |$ Q$ X# l* e  return ____(3)____; 2 ^0 L0 P( C' r
}2.输入N个整数,输出其中最大数。! w: w5 O( X& g; w/ \8 i1 n
void main()
2 X  Y/ I8 q+ f9 e2 t$ [{
# @' v8 v( _! ?8 d% v: G  const int N=100;          9 w. ^8 A$ k+ W, [% V! M0 L8 M( s
  int max, a[N], j; $ I- Q: v  D* f$ V2 F& y
  for(j=0; j<N; j++)
0 v6 C# T! O5 L  f. x: l, E    cin>>____(1)____; 0 z4 K8 S& r6 X9 R! p2 l0 j
  max=a[0];
6 c) R+ b" o9 L8 ^  for(j=1; j<N; j++)
3 m8 t( m6 `4 R+ J3 M    if(a[j]>max) max=a[j]; ! J* J( _# [9 g1 Q4 R% {9 f
  cout <<____(2)____;
; N! G( d$ V/ r; U}3.请填空完成下列递归计算 的函数。
- |; {# G6 Z/ {; C4 \% Rint fac(int n, int m)
$ L1 y0 d3 e9 E1 U( w, f8 R, V! K{; R) k3 l! e) v8 @: Z
  int p; 5 _4 X8 m) s) p" W3 j
  if(m<1) ____(1)____;
7 |& U3 k1 h4 @+ t0 i  else p=n*fac(n,____(2)____);
+ @1 l9 D, X9 D  return ____(3)____;
6 W7 p7 a, M) L2 P- I5 A& }6 [7 v9 N}4.下面是求一个5*5矩阵对角线元素和的程序, 请填空完成程序。
6 q9 c* P! H0 T#include <iostream.h>           $ |% q( j& t  s# s' C. |) A
void main()
# }  E# _: |0 v- j" m/ b& B{
' R9 ^4 T) [+ d6 u  const int N=5;
6 x& [( P! w1 u6 z+ b: S  int i,j;+ L; y( n+ K3 `
  double sum=0.0, a[N][N];
9 C8 i* q! j3 ]  j4 v1 M  for(i=0;i<N;i++) % a" s2 n3 x1 B& Y$ F
    for(j=0;j<N;j++) 0 B2 ^& T3 e6 V: w
       cin>>a[i][j];
9 q( }, |/ b. y$ N7 u2 D  for(i=0;i<____(1)____;i++)
' o0 W& L% V7 P2 G3 @; }     sum+=____(2)____; 9 j: \5 a- u* E" r: [- B
  cout <<sum<<endl; + X; p8 a. }6 F, n+ f
}5.下面程序将键盘输入的一个三位整数,倒序输出到屏幕(例如,输入的是125,输出的是521), 请填空完成该程序。0 h1 w4 U' ]" G) V# R9 W
#include <iostream.h>- a, X$ h) f& B
void main()& p0 O- V  g5 L
{
; l) ^- Z# Z( p1 p1 f0 ]  v        int n,a=0,b=0,c=0;
! k5 a2 i6 Y0 O& z6 f0 l        cin>>n;
' q- i/ B% i) J# W5 {) |        if(____(1)____)
' J/ p: A5 f7 C& f6 ~/ N  m        {9 z/ C1 L1 H+ D+ B# O
                a=____(2)____;
- `: A5 f, G, e+ g                b=n/10%10;
; c/ [) @8 A. @- H% Z) l' o3 P' w                c=____(3)____;   4 G! E. t( I1 `  A: t- I) d
                cout<<a<<b<<c<<endl;
% }! W  p$ r1 p        }# C3 K3 i: M7 w; G; V- d
        else
. @7 B* L6 N/ B9 F                cout<<"input error!"<<endl;
+ X- s1 y8 y0 }: C}6.一个函数将一个数组中的值按逆序重现存放,填空完成该函数。
: ?+ |9 Y9 K' o8 h7 p* gvoid inverse(int ____(1)____,int n)( Q' ^& h0 C& Y& ]
{4 x( _/ R2 |) H( Q  G7 C' t* k
        int j,k,t;$ }6 ?8 w2 Y& A) A
        j=0;k=____(2)____;* L8 H2 X: ^2 L. ~5 M1 _  y
        while(j<k)9 B% Z& h" r7 j/ I
        {
- d: {; ?/ t6 I$ r1 ^. Y! X: M. i                t=a[j];a[j]=a[k];a[k]=t;
1 ~9 N, Z9 U: l0 V3 c3 H3 r                j++;k--;, ~! W( D7 p; ?9 U4 P+ Z/ H
        }8 \8 n; E5 w# w  w+ S
}7.下面的函数计算一字符串的长度,请填空完成改函数。' g( y( i9 w  b( ]
int strlength(char ____(1)____)
* q- |7 @; b7 w* p; Z+ b" Q{
+ F, b  `& G8 B  int k=0;
& R8 I; ]: c0 z  d  while (s[k]!=____(2)____) + ?5 k0 d/ f: j3 E* C- q/ \
    k++;) N) E2 ]* E: x; ~$ b$ U) S
  return ____(3)____;
+ i6 \0 H  U9 j' x6 s* a}8.下面的函数将一个字符串接到另一个字符串后面,请填空完成该程序。3 d2 H- r3 N  u+ i& a
void strcat(char s1[ ], char s2[ ]) ( A' [' Y. m9 m  _
{
& x& f6 O+ D! p8 E$ @! j  int k=0,j=0; ! ]' _" m' u* B6 [1 y7 z
  while (s1[k]!='\0') : b  v. H9 S7 c
    ____(1)____;
" Q3 ^& l7 Q& p4 e2 p9 S8 E  while (s2[j]!='\0'). Z5 X  H* R, f7 T1 h
  {
' v- ~8 c# L* K1 E0 c1 R& i. Q0 k    s1[k]=____(2)____;" J$ @. I+ V5 N1 D# h
    k++; j++;4 Q" O1 I5 M! ^3 O. d. V  Y
  }
8 K; l% Q  S# J8 |$ G7 [. i}9.下面的程序计算下列级数的和:" s$ H7 P& g; B* r! m; x$ v
  s=1/1+1/2+1/3+...+1/n- u4 Z& O" m* j; B! D2 s
  请填空完成该程序。5 }7 M# e4 k, E* ^6 ~5 Z: ~
#include <____(1)____>           
$ S- ?1 U8 s+ A) S$ p9 Yvoid main()4 E) E. A+ P$ c) V# i  _$ \' {! H
{
* ]3 J7 s& A: h0 V5 N# s  int i, N;        
% {% F8 c* ^- R, e: v) h* [  double f, sum=0; 8 c$ {3 H* M5 d/ T, S# L
  cin>>N;
$ T/ H6 p9 }- I" Y  for(____(2)____;i<=N ;i++)
! e+ a0 I( e& K+ r+ c  {
! @8 O) x: [; {: v     f= 1.0/ (double)i; . {5 s& d* u, N# h. g; `
     sum+=____(3)____; ! q  b4 ~- N# o0 m$ O; E
  }
7 T6 Z2 B" R& A3 X1 c; U  cout <<sum<<endl; 2 ]: b( @2 s/ v( Z% Y
}10.下列程序验证100以内奇整数,其平方被8整除余一,请填空完成该程序。
$ K, u$ B4 I! @, O4 O#include <iostream.h>% a' T$ Y; q% h, A3 P( y
void main()
8 f! S- O  }5 p& C{+ g. I) \* E) a
  int m, n;
5 N4 h8 U* i/ B; D  for(____(1)____; m<100; m+=2) : `5 f9 u' E$ y% n
  {0 V  q* t4 _% U6 Y* Q3 u
    n=____(2)____; 1 _& S- j4 ?' C- q' G4 ^. F
    if(n%8!=1) break; % N) x7 [! @  d9 B
  }2 \1 k9 v! s" Q; W
  if(m>=100)
' X4 ?. L, I0 t6 n6 ?" b) K    cout <<" 奇数的平方被8整除余1是正确的"<<endl;             1 ]* I2 ]7 ^3 U6 |! \2 x
  else' T& @7 O. c* R$ J. Y8 F* p
    cout <<" 奇数的平方被8整除余1是错误的"<<endl;
- v. d* J6 U% w3 {, ]}   ( k' Q& w. v$ Y3 j1 H
11.下列程序是完成由公制转换到英制尺寸的程序(已知一英尺为25.4cm),请填空完成该程序。
' o) ]# B+ V2 {! b7 P4 r% V#include <____(1)____>0 h' s5 j: R$ f0 |7 }
void main()
9 {  J0 \1 v- ^( [. N{
" ^5 A) u7 H0 K* w  float inch, cm,;8 T3 z# X6 m8 D" ?! I+ Q% a: `8 l
  cout<<"Enter the height:";' P2 A* ]6 k! E* q& @+ n' }! T' \
  cin>>____(2)____;
3 s, H3 Y9 l+ n% M3 \  inch=cm*____(3)____;
) @2 f# ?* F" y9 M  cout<<endl<<"The height is:";
! H9 k! c7 K( j9 t  cout<<cm<<"cm="<<inch<<"inch\n";
% ?5 U! N* d- H+ _; m6 r$ b}   
  J" S/ `% i6 m7 A12.下列程序是求表达式
6 R' z3 Q! h: o- O5 A100                50                10
) Z% g! h6 ]  Y$ E6 h∑ K +        ∑ K2 +∑ 1/K
  ~$ N9 e! p/ w& w2 W! D0 g# xK=1                K=1                K=1$ n" z0 q  V* m; w& _
                的值,请填空完成该程序。! z' p7 ^! h, |2 P! V
#include <iostream.h>. e( Y2 @1 d! g' e: _% E
void main(), N% `7 V( ?* \
{" C. w' M* A; N
        int K;
0 K- Y  O7 v1 v% _: r- c        double sum=0.0, sk1=0.0, sk2=0.0, sk3=0.0;
; s: p) ^7 X  T, f4 q8 q0 s8 i2 c        for(K=1;K<=100;K++)
! p) M/ Z( w+ i; u1 Y) H        {& a% @' c9 Z  p' \3 h
                sk1+=K;
2 N( _  S- T$ f5 u! G" \. c        }9 p+ G& K3 @4 q1 e( a
        for(K=1;K<=50;K++)
4 w: P6 K; q- ]4 |2 Q        {1 D- I/ F- U: F' b! o
                sk2+=____(1)____;
" N* z' T& p1 H4 x3 U        }: Y! I: M, Y6 }3 s9 ~! n
        for(K=1;K<=10;K++)
/ X, U8 }; E5 R+ @+ j% V" Z' @3 R/ x6 I        {/ q% n7 S# E9 k
                sk3+=1/double(K);! k/ ]- ]9 Q" t
        }
/ e; ?3 ^2 P. `5 S8 m* F+ Z        sum=____(2)____;
4 v3 _0 P) W; M    cout << "表达式值为: " << sum <<endl;
1 q9 B" ^/ p( [8 I; l}13.下面程序求满足以下条件的最大的n:* B! ]! k2 R5 c+ ^. M
        1*1 + 2*2 + 3*3 +…+ n*n < 1000
  B9 r' h4 U" ?: L$ }3 x3 {; g, g6 Y                请填空完成该程序。
0 K* C2 d2 B$ K#include <iostream.h>
# U* F1 t! J; t, a$ ivoid main()
% `, P3 A- X5 p6 F" `+ v4 x{
3 n% L: E7 ^" l! ^        int n=1;. h* a: c* J# I, C* X% S7 ~9 U1 M
        int sum=1*1;1 a; e+ @2 q& t
        while(____(1)____)
) s$ f! E9 Q( w8 D9 ?        {: Q) ~( i6 _# T  u0 b
                n++;5 u2 K9 K- i: c9 \7 p
                sum+=____(2)____;3 ^2 o" |% U/ w; `5 P& g
        }$ M" l8 S% P- E5 u: g
        ____(3)____;7 `0 E* ?/ @  s) u% z2 y. e+ U
        cout << "满足条件的 n ="<<n<<endl;
: t5 Z6 W3 M/ r& [}* h" z# L: t6 s+ i9 w$ P
14.按给定的半径r计算圆的面积a和周长c。下面的程序用键盘输入r的值,计算a、c并输出到屏幕。请填空完成该程序。2 k: d' g, I: T4 v* ?
#include <iostream.h>
1 r0 c; A5 Y) Dvoid computeCircle(double& a, double& c, double r)
- ], u* w, _" C* n1 F8 @2 |{. E* d8 T. \  t5 @; w% c# x
        const double PI=3.1415926;
* E0 Q( ]" {( G( L        a=____(1)____;* Z. D/ X- Y3 X, c, y  V# p
        c=2*PI*r;
: Z2 @8 `" S) d}8 B- o2 A- Z  F0 l* [
void main()
" H- }7 D/ z9 h, \! E{8 R! x% j! K0 B5 D- k9 k6 G
        double r,a,c;$ e) `1 j/ ^# r! ~7 B2 p2 V5 O
                cin>>r;
, F6 n0 z; I4 M) T; l  l+ D        ____(2)____(a, c, r);+ m* }2 t& |" q
    cout << "面积="<< a << endl;
) e7 _; O0 f, O1 B% n! w) W2 G) c    cout << "周长="<< c << endl;
+ Y) O5 }) X4 ]}# E* Z3 ?; z  o, S* S) A# E2 G
15.有一个数列,它的第一项为0,第二项为1,以后每一项都是它的前两项之和。下面的程序产生此数列的前20项,并按逆序显示出来。请填空完成该程序。$ V' Q. w) ^1 _+ K% L0 S% v1 ]0 ~
#include <iostream.h>
4 t8 c3 I0 U& n- Hvoid main()2 h7 p1 i3 i- I: r
{
$ W: `. F% E' @; H$ E        int a[20];
' ^) A( U/ Y9 `7 T7 g$ i1 c        a[0]=0, a[1]=1;$ F& _0 m8 T- {; I2 a
        int i;, D) L$ w9 c& s
        for(____(1)____;i<20;i++)
" x3 e7 B5 n! a2 q" w8 t, }        {7 Y( Y5 ~$ d% p9 r
                a[i]=____(2)____;- i. K! W$ B: O. L4 Y, }
        }
: N* b1 c4 ~" T1 ~3 T! A        for(i=____(3)____;i>=0;i--) $ y7 z& x0 O5 K
      cout<<a[i]<<" "<<endl;
9 q: ~' g2 C5 |9 p8 b9 [+ E6 b}16.下面的程用键盘输入三个数,并向屏幕输出最大者(要求用条件表达式)。请填空完成该程序。7 g& h4 i  W. u
#include <iostream.h>
4 H2 }, p0 s+ @+ s0 H& ]void main()7 f0 d5 p% V# k% [
{
- b- I; _7 O! I7 P5 Z  float a,b,c,max=0.0;
, z. q5 H" f) W3 o6 u  cin>>a>>b>>c;" T  I$ z# w2 I* c- T3 q5 t
  if(a>=b)  max=a;  ~7 [- |+ R2 K3 f7 V
  else      ____(1)____;
) _$ r( q: Z1 R' C$ T  if(c>=max) max=c;
" P8 H( ]0 Z1 N7 N7 c* D5 f9 ~     cout<< ____(2)____<<endl;
+ _. i1 S! K* n* {}17.下面的程序把100至200之间的能被7整除的数输出到屏幕。请填空完成该程序。$ [0 u7 J& |- X
#include <iostream.h>& l2 y8 {8 }9 a- F3 D$ M
void main(), a2 ^5 c5 c# J
{
8 r3 \: P) {( L5 w# ?5 s  `: M9 f  int n;- [& ^$ V' L: R0 K' x; q
  for(____(1)____;n<=200; n++)8 {( ?0 L  h& e3 a
  {- }7 j: U5 H! g& M/ f2 B8 X- ]
    if(n%7!=0)
' f; ]6 S6 V4 S      ____(2)____;        
- @/ C: J" L. m' C4 G5 h* [    ____(3)____<<n<<" ;";
  K4 n2 a  G! y  }; u- ^3 v' z; \* L9 ^% S
}18.下面的程序从键盘输入一个字符,判别它是否为大写字母,若是将它转换成小写字母,若不是,不转换。请填空完成该程序。& u5 r0 n) P& c& @& b! T
#include <iostream.h>                  
7 \1 `: B7 x: e/ tvoid main()3 }; ^1 P9 C# X
{% y. y/ X7 `% j. t
  char ch;! e. V9 o& `. h
  cin>>____(1)____;
% l% e2 R2 D% ]. M! W  ch=(ch>='A'&&ch<='Z')  ____(2)____  (ch+32):ch;9 X1 a( d5 e$ X, ?; u' T
  cout<< ch << endl;
8 o+ S3 f3 e7 T. m% L, \- }}19.下面的程序计算下列级数的和:          4 ]  \: ^. _2 I+ F, _% w
   e=1/1! + 1/2! + 1/3! + ... + 1/n!7 a9 v& Y0 j' R2 D+ S7 T( Z
是自然对数的底,当最后一项近似值小于10E-7,循环结束,请填空完成该程序。
. ~7 E' ~- A0 v8 \" K& c: C; i#include <iostream.h>
# m" o2 [( m4 y9 _) h$ N" Yvoid main()
# ?. q" a8 m- v1 Q0 q9 h{9 Q  _" Z* {6 x. T& v
  const double eps=1e-7;         
( A4 }& I1 p! }3 ]  int n=1;8 Z7 E2 }0 i4 @8 K$ d
  ____(1)____ e=1.0, r=1.0;
: ~, B3 F% ?: @0 R  do
, r& n, L6 @$ n+ B0 `+ s  {
3 Q; @" I9 R2 H/ L    e+=r;
$ D  d# Y7 J2 c4 L2 t. i6 K    n++;
7 l* V6 n$ ~' B0 _$ w8 U% o    r/=____(2)____;
. ~- f8 N1 V6 B: E, X7 W+ D  }____(3)____(r>eps);
0 P; H* \" Z" c. U: Q# k) }6 ]/ f5 R1 o  cout<<" The Value is";( Q& Y  h* `- m, B# m6 H! \; V
  cout <<e<<endl; % W: {9 [- X+ {* J' L
}20.下面的函数统计字符串中,某字符出现的频率,请填空完成该程序。  \7 _9 h& o! g- w% H  |3 w
int total(char s[ ],char c)
, l5 H+ K- C8 h; C3 Z2 Y' r{% I6 m# \; {. e: |8 E
  int n,k;
7 @9 z9 A; O8 C2 x: Q  k=0;6 f/ T0 }4 s' J
  while(s[____(1)____]!='\0')  R' x  v: V/ T) o) j  d
     if(s[k++]==c)  n++;
1 K+ t0 Q, v8 ~$ |; d7 W* x  return ____(2)____;6 n* `- d: O+ x, D) R8 K1 I6 p
}21.编写一个函数,返回2个参数(整数)中的小者,请填空完成该程序。
+ i4 ~4 \* z# {# i4 I7 U- @int min(int a, ____(1)____)
( v9 P, d7 w; w1 R7 D% k{
, i) T1 f. F' F0 ^+ k   if (____(2)____)
. R0 v( ^! |! g  ?" j                   return a;8 H) p0 F" t1 W1 ?
   else
& ?/ c1 P1 z# Y4 Z# `- W                 ____(3)____;
& U3 r" x; `/ c. P$ g) \}9 l" `9 w1 ]2 m) o3 x
22.将一数组的数据倒着输出,请填空完成该程序。
% l+ N8 `5 q/ i- Y- h#include<iostream.h>
1 u8 z& d9 f1 V& \: pvoid main()* m$ Y; j4 Z8 Z6 a
{  v$ q! r' C: n2 d! `* X
  int a[]={9,8,7,6,5,4,3,2,1};
/ F; |9 u1 i# B# Z1 ]7 h  int i=8;" Y# `! O0 a. X& V
  do
! d% ~# q$ G/ J8 b  {
# L% S6 \3 u9 t     cout<<____(1)____<<endl;8 c" o$ w; x4 N" ?# s/ T
     i--;
, H& D  h, i1 Z2 k6 M5 r8 @  }
4 E# M; b8 Y7 o5 N9 h1 B  ____(2)____(i>=0);5 N4 G8 g& e& h& N4 r3 |' W& g
}23.编程输出1-100之间的素数,请填空完成该程序。
9 C" U6 z9 [. u. a& q7 k2 }#include <iostream.h>- S5 h: ]5 A$ x5 X3 v
#include <____(1)____>               4 }; `' f, u. P+ I
void main()3 k2 O  g7 b- e+ |2 A+ ]
{2 s5 Q7 `/ n6 V( y0 i4 Y* U
  ____(2)____;                  
- f! R( k# W: v& a  for(m=1; m<=100; m+=2)5 Q* O' G* t$ C
  {+ ~* f( C' _' g, J
    tag=1;$ P6 X7 C4 n7 x" i4 ~% T* W
    k=sqrt(m);                    . S* C2 I2 O0 d: R
    for(i=2;i<k;i++)
6 x6 N2 b: \* f      if(m%i==0)
5 S2 v9 \/ ~! i4 g7 o      {/ ]. Q+ [- T1 }3 v  Z. X. s2 V' @! V
        tag=0;
8 g# I, ~# X. _6 w. t8 x3 C6 N        break;  
) `( {& G2 @$ W! e      }  |  [0 A) I5 V- Q* U$ n, l
    if (tag= =1)          ( ], a* W1 V- S1 k
        cout <<____(3)____<<endl;            
3 k; l1 X  E- l9 P8 Q5 w  }
/ g- N" v/ I0 G# }! B! T3 l}24.下列程序段应输出100以内的奇数,请填空完成该程序。$ {* G, H  B: t
#include<iostream.h>
4 ~) O' t* f4 N____(1)____
5 f3 j( p" o6 D{
$ |; `# c/ V* ~' ]  int k;+ \: F; W* S% F+ j+ I( m# U
  for(k=1; k<100; k++)
. {! v# l6 u; {( |# U4 r  if (k%2== ____(2)____)
2 n4 |. B5 h( Y  u9 [; B* f# u     cout<<k<<',';8 i& ?& K5 ^; e9 l) ]  T
}25.计算输出20!的结果,请填空完成该程序。
" c5 n' n, Y# q/ ]5 O: j* t4 d#include<iostream.h>8 R1 t( R1 h" d1 o( m
____(1)____, i6 o) _" p3 m- `, E
{+ h" B( D" h* {' ^
  int i;% H' N5 V8 Z. `0 Q$ F- w
  ____(2)____;8 E* n) I/ S2 e
  for(i=1;i<=20;i++)( B7 K! Z/ C! o& _" R9 x' o
     sum*=____(3)____;$ j9 k! \; b) o! h7 W3 t0 m4 A1 M  v" Z* A
  cout<<"sum="<< sum <<endl;
1 n! ^& z+ z) G; [: Z}26.下列程序段应输出20以内的偶数,请填空完成该程序。
4 X5 m: J8 P' u#include<iostream.h>
! X( e7 y7 a- }& M5 X' Evoid main()
9 a& }% G+ s9 b* w$ u* b) k{
# M/ c) ?8 U& o0 R/ F8 _: D! n4 @0 h' Q    int ____(1)____;, k+ \% y/ z4 i* i' R# L) D. q
        for(k=2; k<20; k++)
) z( m* w/ l/ T                        if(____(2)____)  cout<<k<<',';! G0 n; ^3 B3 o! H5 n  x3 f8 t8 z
}27.下列程序的功能是将字符串s中的所有空格进行压缩删除,然后输出,请填空完成程序。% M3 L* o$ u/ ^! X
#include <iostream.h>
9 ?6 A$ o' S& Y- L- h0 pvoid main()
" ?0 i5 n& m6 A0 w5 f! k+ ~5 q0 Z4 I{' ]/ z1 k1 M/ W* t# C
        char s[]="We are learning C++ language";, e1 t6 ^2 b; B8 G/ k
        for(int i=0, j=0; s[i]!='\0'; i++)
% x! c! g0 o4 w                if(____(1)____)  s[j++]=s[i];
" M& W1 h' a6 T0 m' E( ?* A$ F        ____(2)____;2 r% @$ O8 R$ C3 v4 x6 X+ \  b
        cout << ____(3)____ << endl;3 w- c0 \  V) P" Q) g6 N7 `
}28.下面程序是从键盘输入学号,然后输出学号中的百分数字是3的学号,输入0时结束循环。请填空完成程序。2 M6 d; k& \! C) M
#include <iostream.h>
: r' X! q3 Q$ o) V* L  W6 qvoid main()
' V/ N9 }2 F! Q, |! `0 y{. r7 W& q8 g) N4 W  V* Y, o5 [( n# `
        int num;
1 _  q7 s1 [& |( J( q; C0 e% Z        cin>> num;- b7 Q8 P( }" G: ]& r; J
        do
3 E/ w! v7 [+ b2 a        {
5 _) W( r1 S7 ]                if(____(1)____)  
; M' ~: O$ u, s                        cout<< num <<endl;
% s2 C4 l% F8 ]( B                cin>> num;; |: w0 \( ~, w9 @* d) I! L
        }while(____(2)____);
+ v8 }; O' O* X! t" x}
1 H. H4 g2 {+ K6 J29.以下是一个采用类结构的方式求n!的程序,请填空完成程序。
4 ]9 a: L$ }/ Z3 S! F9 C#include <iostream.h>
) W# y8 R- s, ?7 ^  Iclass Factorial
4 L3 R, n! Y  Z) K  B( R$ X/ r{, t1 V+ L+ h+ g& u0 `. A
        int n;        int fact;
' [3 F, B) l+ Upublic:% Z/ k! D: h1 g" X8 Z- O/ E
        Factorial(int val){                n=val;____(1)____;}7 Z9 h6 v5 u! a* `9 l
        void Calculate(){ int i=n;  while(i>1) ____(2)____;}9 Q' P* c7 R, `* C9 W
        void Display(){        cout<<n<<"!="<<fact<<endl;}
- |& Q) ~; A7 w& Q6 A; u};
0 w1 Y' D* D# |6 @1 C# q5 ]void main()
- _5 z4 o/ |$ b{
8 g' k8 ~+ T! ~$ F0 I9 `        int n;6 T, W; c% r. X4 J: z: b
        cin>>n;. A! I/ u3 ]1 \2 s4 O
        ____(3)____;1 o, J& c3 i1 w( F6 k
        A.Calculate();
' |, f# F# Y9 x+ L6 B  P; h        A.Display();8 N1 |/ X5 J0 {( i
}30.下列程序是用递归的方法计算fun(5)*10的值。其中fun(k)=fun(k-1)*k, 当k=0时,fun(0)=3。运行结果为3600,请填空完成程序。
# u* E4 X+ M: H% P: M#include <iostream.h>
2 K9 X5 I9 o' `# iint fun(int k)
9 \& G1 }: O% _6 {& U9 P! `- B3 X{
3 k5 _9 L5 k2 v8 v& G" R% m! L        if(k==0)
0 U3 B/ l( q6 K$ J                ____(1)____;! o% r2 u+ C8 o- g2 W
        return fun(k-1)*k;
8 m/ \; R5 B2 N2 f4 b0 {}void main()
9 n, n& U8 M; w2 t4 v" e, @) e{, n* c, R* ~0 g9 C- H
        ____(2)____;
! J+ N" J" |' s. n        cout << fun(n)*10<<endl;6 q- [7 c- k- d+ n# e* E7 Z3 l
}
; e4 ~* t0 `. k6 u( n& P2 U31.?斐波那契数列的第1和第2个数分别为0和1?,从第三个数开始,每个数等于其前两个数之和。求斐波那契数列中的前20个数,要求每行输出5个数。
! Z3 Z& B7 ~4 @# j#include<iostream.h>4 b5 k0 U: t: P9 {$ c% ~. z6 E
void?main()?{
* e% P2 M! y! |2 c6 g????int?f,f1,f2,i;* U0 D! [4 R, H+ u9 W) z% o
????cout<<”?斐波那契数列:\n”;
7 J2 v% @4 w0 T# G0 k$ b: A????f1=0;?f2=1;- X0 n# y2 Z* A" B, b( h
????cout<<setw(6)<<f1<<setw(6)<<f2;
3 }9 E1 k4 H3 Q: h/ f4 P????for(i=3;i<=20;i++)?{3 k& B4 C9 ?) b# c
????????f=______(1)______;?6 a4 ]9 n; x5 a
cout<<setw(6)<<f;
& m  V3 @7 C/ X3 ]; Zif(_____(2)______)?cout<<endl;
7 Z+ h9 Y; M$ t" \4 Xf1=f2;8 ^) F* L  S# q6 Z
f2=____(3)_______;
. u4 o. ~! g8 p+ t) w0 u????????}6 S, V! D' a0 T
????????cout<<endl;
3 b; N' R1 J: k" e$ x????}32.?计算?的值。
+ @5 y6 W4 _4 k" ^/ A6 h1 z????????#include<iostream.h>: p2 }, j0 l! a7 z4 S" _
????????void?main()+ q# a$ z, S5 f4 K8 Y1 P5 q
????????{' v- O9 m- w" E9 A
????????double?x,p1=1,p2=1,s=0;
; C/ Q, \8 h& U- O5 ~????????int?i,j=1;9 [! D" ^. _$ H( G, l7 }! ~/ U1 G  y
????????cout<<"输入x的值:";8 l6 A& m+ M: Y9 D) ^" P) M( d7 k$ s8 E1 D
????????cin>>x;- V, P4 j+ \& J, l8 _' p% [* W
????????for(i=1;i<=10;i++)?{" M! u) w+ J4 J
????????p1*=___(1)_____;) v; |9 r; \7 y# L
????????p2*=____(2)____;& H$ `- S1 S' N
????????s+=j*p1/p2;??//j的值为(-1)i+1* Z4 o$ I$ P+ }
????????j=____(3)____;
: X9 o, G+ Y) B5 U9 {* o4 C4 {????????}
% m9 f9 T$ [2 [' i% Y! b2 o????????cout<<s<<endl;4 W/ m6 l, \$ |! `& L4 P) \- f
????????}
1 U7 y! s% q* z& |33.?打印出2至99之间的所有素数(即不能被任何数整除的数)。0 x7 Y* ]( C: A0 X; \
????????#include<iostream.h>0 o. d/ A2 _# I
????????#include<math.h>
8 @2 c% m  z( y0 W????????void?main()5 T# i0 ?+ r; b+ k
????????{
) e4 X$ P- v. P) a6 R# S????????????int?i,n;
( F' }5 J% f4 E????????for(n=2;?___(1)___;?n++)?{3 S' Z; u$ I/ P
????????int?temp=int(sqrt(n));??//求出n的平方根并取整7 i6 L  h  o, U( G
????????for(i=2;?___(2)___;?i++)
) E0 l5 Z, c" l3 H) ]  r2 d; j/ J????????if(ni==0)?___(3)___;??
# u( p: p' A: ?5 I9 C; \????????if(i>temp)?cout<<n<<?;
! Y* k7 B2 }2 ^9 O/ ?????????}5 S6 m: b  h6 J9 \0 ]- e% v" J- O- F
????????cout<<\n;4 E* l7 C3 R) Q: H; y
????????}
1 R, A; c$ d$ s34.?采用辗转相除法求出两个整数的最大公约数。' {2 |) f. D2 s* U# m
????????#include<iostream.h># |9 I* E. K8 s
????????void?main()
5 R% q5 Y1 U6 g. V????????{' {4 w6 H  H: t+ C
????????????int?a,b;
4 V+ }* K5 L" F1 a4 a, s* u????????cout<<"请输入两个正整数:";
2 e2 O# S8 l% h% h4 [+ e????????cin>>a>>b;
0 c; ^' v& U( d+ M????????while(a<=0?||?__(1)___)?{cout<<"重新输入:";?cin>>a>>b;}- Z2 J, j7 Z- L5 S, n1 l4 x# h  q; [
????????while(b)?{8 E, A( ?1 c% w7 C2 U
????????int?r;
* |- ]/ c: z6 V! B) A& f/ `9 W????????????????r=ab;% q! C2 Y9 W# K! b0 S; t
????????___(2)___;?___(3)___;??//分别修改a和b的值( U: f# F& y6 G
????????}* b2 R" f, f# `3 o% c$ I. q# W
????????cout<<a<<endl;??//输出最大公约数0 ], e  S4 l$ D0 f2 ^$ ^' D
????????}35.?把从键盘上输入的一个大于等于3的整数分解为质因子的乘积。如输入24时得到的输出结果为“2?2?2?3”,输入50时得到的输出结果为“2?5?5”,输入37时得到的输出结果为“37”。
3 J% p" R- i6 x9 B????????#include<iostream.h>4 w, k2 {( {% K5 E+ b  r
????????void?main()
4 Q1 T! I8 m( \  B; @????????{
1 Q) n/ `( P" L# l* z7 M  ]????????int?x;# Z  v/ E, q# X6 b4 Z5 ^% t
????????cout<<"请输入一个整数,若小于3则重输:";3 W. \( B: W8 o$ z" P5 r5 i
????????do?cin>>x;?while(___(1)___);
+ s% ~3 u' }$ Y  J1 K+ S????????int?i=2;
  I8 y0 j% v, k3 t6 }8 e2 B, W????????do{
8 I8 a/ @$ b) d$ g????????while(___(2)___)?{4 n+ \4 ?/ K. u+ w* C( |: |
????????cout<<i<<?;
  U1 g/ @6 r( Y( I( S$ z8 `6 e????????x/=i;
& w4 m" B6 I/ n????????}
# _: G0 q! j5 X( E  y????????___(3)___;( T6 N/ }+ J7 ~7 B: o5 S  N( c
????????}while(i<x);
- b2 Y3 Q5 x3 e$ |????????if(x!=1)?cout<<x;?
- c. j0 `' f3 F% ~6 ]????????cout<<endl;
6 k$ P5 z# t& l  o+ s; `????????}36.?下面函数是求两个整型参数a和b的最小公倍数。
! s( P% T8 m  `" Z) w( f# l???????int?f2(int?a,?int?b)! d4 ^5 \+ p& K3 w6 G
???????{
2 u- B9 R0 S0 b# R???????int?i=2,?p=1;# Y; y/ W' h$ R' T: h& M
???????do?{: n  ~4 H0 u* l3 z
???????while(ai==0??___(1)___)?{' {7 H) [6 ?$ ^
???????p*=i;?a/=i;?b/=i;$ S. k5 C: M' J8 f
???????}  o/ N3 t9 S5 r5 ]  e
???????___(2)___;0 R+ |; C. M: X
???????}while(a>=i??___(3)___);
  z' ?8 H* W$ v???????return?p*a*b;2 o, c9 X4 H7 r$ V7 [
???????}/ \( O2 y/ S+ w* ?: M" `
37.?在输出屏幕上打印出一个由字符’*’组成的等腰三角形,该三角形的高为5行,从上到下每行的字符数依次为1,3,5,7,9。8 L% `" c! B5 [6 p& n% q
???????#include<iostream.h>
8 V: @% k- R7 }8 d$ S2 f???????void?main()+ F' V- A* ?8 t* g4 s
???????{; X4 W+ O. }$ Q$ h, w! y
???????int?i,j;$ d; c- A% {0 `; A# D" X6 b5 A
???????for(i=1;___(1)___;i++)?{! `' H( P# e! b' \% @' j) |
???????for(j=1;j<=9;j++)3 U/ Y! T% y1 Y% D" K6 P% M
???????if(j<=5-i?||?___(2)___)?cout<<’?’;
9 @% h$ T0 R4 [- t. V2 v1 p, y* C???????else?___(3)___;
0 C* n. ]' K% l2 m1 }8 }???????cout<<endl;
: A! w4 f; L  x9 P3 H???????}0 y0 `" t+ d. v! R  A5 U) T
???????}38.?统计字符串中英文字母个数的程序。
0 D% T, A  Z5 }9 m4 @  u2 E???????#include?<iostream.h>+ A: G4 e( o& l4 C$ `2 `
???????int?count?(char?str[]);8 r( h. P7 m3 k- H  L( G6 D% l6 M
???????void?main(){
" h+ U; |5 d+ \- T$ {- ~" b# x+ O???????????char?s1[80];
5 E5 V- \! V  f4 W2 j; K, t% l4 {???????????cout?<<”Enter?a?line:”;
/ g  l" p2 Z( k, [7 w???????????cin?>>s1;
7 {' q- a5 ~& h' C7 D???????????cout?<<”count=”<<count(s1)<<endl;
; L& E! `3 F! V4 U3 ?: |5 h+ P3 m???????}
* s: d4 G( C/ A" G) F9 Y8 ^/ K???????int?count(char?str[]){1 B. y: a: b2 I" c; B# H) S9 Q5 P
???????????int?num=0;??//给统计变量赋初值
* J; ]9 H9 O4 o8 |???????????for(int?i=0;str[i];i++), I: [( {1 X% w3 n( r3 G9 Z8 _
???????????if?(str[i]>=’a’??str[i]<=’z’?||___(1)___?): }9 B+ ~( Q6 s0 O0 g4 ]6 p, D
???????????????___(2)___;
, e6 |9 ]) I+ q% I???????___(3)___;
3 y1 @) g. K& k: b/ v0 a???????}39.?主函数调用一个fun函数将字符串逆序。
# b9 E' c" m/ y4 r2 v) P???#include<iostream.h>
6 a$ C' r$ b6 V+ {% ~7 f???????#include<string.h>& C/ T) V1 G/ O: u0 P
???___(1)___;
4 a5 L" T8 k% m+ l6 D  z???void?main(?)?{
  O) q. r# f# d# G* d+ i???????char?s[80];$ ?( H' R" I! a+ s$ J3 `3 e1 W
???????cin>>s;
; [7 M4 b# C% D: p2 G9 w???????___(2)___;
; B- q5 z$ d$ c' C0 d: l???????cout<<”逆序后的字符串:”<<s<<endl?;& l# C; H- A& M
???}
* ~' ]6 c) w- F: \???void?fun(char?ss[])?{2 h& a  f" B9 B$ D
???????int?n=strlen(ss);
" W; I, m6 `- I6 f???????for(int?i=0;?___(3)____;?i++)?{  s' d& m. b: b$ x) k7 N7 Q
??????????char?c=ss[i];
- r) _/ D4 c; _, R8 |* T) v??????????ss[i]=ss[n–1–i];
" X7 F3 P+ ]- x/ n# O??????????ss[n–1–i]=c;0 J' E' A/ y) c! j
???????}
; z, a& U1 h" i- {: t" r  m???????}40.?从一个字符串中删除所有同一个给定字符后得到一个新字符串并输出。
9 J& i/ Q+ n3 Z???????#include<iostream.h>& o4 h7 W  ?7 F7 u8 q& N- `
???????const?int?len=20;1 H& C4 v2 _9 E8 f1 I! c% C# K' I
???????void?delstr(char?a[],char?b[],char?c);
# R6 r5 M. `  t???????void?main()?{6 ^! E1 ?4 [) j
???????char?str1[len],str2[len];" c) M: c: C, z/ M7 ^
???????????char?ch;
: z/ P$ I' F9 q4 Y???????cout<<"输入一个字符串:";
) A) a/ U! `0 `  }0 _6 `+ C???????cin>>str1;( K! A' G# M4 |/ P& z
???????cout<<"输入一个待删除的字符:";?
% g' k9 ^7 O4 Y???????????cin>>ch;& l' s; j3 v. s8 b) B+ d& d$ k, C) u
???????delstr(str1,str2,ch);, ]* o7 W4 ~  C- a: X2 o
???????????cout<<str2<<endl;+ }$ Z1 g7 K# k, z" Z4 ?, n7 I5 O) l
???????}. Y* e: P  V! N# o) L7 O9 H- r8 k
???????void?delstr(char?a[],char?b[],char?c)! D7 P  F" U& T7 D+ \1 Q2 W
???????{
" r) y/ F5 s0 c* y???????int?j=0;: a5 E5 s, Y: A
???????for(int?i=0;?___(1)___;?i++)
: K, ]/ u1 N3 _+ t9 J# K  }???????if(___(2)___)?b[j++]=a[i];( m7 ]9 f! R8 e7 S
???????b[j]=___(2)___;
$ y: e/ c: O  a) W) P: g???????}41.?采用指针访问方式从键盘给数组a[N]输入数据,然后对元素值重新按逆序存放并输出。3 q# g% K: n1 ?- f- M" D
???????#include?<iostream.h>) g0 s0 s0 h; o. {0 [' ]. c7 U7 m
???????const?int?N=8;
9 i4 q7 N8 X, o/ r; |# {6 r5 I???????void?main()
+ f$ e3 |8 Y! T) ?, E???????{2 ~# k+ U9 X, V5 u6 G# C
???????????int?a[N],*p,*q;- a/ q- n6 ]7 u5 K2 Y% t
???????????for(p=a;?p<a+N;?p++)?___(1)___;
0 c- G& k+ N' }7 ~???????????p=a;q=a+N-1;0 z+ }  K. c' V
???????????while(p<q)?{3 R/ U; N+ _. Q7 O, n! T7 z
???????????int?r=*p;?*p=*q;?*q=r;
: a$ H! x0 S# v6 w???????????????___(2)___;?___(3)___;
- X' u; W: s% B  k! E- n" i" O- Y- [???????}3 t) Z7 s6 u* _2 u( _* x. f
???????????for(p=a;p<a+N;?p++)2 J. S' z$ w& A2 l" X! N5 V2 f0 z
???????????????cout<<*p<<?;
! y+ r" ?" t, j% p1 V, x, k???????????cout<<endl;
# V9 P, Y. j! N3 H???????}42.?从键盘上输入一个正整数,然后把它转换成的二进制数的每一位存放到一维数组中,最后输出该二进制数。注意二进制数的存放是按照从低位到高位的次序进行的。
; e0 N7 ^' j+ n/ ~: m4 R???????#include?<iostream.h>  P$ g( k& x# \; n- v7 j
???????void?main()2 p( B4 p% g* C# L
???????{
1 A! @1 G# b, D% ~???????int?x;
% }2 v7 P1 @  I???????????cout<<"输入一个整数:";/ t$ K- u, y. Y6 R
???????????cin>>x;5 A& U5 k& Y7 s0 ^  c
???????????int?a[20],k=0,r;/ s( d9 a# a5 D+ g' f  e. `8 q
???????????do?{0 y8 N+ v' P/ e* x# p
???????r=x2;/ Z' i6 t/ ]' E
???????????????a[k++]=r;# H0 {) R) _  Q6 f! F
???????????????x=___(1)___;
& W. t) F; j& e: f8 [% D* p???????}?while(___(2)___);
9 r8 \0 C6 W& V5 m???????????for(--k;k>=0;k--)?___(3)___;
; E( |# g$ A+ }# @* e???????????cout<<endl;
/ b6 W4 p& `7 i- C$ `( J. T???????}43.?对数组a[n]按升序进行的选择排序算法* n' t5 x6 s* ]2 T+ I0 v6 x
????????void?SelectSort(int?a[],?___(1)___)* a! g; i/ H- S
????????{
$ m& L& z# D) p????????int?i,j,k;, o7 t; @2 k+ x+ `
????????for(i=1;i<n;i++)?{??//进行n-1次选择和交换' e: h1 `, z7 s6 u& S
????????????????k=i-1;
/ ~: x- O8 m$ O( Q  L- C1 E: A1 _????????for(j=i;j<n;j++)3 m# z1 [( R; c  z
????????if(a[j]<a[k])?___(2)___;
0 b5 S6 @/ v' j' u3 M) P????????int?x=a[i-1];?a[i-1]=a[k];?___(3)___;
; f) X* }5 E- y$ H# p????????}
5 l0 d6 ~8 N1 o& f, Y5 q????????}?44.?对数组a[n]按升序进行的插入排序算法
$ s8 f$ d7 m4 N% l9 M, Q, x$ x????????void?InsertSort(___(1)___,?int?n)??/ {# q1 j4 l3 Z/ Y9 y7 s: R- @
????????{
3 b9 v# x+ r8 k: l/ V????????int?i,j,x;
( {4 t0 ~$ }6 |7 M- K0 j????????for(i=1;i<n;i++)?{??//进行n-1次循环
4 f% }+ b. y9 _( ]/ `2 ?????????????????x=a[i];! r8 @; }+ A" ?2 \6 ?3 j
????????for(j=i-1;j>=0;j--)??//为x顺序向前寻找合适的插入位置$ S3 [  S) ^& G, ]
????????if(x<a[j])?___(2)___;/ ?3 Y; }( B& ~8 ~8 A( Q$ Q
????????????????????else?___(3)___;
# ?7 C+ X' L) S- [: d$ n  y????????a[j+1]=x;??/ j& O/ Y3 i# Q: x0 B1 h! l
????????}, z* f" k; M; ?" L4 Y
????????}45.?对按从小到大排列的有序数组a[n]进行二分查找x的算法,若查找成功返回该元素下标,否则返回-1。
, X  d; L( t, N9 u1 {# e????????int?BinarySearch(int?a[],int?x)?
  f+ x0 l3 L  b6 X) C????????{; \4 J$ z! ~  f5 q! o4 e, R, K
????????int?low=0,?high=N-1;??//定义并初始化区间下界和上界变量) H$ u% x: G$ ]5 ]: h
????????int?mid;??//定义保存中点元素下标的变量
2 U( u7 I/ ]$ ^: A1 q% w????????while(low<=high)?{
; N1 H2 v! [2 _5 f. P- k' _4 I9 b????????mid=___(1)___;# V  o4 D* z8 H! h
????????if(x==a[mid])?___(2)___;& D' E4 ^. b0 A, k' n' \4 T$ ~7 @
????????else?if(x<a[mid])?high=mid-1;  K- E% W- e6 L3 g2 ~0 ]) s
????????else?___(3)___;
3 N/ I3 F! f* F+ Y% G+ Z????????}9 c$ G& r2 M0 q6 ]/ E
????????return?-1;
/ T5 H( O: D& n6 }7 P$ f) c6 M????????}46.?用插入排序方法对table指针数组中size个指针所指向的字符串进行按升序排序的算法。2 }) g9 g$ b/ w* o5 b
void?sort(char?*table[],?int?size){
1 e! a$ T8 l- a" p????for(int?i=1,___(1)___;?i++){& a- D7 Q2 h( s! e
????????char?*p=table[i];
3 F" P9 U/ ~. O; D: C7 X5 c????????for(int?j=i-1;?j>=0?;?j--)?
7 w3 v4 h" i+ I????????????if(strcmp(p,table[j])<0)?___(2)___;
" m* I, A8 ]% [7 t) T' k????????????else?break;
/ i% v" I  V7 Y) A( ?2 ]????????table[j+1]=___(3)___;
( r% b- h! j2 b5 F1 \* a????}
( \& X. \! g3 E0 i}47.?假定有定义为“struct?NODE{int?data;?NODE*?next;};”,下面算法根据table数组中的n个元素建立一个表头指针为L的链表,链表中结点值的顺序与数组元素值的顺序相同。
  R# q( F" k4 y) Svoid?f5(NODE*?L,?int?table[],?int?n)# x' \) E  D5 M- ~6 [* a7 Q
{??
; a7 _2 h1 y4 h1 \' L  J: Gif(n<=0)?{L=NULL;?return;}4 z# _+ s  q% q# g5 m* S3 L! t6 l
L=new?NODE;??//生成附加的头结点+ l, b9 {% j  E  M6 w7 _
int?i=0;?
/ X/ V2 I7 l; I5 P( K* \8 x! CNODE*?p=L;
7 M6 x* U5 w2 G! B' F) Q6 J- J  X7 Z! ywhile(___(1)___)?{, v' @6 L* I) s0 ~$ a& D) o3 K
p=p->next=___(2)___;, ~: }, ~% Y' O3 U; p, Q( k$ [7 P
p->data=___(3)___;
9 r" ]4 F; |% ~i++;
1 `3 `" X4 g5 n. v. d8 C6 [$ U}  I7 l. A/ {% L7 _9 r* l) I! u
p->next=NULL;??//把最后一个结点的指针域置空
8 s1 t, B. v, @$ Kp=L;; \3 a6 ]% Y4 Z+ }) z' O9 p
L=L->next;??//使L指向链表的第一个带值的结点
1 i% B! m) u5 c# G6 k) @' ^delete?p;
6 H1 i2 t8 T8 D4 u. a0 n}48.?假定有定义为“struct?NODE{int?data;?NODE*?next;};”,下面算法根据table数组中的n个元素建立一个表头指针为L的链表,链表中结点值的顺序与数组元素值的顺序正好相反。
) r" H1 ]' s' C- W4 C3 r! M9 ^void?f6(NODE*?L,?int?table[],?int?n)
* ?( H8 \* j% R# p( ?{??! `# ~' \' e5 g
L=NULL;3 m3 f. n6 T& w/ ^6 O5 g
if(n<=0)?return;9 E% q& v1 u* o- w5 y' j* l
int?i=0;?
1 T/ N2 f7 y% o* x7 i9 }& d# BNODE*?p;
  l7 K$ Y& y2 m% {" T, `* Q: n7 ywhile(___(1)___)?{
6 D4 Z3 O. p, B3 U2 gp=new?NODE;' T" Z  d& K$ }
p->data=___(2)___;) Z/ H! x0 W0 o6 v3 y+ h
p->next=L;
+ l$ F$ N* {8 r5 W___(3)___;
9 _" K2 [$ F6 Q# \; r- ii++;
8 H  @" n/ @1 ^0 U$ F, q4 J2 P, s! M}8 r; @7 v/ @0 F8 u' r
}49.?假定有定义为“struct?NODE{int?data;?NODE*?next;};”,下面算法是依次显示输出以L为表头指针的链表中各结点的值。' w8 N& @& W0 C
void?f7(NODE*?L)
6 l# w3 u1 j3 @  {& e{( j- i' V# [6 Q: t
for(___(1)___;?p!=NULL;?___(2)___)
5 l, V' y4 R1 q7 S4 Y' i4 O' ?cout<<___(3)___?<<?;* g: o% @' z! `# g. y" T; m
cout<<endl;; f$ c1 E6 z& ^; x* f$ H
}50.?假定有定义为“struct?NODE{int?data;?NODE*?next;};”,下面算法是把以L为表头指针的链表中各结点依次按相反次序链接并返回新链表的表头指针。
4 K% I" D; b# V: C6 ~2 TNODE*?f8(NODE*?L)' W$ [- D- d7 `0 w. m
{??
; ^1 u, o7 i5 F) sif(L==NULL)?return?NULL;% Y8 r0 z. B. n9 M# B
NODE?*p=NULL,?*q=L,?*t;
& j, B& w& b$ W8 ?: h; Q7 k+ Rwhile(q!=NULL)?{
! q) r1 T3 [' Z; [3 q, N2 `$ b: Yt=q;
2 e5 r- X0 y4 F) m" n' oq=___(1)___;
' L8 [% y9 |9 Y$ w3 W! Rt->next=___(2)___;8 y  k9 P4 P, Q( O, ?6 y. V2 C
p=t;. u, K9 f* V) F2 b; V* l
}1 ]' h/ _5 O9 K
___(3)___;
8 S6 _0 q4 q/ u4 \8 A}
% g+ @8 g& i( d: c$ N; h3 z7 M编程题:& i8 A/ j8 L& D( }% Q2 A9 V
编写一个递归函数计算(1+2+3+…+n)。2.输入N个整数,输出其中最大数。3.编写一个递归函数计算 。4.编写一个递归函数计算n!。5.输入N个整数,输出其中最小数。 6.编程计算100-200之间的素数。 7.编程计算下列级数的和:1-2+3-4+…..+(-1)n-1n。8.求一个N*N矩阵对角线元素的和。9.输入N个整数,按大小顺序排序。10.一个函数判断一个正整数是否为素数。  11.编写一个函数将一个数组中的值按逆序重现存放。12.编写程序,统计输入字符串中数字和其它字符的个数。13.编写函数计算一字符串的长度。14.编写函数将一个字符串接到另一个字符串后面。               15.编写程序计算下列级数的和:2+4+6+8+…+2n16.用程序验证100以内的奇整数,其平方被8整数余一。17.编程:设计一个自动转换公制和英制尺寸程序。已知一英尺为25.4cm。18.用公式"π/4 = 1 - 1/3 + 1/5 - 1/7 + 1/9+…"求π的近似值,直到最后一项的值小于10  ,并把结果输出到屏幕。19.编程求下列表达式的值: " Z, g. l3 s3 C$ S6 ^
100                50                10+ q0 @, ~9 C* g0 c1 `- X
∑ K +        ∑ K2 +        ∑ 1/K$ M0 Q/ o2 V) K0 O& f% k6 I
K=1                K=1                K=120.编写一个程序,将下列一组成绩{76,83,54,62,40,75,90,93,77,85,100}中的每一个成绩x,按x<60、60≤x<70、70≤x<80、80≤x<90、90≤x≤100五个区段分别统计人数,并把各个区段的人数输出到屏幕。21.有一个数列,它的第一项为0,第二项为1,以后每一项都是它的前两项之和,编程产生此数列的前20项,并按逆序显示出来。22.编写一个函数,按给定的半径r计算圆的面积a和周长c。用键盘输入r的值,计算a、c并输出到屏幕。23.一个数列它的第一项为1,第二项为2,以后第n项是第n-1项2倍和第n-2项之和,编程产生此数列的前10项,并显示出来。           24.有个三角形,三边为a,b,c,设s0=(p*(p-a)* (p-b) *(p-c)),其中p是周长的二分之一,三角形面积为s0的平方根。用键盘输入a,b,c的值,求出三角形面积并显示出来。25.输入三个数,输出最大者(要求用条件表达式)。26.把100至200之间的能被13整除的数输出。27.把100至200之间的能被23整除的数输出。28.输入三个数,输出最小者(要求用条件表达式)。29.求出从1990年至2020年的润年年份,并输出到屏幕;成为润年的条件是以下条件之一的年份:6 t8 E9 i% E6 y) c- o
①年份可以被400整除;
! p0 D/ X0 m" ~. i6 \# ~②年份可以被4整除,同时该年份不可以被100整除30.输入一个三位整数,倒序输出(例如,输入的是125,输出的是521)。31.输入一个字符,判别它是否为大写字母,若是将它转换成小写字母,若不是,不转换。然后输出最后得到的字符。  32.输出"百钱买百鸡"问题的所有解(问题是这样的:用100块钱买100只鸡,公鸡5元/只,母鸡3元/只,小鸡1元3只,问供给、母鸡、小鸡多少只)。33.求一个矩阵的转置矩阵。34.打印所有的水仙花数,所谓水仙花数是指一个三位数,其各位数字立方和等于该数本身。9 G: h0 ]  ^+ V& S
35.设计一个有公制转换到英制尺寸程序。已知一英尺为25.4cm。36.编写一个函数统计字符串中,某字符出现的频率。37.把100至200之间的能被7整除的数输出。38.将下列等级成绩:A:85~100; B:85~79; C:60~69: D:0~59; 表达成百分制分数段。39.编写程序,统计输入字符串中大写字母和其它字符的个数。40.把1000至2000之间的偶数且能被3整除的数输出。! M+ {5 E& ]: ~
第二章 类和对象4 Q5 Q) M7 F/ E+ X7 r  h
单项选择题:
( m4 u" V3 i3 y* s1.在下面存储类中, (    ) 对象的可见性与生存期不一致。  z1 s& P: E( @; G& j
A. 外部类            B. 自动类    C. 内部静态类            D. 寄存器类
. v# p0 t# G6 _9 K, M* I  N6 Z- c0 h2.在下面存储类中,(    )的对象不是局部变量。
. u$ T2 [, D: ?; H# r/ \# l+ U7 Q% Y9 cA. 外部静态类          B. 自动类    C. 函数形参           D. 寄存器类
; Y' U+ O+ a7 K* v& n/ Z3.栈具有(   )的操作特性。+ Q, ]: O1 N3 Q* ?
A. 先进先出      B. 先进后出      C. 进出无序      D. 进出任意! D0 `( Z1 h% Z4 u/ l
4.关于消息,下列说法中不正确的是(   )。$ X2 F/ H0 }0 F
A. 发送消息的对象请求服务,接受消息的对象提供服务# d4 [8 C" @4 R( z/ _" z. R
B. 消息的发送者必须了解消息的接收者如何相应消息, N0 V8 h( J  z+ v+ r
C. 在C++中,消息的发送具体体现为对接收消息的对象的某个函数的调用
& X  S' I) i$ `D. 每个对象只能接收某些特定格式的消息
( x; e; o' r" C, s' |6 T/ m* k5.关于封装,下列说法中不正确的是(   )。& e# R& D' X$ o. L  x4 Q
A. 通过封装,对象的全部属性和操作结合在一起,形成一个整体
$ J4 y! K2 k0 L% A8 ~% s1 @B. 通过封装,一个对象的实现细节被尽可能地隐藏起来(不可见). }- w; M: a  j% {  z+ B
C. 通过封装,每个对象都成为相对独立的实体4 P" ^/ N, g, |* I  d
D. 通过封装,对象的属性都是不可见的  M. A" _+ o" o% f2 X
6.面向对象方法的多态性是指(   )。' e4 G: o2 S  s3 [
A. 一个类可以派生出多个特殊类) B3 C- h- U2 J# L; p2 N" S1 H1 C
B. 一个对象在不同的运行环境中可以有不同的变体
3 q2 ?! U" V) s# r1 iC. 针对一消息,不同的对象可以以适合自身的方式加以响应6 i- @) S7 n- z2 @/ G" Y
D. 一个对象可以是由多个其他对象组合而成的
' C3 Y. o2 r% G" r6 c7.软件产品在需求发生变化、运行环境发生变化或发现软件产品本身的错误或不足时进行相应的软件更新的难易程度叫做软件的(    )。2 L0 A* B, W3 n7 J' i2 w; |- U
A. 可维护性          B. 可复用性    C. 兼容性            D. 正确性7 k, G4 \9 `. P( d9 k  _
8.软件产品可被全部或部分地再用于新的应用的能力叫做软件的(    )。
) r7 H( \/ O" j+ }6 ]A. 可维护性        B. 可复用性   C. 兼容性            D. 正确性& _( G: i7 \( m2 n  \
9.软件产品与其他软件产品组合成一个整体的难易程度叫做软件的(    )。
' {8 ^. J% C; m' F* jA. 可维护性          B. 可复用性    C. 兼容性            D. 正确性
5 A0 F' A- |" j, A: l! X, b8 Z( `10.软件产品准确执行软件需求规格说明书中所规定的任务的能力叫做软件的(    )。
1 z: }# Y3 F9 E2 ~; NA. 可维护性           B. 可复用性   C. 兼容性          D. 正确性
! a0 I. t! ]& F$ T2 q11.面向对象软件开发中使用的OOA表示(   )。
. ^4 N, c; n0 Z! g. nA. 面向对象分析          B. 面向对象设计   C. 面向对象语言           D. 面向对象方法
( U0 k3 z% a  M" `- Z+ b' e12.面向对象软件开发中使用的OOD表示(   )。
" [" _1 S" T/ n  _7 nA. 面向对象分析        B. 面向对象设计   C. 面向对象语言    D. 面向对象方法) Z0 \" o# f, I& W0 I% e9 |
13.关于面向对象系统分析,下列说法中不正确的是(    )。/ s6 d4 I/ ~& p% P1 ~
A. 术语“面向对象分析”可以用缩写OOA表示& u, X5 \4 L4 l  H7 h' Y" U$ s6 }
B. 面向对象分析阶段对问题域的描述比实现阶段更详细% H/ y! T% @2 C) R% z' f
C. 面向对象分析包括问题域分析和应用分析两个步骤* Q5 h3 V/ n8 \4 l! w
D. 面向对象分析需要识别对象的内部和外部特征
+ }& u0 O5 l5 X14.在一个类的定义中,包含有(   )成员的定义。
4 [2 U5 p2 r! I  ?. O! u- hA. 数据      B. 函数      C. 数据和函数      D. 数据或函数
; o) t9 c, U$ G: }) g15.在类作用域中能够通过直接使用该类的(   )成员名进行访问。
$ i# j( m4 ?* g4 ~1 h8 v0 {% C" iA. 私有      B. 公用      C. 保护      D. 任何
+ N- I8 e: ~. n, m' |  e16.在关键字public后面定义的成员为类的(   )成员。
; `9 |/ a6 m! s1 N& xA. 私有      B. 公用      C. 保护      D. 任何& w; G3 V& x/ n# L% u3 \) S, q$ u- Z
17.在关键字private后面定义的成员为类的(   )成员。
: c" l: ^0 ?( H! mA. 私有      B. 公用      C. 保护      D. 任何; Z" ~; }6 Q# m/ x
18.假定AA为一个类,a为该类公有的数据成员,x为该类的一个对象,则访问x对象中数据成员a的格式为(   )。+ r' j; K5 n0 {( ~3 S: R
A. x(a)      B. x[a]      C. x->a      D. x.a5 @; V. D4 K) A  W2 P2 f
19.假定AA为一个类,a()为该类公有的函数成员,x为该类的一个对象,则访问x对象中函数成员a()的格式为(   )。
0 X9 N& \. f5 G5 |A. x.a      B. x.a()      C. x->a      D. x->a()
8 m; v- B2 R: C+ e1 }# M  m20.假定AA为一个类,a为该类公有的数据成员,px为指向该类对象的一个指针,则访问px所指对象中数据成员a的格式为(   )。7 o7 g6 w& Y& F& x
A. px(a)    B. px[a]      C. px->a      D. px.a) T9 t. Y: a7 K
21.假定AA为一个类,a为该类私有的数据成员,GetValue()为该类公有函数成员,它返回a的值,x为该类的一个对象,则访问x对象中数据成员a的格式为(   )。* ]5 y( [$ n6 l8 h' {7 j
A. x.a      B. x.a()      C. x->GetValue()      D. x.GetValue()3 G: v* C. [& x: Y' ~& S6 R
22.假定AA为一个类,int a()为该类的一个成员函数,若该成员函数在类定义体外定义,则函数头为(   )。( M7 p) `$ F+ v2 m
A. int AA::a()           B. int AA:a()    C. AA::a()           D. AA::int a()3 w: J! Z7 i$ }8 [3 o- F* x0 y
23.假定AA为一个类,a为该类公有的数据成员,若要在该类的一个成员函数中访问它,则书写格式为(   )。5 T, R" Q* W7 P8 Y0 y, Z  ^
A. a        B. AA::a      C. a()      D. AA::a()
$ \- b1 w7 @, O' B! R24.若需要把一个类外定义的成员函数指明为内联函数,则必须把关键字(   )放在函数原型或函数头的前面。
7 s" c2 u* ~" G8 L. hA. in         B. inline      C. inLine      D. InLiner
2 r* w+ Z- Q  _- `! d3 U4 J. ]6 e25.在多文件结构的程序中,通常把类的定义单独存放于(   )中。
6 G! w. N5 `" t) K' P8 Q( JA. 主文件     B. 实现文件      C. 库文件      D. 头文件. @& ~* M( M) ?6 p
26.在多文件结构的程序中,通常把类中所有非内联函数的定义单独存放于(   )中。' n+ T; r+ c" y& `7 g+ e% L. O
A. 主文件     B. 实现文件      C. 库文件      D. 头文件
" Y2 v7 \1 _9 Z/ R27.在多文件结构的程序中,通常把含有main()函数的文件称为(   )。
1 ?* u2 M6 _7 v- E0 j2 j3 PA. 主文件      B. 实现文件      C. 程序文件      D. 头文件( `; b7 J: e" R  D4 C+ V: W9 T
28.一个C++程序文件的扩展名为(   )。
) u9 Z+ i+ }4 Q' f3 ]* e; ?" LA. .h          B. .c           C. .cpp      D. .cp
& z6 D$ D  p6 P29.在C++程序中使用的cin标识符是系统类库中定义的(   )类中的一个对象。
. a3 T' d( I8 ~1 Q) ~3 uA. istream      B. ostream      C. iostream      D. fstream
. [- s1 e+ j0 ]% T5 S9 Q30.在C++程序中使用的cout标识符是系统类库中定义的(   )类中的一个对象。) X/ x8 I& s7 _, ^, Q1 f
A. istream      B. ostream      C. iostream      D. fstream
. b; e6 D: _7 _% r0 ^% b5 T31.假定AA是一个类,abc是该类的一个成员函数,则参数表中隐含的第一个参数的类型为(   )。
2 P! a5 Y! N, Y1 A: m8 ~A. int          B. char         C. AA            D. AA*+ K" R4 ^( A$ f; x. q
32.假定AA是一个类,abc是该类的一个成员函数,则参数表中隐含的第一个参数为(   )。
. [, V' P1 ~% P" H* \0 `A. abc           B. *this      C. this      D. this&
0 f* V8 Z' r! T1 r33.假定AA是一个类,“AA& abc();”是该类中一个成员函数的原型,若该函数存在对*this赋值的语句,当用x.abc()调用该成员函数后,x的值(   )。9 P; S/ c- o7 _4 n+ k1 E
A. 已经被改变        B. 可能被改变    C. 不变           D.不受函数调用的影响
* |0 b$ N2 r0 R. P+ [: C. P34.假定AA是一个类,“AA* abc()const;”是该类中一个成员函数的原型,若该函数返回this值,当用x.abc()调用该成员函数后,x的值(   )。
& u& m8 o. }: _. xA. 已经被改变           B. 可能被改变    C. 不变           D. 受到函数调用的影响3 z  }& [: F9 v8 ]9 B' ^
35.类中定义的成员默认为(   )访问属性。' F' t0 D9 C4 V- O! d, v( ]
A. public      B. private      C. protected      D. friend: M% L; P% e/ T) ~  m
36.结构中定义的成员默认为(   )访问属性。
' U, }8 C% |( ?A. public      B. private      C. protected      D. friend
' w8 Q! W) l: H# s37.当类中一个字符指针成员指向具有n个字节的存储空间时,它所能存储字符串的最大长度为(   )。
% ?, p) D* E' @% }5 tA. n           B. n+1          C. n-1            D. n-24 o, d1 I; v& J7 [5 U- c0 a
38.在一个用数组实现的队列类中,假定数组长度为MS,队首元素位置为first,队列长度为length,则队尾(即最后一个)元素的位置为(   )。
( Y$ e8 O+ m1 ]$ j" ^A. length+1                                  B. first+length
! x+ O' {8 t3 f. m5 R/ N7 u3 j' iC. (first+length-1)%MS                      D. (first+length)%MS' L( e2 \$ @% A3 _4 }$ q6 l6 a
39.在一个用数组实现的队列类中,假定数组长度为MS,队首元素位置为first,队列长度为length,则队尾的后一个位置为(   )。
6 A; v  N6 U  H9 I5 T* lA. length+1          B. first+length     C. (first+length-1)%MS           D. (first+length)%MS
  H6 O' h8 X/ B$ e6 ^( B% r40.在一个用数组实现的队列类中,假定数组长度为MS,队首元素位置为first,队列长度为length,则队首的后一个位置为(   )。
. s. k/ X7 Y. k. h* IA. first+1           B. (first+1)%MS     C. (first-1)%MS             D. (first+length)%MS
( W6 R" F. Y  R  l* R1 X9 n* n41.在一个用链表实现的队列类中,假定每个结点包含的值域用elem表示,包含的指针域用next表示,链队的队首指针用elemHead表示,队尾指针用elemTail表示,若链队非空,则进行插入时必须把新结点的地址赋给(   )。
$ n& j4 V1 ?; c2 D' d9 tA. elemHead                              B. elemTail+ \( I7 }7 V8 ^5 U; u
C. elemHead->next和elemHead                D. elemTail->next和elemTail( X# M" D. d$ B' ^* Y
42.在一个用链表实现的队列类中,假定每个结点包含的值域用elem表示,包含的指针域用next表示,链队的队首指针用elemHead表示,队尾指针用elemTail表示,若链队为空,则进行插入时必须把新结点的地址赋给(   )。% d3 ~+ N4 a$ @( Z8 A' \+ W3 S
A. elemHead                                        B. elemTail
* T! l6 D9 t; XC. elemHead和elemTail                             D. elemHead或elemTail1 [) e- j& J. i7 r
43.队列具有(   )的操作特性。+ R; b6 U$ |5 \& s9 u
A. 先进先出      B. 先进后出      C. 进出无序      D. 进出任意填空题:" M4 @  ^) B  n) Z% s% i
1.?在一个用链表实现的队列类中,若链队为空或只含有一个结点,则队首指针的值与队尾指针的值(  )。" u- \3 c6 o8 I$ P% h
2.?在一个用链表实现的队列类中,若队首指针与队尾指针的值不同,则说明链队中至少包含有(  )个结点。* H4 _4 l" A1 ~' _2 b4 D) M7 s
3.?以面向对象方法构造的系统,其基本单位是(  )。
5 R0 e; |  W6 q& {" Q4.?每个对象都是所属类的一个(  )。
% z3 r' S: X) D+ B: r) y0 e5.?对象将其大部分实现细节隐藏起来,这种机制称为(  )。
, V* K8 N$ H# o7 L5 Y' K: o. V, ]6.?基类和派生类的关系称为(  )。
) \# O5 \0 X- m: n) Q: ]; T7.?复杂对象可以由简单对象构成,这种现象称为(  )。
" ]7 J0 m& j' Y7 R, z* t) x/ Y8.?对象是对问题域中客观事物的( 抽象 ),它是一组属性和在这些属性上操作的(  )。/ s9 |, i5 J3 i, y, T
9.?特殊类的对象拥有其一般类的全部属性与操作,称特殊类(  )了一般类。
6 B9 ^* x5 z4 L# N0 T10.?如果一个派生类的基类不止一个,则这种继承称为( 继承多继承( )。6 x6 ^. {) t# @; g3 ?2 e) [
11.?如果一个派生类只有一个唯一的基类,则这样的继承关系称为(  )。3 T# H8 o# ?6 N
12.?C++支持两种多态性:(  )时的多态性和(  )时的多态性。' p$ e! r; u- ]0 R+ Q( a# n
13.?在C++中,编译时的多态性是通过(  )实现的,而运行时的多态性则是通过(  )实现的。
  Y! U. V1 j7 y' s1 \. g" ?14.?面向对象软件开发的生命周期分为三个阶段,即分析、(  )和(  )。
& n3 T0 o  m* k- [15.?面向对象的分析包括(  )分析和(  )分析两步。
" A5 w4 \9 Y4 ?$ ]0 ?% l. n( k16.?类定义中,既包含数据成员,也包含(  )成员。
: i9 m2 g& ^1 @0 u17.?类中的数据成员的访问属性通常被指明为(  )。# s; u! K9 Y3 V/ x1 e0 a% e& V5 X1 i
18.?类中的供外部调用定义的函数成员,其访问属性通常被定义为(  )。
  L$ h2 Q; N, s5 c6 o19.?对于类中定义的任何成员,其隐含访问权限为(     )。& ?- g& g/ a: X9 F) L5 B7 a
20.?对于结构中定义的任何成员,其隐含访问权限为(      )。4 e* d3 Q: h- S# r4 _
21.?为了使类中的成员不能被类外的函数通过成员操作符访问,则应把该成员的访问权限定义为(  )。?
( {3 z; S8 i" B/ `2 v- S22.?若在类的定义体中给出了一个成员函数的完整定义,则该函数属于(   )函数。
0 k5 Y: K: D" O# c' K$ ]8 i5 H+ o23.?若在类的定义体中只给出了一个成员函数的原型,则在类外给出完整定义时,其函数名前必须加上(     )和两个冒号分隔符。
3 B* r  [3 g, ?24.?若在类的定义体中只给出了一个成员函数的原型,则在类外给出完整定义时,其函数名前必须加上类名和两个(  )分隔符。: {% T- _( P1 ]1 T" C4 s0 Q
25.?若要把类外定义的成员函数规定为内联函数,则必须把(    )关键字放到函数原型或函数头的前面。?
% u( |6 A$ f& }4 w) Y26.?把一个类的定义体和所有成员函数的定义体所构成的程序范围叫做该类的( )。# U* b% b5 _/ |* F# m
27.?假定AA是一个类,“AA*?abc();”是该类中一个成员函数的原型,则在类外定义时的函数头为(  )。
2 l) q9 b9 C1 O+ _( g$ j  p/ e28.?成员函数的参数表在类作用域中,成员函数的返回值类型(  )类作用域中。
/ \0 [8 C4 D# W2 i29.?为了避免在调用成员函数时修改对象中的任何数据成员,则应在定义该成员函数时,在函数头的后面加上(    )关键字。?4 |$ X( v& E" ^5 E; @
30.?若只需要通过一个成员函数读取数据成员的值,而不需要修改它,则应在函数头的后面加上(  )关键字。?
+ [+ ^& r" r' ]. `$ a31.?若采用x.abc(y)表达式调用一个成员函数,在成员函数中使用的(  )就代表了类外的x对象。?
0 c3 f1 Z' q. D* S% }; I32.?若采用p->abc(y)表达式调用一个成员函数,在成员函数中使用的(    )就代表了类外的p指针。?; l$ N+ @$ J6 J/ ~0 u
33.?内联函数的定义模块与(  )模块必须放在同一个文件中。
& @9 y5 Z* U+ X; ?& ?34.假定AA是一个类,“AA*?abc()const;”是该类中一个成员函数的原型,在该函数体中(   )(     )向*this或其成员赋值。
7 O6 b$ U4 {* a6 _$ m5 B& V35.在一个用数组实现的队列类中,包含有两个数据成员,一个指明队首元素位置,另一个指明(  )。+ L5 [' @! g+ W: k# `! @! k
36.?在一个用数组实现的队列类中,包含有两个数据成员,一个指明队列长度,另一个指明(  )元素的位置。. [* Q: h* ^( v; H/ B% a- ?( _3 m
37.?在一个用数组实现的队列类中,假定数组长度为MS,队首元素位置为first,队列长度为length,则插入一个新元素的位置为(  )。
2 O: M( p5 ]3 y& y" I4 a38.?在一个用数组实现的队列类中,假定数组长度为MS,队首元素位置为first,队列长度为length,则删除一个元素后队首的位置为(    )。
2 N0 e; r9 f* A39.?在一个用数组实现的队列类中,假定数组长度为MS,队首元素位置为first,队列长度为length,则队列为空的条件为(  )。# A$ ?) `5 `: R* j  r! p1 X
40.?在一个用数组实现的队列类中,假定数组长度为MS,队首元素位置为first,队列长度为length,则队列为满的条件为(    )。
, A! @6 I# Q! d41.?当一个队列为空时,不能对其做(  )元素的操作。
( c8 c7 g5 s/ j* S42.?当一个队列为满时,不能对其做(  )元素的操作。
. _2 j2 u8 n1 `6 U5 E/ r1 B9 s43.从一个队列中删除元素就是删除(  )位置上的元素。
" y: f% i2 a1 }8 P3 _* `# }44.向一个队列中插入元素就是把该元素放到(   )元素的后一位置上。! t! A" e. N  C' y5 q, p
45.在一个用链表实现的队列类中,假定每个结点包含的值域用elem表示,包含的指针域用next表示,链队的队首指针用elemHead表示,队尾指针用elemTail表示,当链队非空时,(    )指向队首结点的后继(   )结点。
) g& c/ [+ ]( Q% C46.?在一个用链表实现的队列类中,假定每个结点包含的值域用elem表示,包含的指针域用next表示,链队的队首指针用elemHead表示,队尾指针用elemTail表示,当链队非空时,新插入结点的地址应当赋给(    )所指结点的next域。
" ~8 K4 P: }( y! |47.?在一个用链表实现的队列类中,队尾结点的指针域的值为(     )。; e# k- t: _, S# ]0 K
48.?在一个用链表实现的队列类中,若链队中只含有一个结点,则队首指针的值与队尾指针的值(    )。简答题:
  @* B  Q) M. r% H9 o文件包含预编译指令#include ,有那两种格式,它们有什么区别?简述面向对象程序设计方法相对于面向过程的程序设计方法的优越性。简述什么是类,并举例说明。简述什么是对象,并举例说明。简述C中结构与C++中类的区别。简述C++中类的成员函数的三种访问方法。简述类和对象的区别与联系并举例说明。简述类对其成员的三种存储控制及作用结果。简述C++程序在内存中的分配格局。简述 C和C++动态内存的使用。简述什么是先期联编,什么是迟后联编。* H7 f9 L# W, ^, I# A) A- z( h3 q( Q
程序填空题:
* g3 z! J  O& Y4 p, }; f8 c?1.?已知一个类的定义如下:' h' i- O1 p5 |
#include<iostream.h>
! Q! @: `, f  Y8 o; b) k! t7 ]0 i( b2 bclass?AA?{
# u$ I, z7 z0 R* S. Eint?a[10];
8 H; W% F' o2 N6 iint?n;
3 e% u' G( L9 ppublic:* E- L5 Y' o  N, j5 h
void?SetA(int?aa[],?int?nn);?//用数组aa初始化数据成员a,
, u" ]( k# q6 \' B?????????????????????????????//用nn初始化数据成员n
- g0 u0 D- R4 U' e; Uint?MaxA();??//从数组a中前n个元素中查找最大值
- R8 }- Z5 O7 W# H; C9 {6 r; Nvoid?SortA();??//采用选择排序的方法对数组a中前n个元素  o6 o  y8 J* c  H% ~; g
???????????????//进行从小到大排序, z% o7 W, M, G1 H% n6 r
????void?InsertA();//采用插入排序的方法对数组a中前n个元素进行从小到大排序1 W$ J% ~7 L$ q' |% a
void?PrintA();??//依次输出数组a中的前n个元素5 D0 K) e" ]% [
};????该类中MaxA()函数的实现如下,请在标号位置补充适当的内容。- J5 \+ Z3 d( n% w
int?____(1)_____?
% }+ l$ @) W5 o' q$ h6 E, G{
- V5 E. j; Y. t. {. B$ {0 ~: Z0 Nint?x=a[0];0 \1 _2 O0 b4 S2 \5 z5 S1 R
for(int?i=1;?i<n;?i++)?
7 c" q2 j) ~. sif(a[i]>x)?___(2)___;
" n- J% c; s: K- e___(3)___;+ p+ }; K, x: o( `, S
}2.?已知一个类的定义如下:2 o* i% b7 o% E, x$ q
#include<iostream.h>  t5 C( S9 E6 Z; a
class?AA?{
" @( X6 I& y* @5 e, ?( y5 d9 j* jint?a[10];
  }$ Y! ~0 ]4 x: Vint?n;
' [+ i% g6 O$ tpublic:& ~6 w. M( u. ]- D; A
void?SetA(int?aa[],?int?nn);?//用数组aa初始化数据成员a,% ~0 Q" K8 ]0 D$ E7 u3 [: U& S, E
?????????????????????????????//用nn初始化数据成员n( A4 ~, ?) A& E+ P
int?MaxA();??//从数组a中前n个元素中查找最大值
3 Q! ^2 f/ {% {+ P3 L7 |4 gvoid?SortA();??//采用选择排序的方法对数组a中前n个元素
" |8 ^, R/ [& M8 Q+ Y0 ~???????????????//进行从小到大排序
& \( \0 D/ U8 ]# Z: X????void?InsertA();//采用插入排序的方法对数组a中前n个元素进行从小到大排序
' p1 V5 i3 _4 r% a! fvoid?PrintA();??//依次输出数组a中的前n个元素
7 n% q) S7 b, H$ l! ^};void?AA::SortA()) ?4 m& t1 L; p, M8 E" ?
{, M# D1 i% |4 x- P. J
int?i,j;4 S, ^) h* W2 R
for(i=0;?___(1)___;?i++)?{1 N% L' u$ n+ ~/ D
int?x=a[i],?k=i;# W* t/ C& P" U/ ?9 _# F  |5 d! \
for(j=i+1;?j<n;?j++)
0 e+ |$ \+ L) |" \% H, P8 U; L. cif(a[j]<x)?___(2)___3 j' r( k8 {1 L0 _
a[k]=a[i];6 L, }) e$ Q2 r# _( E. Y* f
___(3)___;* g" B8 M3 b5 e: w
}
/ J" B' L* J9 M: `' u3 i0 |7 P}3.?已知一个类的定义如下:$ |. h+ d; Y- ]; M. z( A
#include<iostream.h>$ m( u8 c: J$ b4 j8 W! n, h- Y
class?AA?{1 W0 x' W3 s! y5 ^: @
int?a[10];+ G7 w+ |3 K3 Q- {1 ~# n
int?n;
& _9 O* a; d' F9 |2 r2 |- w# }public:
0 i9 p7 @- E6 `8 Q9 o: Svoid?SetA(int?aa[],?int?nn);?//用数组aa初始化数据成员a,0 B; `0 L  x3 Q% y/ R
?????????????????????????????//用nn初始化数据成员n
7 X5 b" b4 V; i* j! @0 f/ yint?MaxA();??//从数组a中前n个元素中查找最大值
# Z# P; w3 F7 ]# N8 c1 j  Z8 wvoid?SortA();??//采用选择排序的方法对数组a中前n个元素/ h: l, C# P+ E
???????????????//进行从小到大排序
. x2 l! \& X5 z3 ?????void?InsertA();//采用插入排序的方法对数组a中前n个元素进行从小到大排序3 R! S8 F2 m& n. w- |4 U
void?PrintA();??//依次输出数组a中的前n个元素/ n6 `3 Q' \5 W
};void?___(1)___?
4 ~3 E* S: h4 G/ L# ^2 [6 q7 y& x{
& D2 [7 T' X' _/ M$ `; Q2 _int?i,j;' H) a; f* u- u* I9 l3 a; {! i
for(i=1;?i<n;?i++)?{- K2 Y) h& G# p; W6 o
int?x=a[i];- U. ?) m1 q8 g/ L0 u
for(j=i-1;?j>=0;?j--)
, w0 q+ X: ~0 Gif(x<a[j])?___(2)___;. q# n/ T6 t: P4 S, O/ ~5 f  E
else?___(3)___;5 E, r4 G; H9 p0 F( U. H' j9 B
a[j+1]=x;  L- y8 h, \' ]7 A8 _4 }
}. R4 C; o% A% D  b9 j& j/ o
}4.?已知一个类的定义如下:
, W' ^- A% H; ?#include<iostream.h>
; q# p9 H3 I8 X3 \1 i+ x3 r2 ^" \: }% vclass?AA?{
% l% j( H1 |5 @2 H( Zint?a[10];
8 t% R8 @5 _/ c1 F. Lint?n;
5 G* i& a* h8 v. R- L% Lpublic:4 a% A$ A, P( I! Q5 L
void?SetA(int?aa[],?int?nn);?//用数组aa初始化数据成员a,) U' ]3 N" B- y! D+ f5 h$ B* L9 G
?????????????????????????????//用nn初始化数据成员n7 K0 C% G# w7 Y
int?MaxA();??//从数组a中前n个元素中查找最大值0 D+ `# o- \( q. O& {, v' s
void?SortA();??//采用选择排序的方法对数组a中前n个元素8 Q: U* \0 y8 b7 g# l( e
???????????????//进行从小到大排序
6 P! X- h" K# S6 I  |# v7 c% q????void?InsertA();//采用插入排序的方法对数组a中前n个元素进行从小到大排序
9 \# x+ P, w* D) evoid?PrintA();??//依次输出数组a中的前n个元素
% u3 r) I3 E/ D6 o- B4 X4 W9 B0 X????????????????????//最后输出一个换行; {2 X- ^# u  |5 ~- R& n  q
};????使用该类的主函数如下:1 I3 T0 U0 I6 [% e8 b& r$ e' R
void?main()
4 `4 G& a- c. W: c$ I{
, D5 _0 l. ]. qint?a[10]={23,78,46,55,62,76,90,25,38,42};
+ ]2 v. x( f* n" cAA?x;??) V  n& Y" _, y3 O; ~/ D
___(1)___;! Q; D  G3 S* ]
int?m=___(2)___;) b6 B3 x8 @7 P
___(3)___;7 h, t  D8 B& m
cout<<m<<endl;
3 k; P" P& ]4 R! S7 c6 u7 ~}
' ^, y5 s1 l9 ^????该程序运行结果为:
# G9 ^; E. k6 [% V7 N7 a, G$ ]23?78?46?55?62?76
3 S$ {# ?6 F4 z: Y; V785.?已知一个类的定义如下:" n* O6 ^( b# J
#include<iostream.h>
' l2 p3 Q+ X  X( A: D6 }/ Sclass?AA?{
; ?% H8 u5 z0 _/ m( H( _int?a[10];( Z1 o. S- j0 ^" }, X% T; `* b0 n
int?n;" h" [) r) ~9 f. S8 R# K+ i
public:: c( b1 D; i# j. E
void?SetA(int?aa[],?int?nn);?//用数组aa初始化数据成员a,0 A9 B+ F7 a6 _( L+ x
?????????????????????????????//用nn初始化数据成员n0 ^5 p+ _$ w6 I  U
int?MaxA();??//从数组a中前n个元素中查找最大值
6 E" {$ Y% P3 u( f2 Vvoid?SortA();??//采用选择排序的方法对数组a中前n个元素
: I' d9 ?) y, W6 Y. s5 V5 g9 g# n???????????????//进行从小到大排序
. C9 ]% r3 R- H3 i- [8 o$ Lvoid?PrintA();??//依次输出数组a中的前n个元素,9 I' R: K  V# z
????????????????????//最后输出一个换行' i* ?+ D: }  G
};????使用该类的主函数如下:
( R- I1 c  J# f! l+ e: b7 Cvoid?main()0 p6 b4 I( \! L
{& r9 J7 T7 m: t
int?a[10]={23,78,46,55,62,76,90,25,38,42};
" d2 V1 w7 ]$ L5 I% T$ D___(1)___;??# l: h4 D2 T* I( A
x.SetA(a,8);- y+ A; t$ L  L$ H9 r
int?___(2)___;1 j5 @% j" x( h: ?$ ?+ A$ _/ T
___(3)___;
5 j4 q& f# [1 ax.PrintA();
3 r' @) }: a5 J: k+ p1 G/ V, w8 O????cout<<m<<endl;  k+ j6 l' Q- A
}????该程序运行结果为:
" |+ V* S0 A, }; r, j1 E* m& o23?25?46?55?62?76?78?90
  ^; M) n& E/ s906.?已知一个利用数组实现栈的类定义如下:
  x$ ^( ?) N2 A# s5 }3 ]% Aconst?int?ARRAY_SIZE=10;
2 W; A# \) b! f- _( k! Wclass?Stack?{
  g5 T8 ~/ Q( J4 ], R0 E0 Opublic:7 a+ }8 ~% G3 g; G. F, [9 I# n6 C
void?Init()?{top=-1;}???????//初始化栈为空
0 t! m( {; K; b, R????void?Push(int?newElem);?????//向栈中压入一个元素
& B4 C8 y  a) x; G% K3 n+ Xint?Pop();??????????????????//从栈顶弹出一个元素. M1 c+ l0 n% K6 i
bool?Empty()?{??//判栈空3 j' L/ \; u& A: `: \9 |; V$ S0 @
????????if(top==-1)?return?true;else?return?false;}
: b8 a+ T/ @  [int?Depth()?{return?top+1;}??//返回栈的深度0 L- a4 W  Y: }7 P$ o
void?Print();??
  Y. i% e# j+ c????????//按照后进先出原则依次输出栈中每个元素,直到栈空为止
4 g+ O! j, t/ \. Q+ Y/ ^private:
: x( U. f( Q# wint?elem[ARRAY_SIZE];??//用于保存栈元素的数组3 p- c3 O; |+ f8 ?1 T5 _
int?top;???????????????//指明栈顶元素位置的指针$ W/ y9 p" [  N3 T$ Z
};void?Stack:ush(int?newElem)?{' \5 Y* F, T( G3 t  _! U( s
if(___(1)___)?{?/ `, F" X: Q" L# G2 L) A  z9 e! @  w! a6 i* |
cout<<"栈满!"<<endl;, a6 j3 b7 i  b# g# J* ]
exit(1);??//中止运行3 D2 n/ E6 i( @" e
}
- t3 e0 O( Q( P___(2)___;
7 A0 e- f  a7 M! lelem[top]=___(3)___;" ~4 {8 e3 k9 i4 @9 o2 n
}7.?已知一个利用数组实现栈的类定义如下:
; w- D8 G1 i2 M. Cconst?int?ARRAY_SIZE=10;
3 I7 ^9 R0 D6 P: n% H, ?# X; Z9 v' ^class?Stack?{
$ ^% w' y' b  B9 i! P9 apublic:
" |. v' [' T9 d3 }+ k9 q$ t0 W. C9 f! Q7 Vvoid?Init()?{top=-1;}?????//初始化栈为空
2 j. k3 J7 C4 `5 I" u6 Y0 R????void?Push(int?newElem);???//向栈中压入一个元素
# z' l4 Q3 M1 M) Wint?Pop();????????????????//从栈顶弹出一个元素) |9 N1 H7 S; c* U! t* o
bool?Empty()?{??//判栈空
2 K7 G. j) w4 V! L3 z????????if(top==-1)?return?true;else?return?false;}
5 X" o9 K- {8 [; q8 Lint?Depth()?{return?top+1;}??//返回栈的深度: D, U$ }8 S7 ]; |/ O. E
void?Print();??
& y; `- X& E8 U& k) ?( i0 m, c# @????????//按照后进先出原则依次输出栈中每个元素,直到栈空为止( g0 c# i, _; z
private:
. I& C/ q. a7 Y3 M7 \2 e% E/ wint?elem[ARRAY_SIZE];??//用于保存堆栈元素的数组. e4 g0 I3 V: z2 b' [; V/ O6 Q# a! X
int?top;???????????????//指明栈顶元素位置的指针0 o  W# ~3 l& ]3 z5 E6 a
};????该类的Pop和Print函数的实现分别如下:3 g2 e. c; P7 q/ V
___(1)___?{
. r: o6 K7 {/ Rif(top==-1)?{, O" Q7 g* L: {" ]! Q0 Z1 C( Q
cout<<"栈空!"<<endl;1 q6 P! L' k: ~9 f' Z! L0 i' r# ^
exit(1);??//中止运行0 C6 L2 w4 o4 v1 X
}9 I% L& c# \; b7 R- k
return?___(2)___;. L4 ?" }/ `" n; u# o7 l3 r
}void?Stack:rint()?{1 ~4 }) f. w% e; M. a2 S3 r9 w
while(!Empty())?
( l1 w+ ~% t2 z2 X6 I3 B- P4 }cout<<___(3)___?<<?;
. F% n9 Z, r) V) _}写出程序的执行结果:
, V3 b& q; u2 d" B( M程序设计与分析题:" a* w* I) ~) t! ?
1.?根据下面类中Count函数成员的原型和注释写出它的类外定义。(﹡﹡﹡)
* j9 v+ ^% d* u! L7 I" Tclass?AA?{% s$ z" T+ P! }. }5 m& t, P/ [. z& s
int*?a;: B  M" q4 w, }/ V2 s, s
int?n;7 Y8 t/ b1 @4 j8 Z
int?MS;
5 n& I6 Q" ~0 A+ _* \- C2 Vpublic:" e  N- u' U% k  w7 Z; Z3 X! [
void?InitAA(int?aa[],?int?nn,?int?ms)?{
# Y6 W% F+ L: Q9 Rif(nn>ms)?{cout<<"Error!"<<endl;?exit(1);}/ O5 N+ J! u1 |
MS=ms;
& B& C3 w6 {" H; i& Z4 Yn=nn;
7 X/ h2 _* y% c( o+ q7 x  Za=new?int[MS];
+ D8 I% Q" c2 @9 }5 f9 Y& Afor(int?i=0;?i<MS;?i++)?a[i]=aa[i];) B! w$ g  |$ `% A
}0 n! ~+ d$ K) W- r
int?Count(int?x);??//从数组a的前n个元素中统计出其- W  E9 o: ?( R* \
???????????????????????//值等于x的个数并返回。' Q$ m/ ^! W, r2 _; a; F
};2.?根据下面类中Search函数成员的原型和注释写出它的类外定义。(﹡﹡﹡)
1 {& F( |. E. ~0 o3 Hclass?AA?{
" W) t8 `" O! R9 Hint*?a;- S0 R1 ^7 h4 O) I% |# f; s7 j3 u
int?n;# t! U1 d+ p3 M5 Y. k- u; k
int?MS;
  m2 y( {* C2 K- G2 }  T4 Fpublic:
- d# v) w. M3 \1 c5 g) Rvoid?InitAA(int?aa[],?int?nn,?int?ms)?{+ }: `; S' X% z; S; O: N
if(nn>ms)?{cout<<"Error!"<<endl;?exit(1);}
3 N4 h4 T. m- ?8 U+ sMS=ms;
1 n! X7 H: `* x. H5 K0 e* b. M" ^# {n=nn;  s, t3 ~, U/ j4 f( H. Q
a=new?int[MS];8 ?8 Z( i8 j4 R* K, J" [$ x9 b  m% o
for(int?i=0;?i<MS;?i++)?a[i]=aa[i];
7 e8 F% H+ @% M) G& a: X: Y; c}
  Y- o. I2 C& s+ Q) ]9 i- o! \2 {% l????int?Search(int?x);?//从数组a的前n个元素中顺序查找值为x的元素,
# d! Q$ ^* w4 v& ^) o! [: y7 g! g???????????????????//若查找成功则返回元素的下标,否则返回-1。# E1 N5 o; C+ j/ e6 v; }) a. F
};3.?根据下面类中MaxMin?函数成员的原型和注释写出它的类外定义。(﹡﹡﹡)
& Z' T! h1 Z: V, xclass?AA?{/ z) T( {4 x( @8 F
int*?a;
9 V4 T! b6 J1 L! C7 Jint?n;
* Y" `) Q# T8 a4 v0 |% ]int?MS;
1 U5 {* v5 H. N9 u% vpublic:
- l$ w5 l+ U. B) Dvoid?InitAA(int?aa[],?int?nn,?int?ms)?{9 u6 T6 V' K# o8 ?$ M8 Z
if(nn>ms)?{cout<<"Error!"<<endl;?exit(1);}
* l, _+ G& F  _$ U: S. sMS=ms;" E5 |0 w2 A2 T9 S+ s
n=nn;3 a' U0 N# u+ k4 k, j
a=new?int[MS];
! L& v! W2 e  `+ @4 ifor(int?i=0;?i<MS;?i++)?a[i]=aa[i];& i9 e! b! B# ]
}
) H7 p- l1 J# W9 }  r* h1 b  ]* |) yint?MaxMin(int?x,?int?y);?//从数组a的前n个元素中求出
8 j5 v7 ?1 `2 \( i?????????//最大值和最小值,并分别由引用参数x和y带回,) h5 o2 W- ^# W( k4 u% p2 \
?????????//同时若n大于0则返回1,否则返回0。0 u$ I, V& B/ n' }/ m" f1 y
};4.?根据下面类中Compare?函数成员的原型和注释写出它的类外定义。(﹡﹡﹡)( x5 S  }! \, ]" u0 _/ l3 D, {& `9 {
class?AA?{
; z' }( n% J6 p9 Bint*?a;* d1 ?/ D/ h" ^" X2 c
int?n;# o6 T7 S% Q1 Z/ W* i
int?MS;5 B9 A$ N1 O3 x0 D
public:8 W) i# v9 m  n4 i
void?InitAA(int?aa[],?int?nn,?int?ms)?{7 b; H; t3 _" n4 z
if(nn>ms)?{cout<<"Error!"<<endl;?exit(1);}9 Z: n) O3 I% D, m5 N8 k9 `
MS=ms;3 k5 `4 W3 J# u% W5 L
n=nn;; \* \$ ^' F- c
a=new?int[MS];$ ?% X$ n5 o" o) {) R8 j
for(int?i=0;?i<MS;?i++)?a[i]=aa[i];! t* ?" a" t5 K% n
}
  ~' K9 j4 K+ U  A/ I" {int?Compare(AA?b);?//比较*this与b的大小,若两者中# \  o! u& d4 y+ @
????????//的n值相同,并且数组中前n个元素值对应8 q, e& Q0 T' F3 _6 B5 \$ n( `
????????//相同,则认为两者相等返回1,否则返回0。( S9 a, A0 t/ ?6 O) m9 i; {1 V
};5.?根据下面类中CompareBig?函数成员的原型和注释写出它的类外定义。(﹡﹡﹡), I% J2 S, t( v  g( q- A8 a
class?AA?{3 R' l; l* Q1 B
int*?a;
% }2 [6 Y: T" Q6 c; t+ Aint?n;
8 R8 A6 t$ n; X3 ?int?MS;
) y* O* M; R: d! ~% z2 t0 a9 qpublic:
- F% J  N% V7 xvoid?InitAA(int?aa[],?int?nn,?int?ms)?{
  n4 {7 @! T& R  z5 ?if(nn>ms)?{cout<<"Error!"<<endl;?exit(1);}
7 b; c7 L" v; R" z& MMS=ms;
2 f, H1 \$ O  U6 un=nn;2 }7 d* I9 D# D" W
a=new?int[MS];3 m1 H1 F* S& t9 a% N6 i
for(int?i=0;?i<MS;?i++)?a[i]=aa[i];
: j! E+ [1 p  K( n2 e}. M& U5 s( j# E0 y
int?CompareBig(AA?b);??//比较*this与b的大小,从前向后按两数组1 n5 h* q. |" J9 K& x
???????????//中的对应元素比较,若*this中元素值大则返回1,若b中
# L6 g' K; i& C* f8 N; w" w, a: z???????????//元素值大则返回-1,若相等则继续比较下一个元素,直到3 n# a$ @6 O3 m
???????????//一个数组中无元素比较,此时若两者的n值相同则返回0,8 h( a5 F9 E- O
???????????//否则若*this中的n值大则返回1,若b中的n值大则返回-1。$ `) B6 `7 ?8 N9 X
};6.?根据下面类中Reverse?函数成员的原型和注释写出它的类外定义。(﹡﹡﹡)3 o! Q. M4 b! C, S8 P! @! d- e
class?AA?{
+ d1 Z3 b7 A& f% a  iint*?a;
$ G2 j$ h9 t/ ]" Z. c( Y, \int?n;9 K8 G9 Y) ~2 x2 }9 J
int?MS;4 \4 k5 j; q6 Y  L
public:+ M4 K& d6 P5 X! [
void?InitAA(int?aa[],?int?nn,?int?ms)?{
3 d4 q' [% B; s! qif(nn>ms)?{cout<<"Error!"<<endl;?exit(1);}: _) `# U1 U+ T6 @$ U) z; X0 E+ r  K
MS=ms;) N2 }' A$ E; q" e2 W
n=nn;( D7 R9 Q7 u0 N7 v) f% @
a=new?int[MS];
! {) M' B! \. ]7 E* nfor(int?i=0;?i<MS;?i++)?a[i]=aa[i];
7 b5 o* v0 @- Z& Q}& I5 ~5 k. }' ?9 O0 s/ V! f  y
AA*?Reverse();??//对于调用该函数的对象,将其a数组中前n个7 k( Z! ]( ^7 i5 ?5 g
???????//元素值按相反的次序排列,返回指向该对象的指针。& B8 h$ C$ T; L5 }! l) R
};7.?根据下面类中Reverse1函数成员的原型和注释写出它的类外定义。(﹡﹡﹡)5 ^+ y7 h2 T- j) O& K! d* g; \* {
class?AA?{/ K! E) M% I* z: D1 l% C& b
int*?a;
% e; q# j5 w! i* V. e/ g. y  gint?n;
- H* @- h9 P- i) }1 P. v! T1 U* a+ \int?MS;
5 j, q# G5 J0 t) j0 Upublic:
8 ]; \' r8 n  X& Vvoid?InitAA(int?aa[],?int?nn,?int?ms)?{: ]1 [% N. h1 e
if(nn>ms)?{cout<<"Error!"<<endl;?exit(1);}
( l" N/ G# j% C* @7 cMS=ms;
6 C' ?+ A0 ?" c  l( C8 in=nn;5 r; ~9 |! q  m: G
a=new?int[MS];
, Q4 P/ Z3 t8 R4 C! z* P: C0 Jfor(int?i=0;?i<MS;?i++)?a[i]=aa[i];( p; m  n* c: o; L- Y
}
/ U8 s- x7 ^( l, c0 J+ j$ iAA*?Reverse1();??//通过动态存储分配得到一个对象,并动态分配" I& I* g5 u. s
?????//a[MS]数组空间,要求该对象中的n和MS的值与*this中的
0 z) Q2 p6 a2 I5 y( \?????//对应成员的值相同,数组元素的值是按照*this中数组元* [2 [1 g  G( a+ P& a2 Y( q
?????//素的相反次序排列得到的,要求该函数返回动态对象的地址。
  |: `: [1 f! O" H( Y' Y};9 r) }0 Q6 o( k& d8 s1 v; P7 g" r
第三章 构造函数2 k7 q8 c3 M& B9 N2 _7 H
单项选择题:& M4 q3 E. k7 h, g- U% f
1.定义类的关键字是(      )。& M9 k  h" V/ W" J) E; p
A.class    B.struct    C.union   D.enum# I! N4 x+ R. o7 @
2.在类中说明的私有成员使用的关键字是(      )。
5 B" C1 L/ d2 k9 X8 C! C3 yA.private  B.extern   C.auto  D.public2 i/ H" N5 b, A1 L' J
3.对类中引用成员的初始化是通过构造函数中给出的(    )实现的。
' i7 S! x! ]  W! P% nA. 函数体   B. 参数表    C. 初始化表    D. 初始化表或函数体6 k1 M% A4 o* D
4.类的构造函数可以带有(    )个参数。
6 u1 z& \; h0 P2 P# Z# MA. 0      B. 1      C. 2      D. 任意
- m. n0 ?+ b6 l% o# P5.对于一个类的构造函数,其函数名与类名(    )。
% v! T! r# ^) T$ ?/ E; L/ |% cA. 完全相同      B. 基本相同      C. 不相同      D. 无关系2 b6 o8 V  `* P0 m" Z0 q; ]# S
6.对于一个类的析构函数,其函数名与类名(    )。
0 w) A6 z# M' D$ mA. 完全相同      B. 完全不同      C. 只相差一个字符      D. 无关系
" _( f' @1 ]# f2 p& {' R7.类的构造函数是在定义该类的一个(    )时被自动调用执行的。( P! F% x  R, o- b7 E
A. 成员函数      B. 数据成员      C. 对象      D. 友元函数
  W$ N0 q8 ]2 I# |! T8.类的析构函数是一个对象被(    )时自动调用的。1 ^6 g" ~$ |! m2 l, |
A. 建立          B. 撤消          C. 赋值        D. 引用
) q$ D' b  W2 l% d' Y9.一个类的构造函数通常被定义为该类的(    )成员。: ]/ `$ W) G3 M5 ]" D  u
A. 公用          B. 保护          C. 私有        D. 友元8 @' A8 W  ]) _7 W
10.一个类的析构函数通常被定义为该类的(    )成员。9 |9 ~) J/ B& [4 s6 v
A. 私有          B. 保护           C. 公用      D. 友元$ ^" _0 _% r$ p+ F; h% i8 ]
11.假定AB为一个类,则执行 “AB x;”语句时将自动调用该类的(    )。
$ F$ q! l) W6 v, p! U0 f! YA. 带参构造函数          B. 无参构造函数   C. 拷贝构造函数           D. 赋值重载函数
) K( y9 z# b. N* B) {: g% b12.假定AB为一个类,则执行 “AB x(a,5);”语句时将自动调用该类的(    )。+ z& M7 S& h7 ~- J
A. 带参构造函数          B. 无参构造函数   C. 拷贝构造函数                   D. 赋值重载函数
2 P9 {3 t- ~9 O, |" M. u13.假定AB为一个类,则执行 “AB *s=new AB(a,5);”语句时得到的一个动态对象为_______。
; [& m8 y. x2 AA. s        B. s->a        C. s.a        D. *s# i  T4 f  z( ^: S$ Y! a
14.假定AB为一个类,则执行 “AB r1=r2;”语句时将自动调用该类的(    )。
0 ]6 I1 A# a6 D" n! x+ Z/ Z1 e( jA. 无参构造函数          B. 带参构造函数   C. 赋值重载函数           D. 拷贝构造函数
% P/ f6 g( ~) l8 _) ]15.若需要使类中的一个指针成员指向一块动态存储空间,则通常在(    )函数中完成。
3 }) w8 f) g2 FA. 析构      B. 构造      C. 任一成员      D. 友元. w$ M# j! C' Y9 F4 G% m4 n% K( O" {
16.当类中的一个整型指针成员指向一块具有n*sizeof(int)大小的存储空间时,它最多能够存储(    )个整数。
7 F/ y+ h& D9 X$ e( `( L6 @" qA. n         B. n+1       C. n-1      D. 11 j1 e, ?6 G- h( O0 X1 r6 h8 L
17.假定一个类的构造函数为 “A(int aa, int bb) {a=aa; b=aa*bb;}”,则执行 “A  x(4,5);”语句后,x.a和x.b的值分别为(    )。3 M  O7 g" @% z* t4 e' v& ], U
A. 4和5     B. 5和4      C. 4和20      D. 20和5
- ^3 Q' z3 f8 w8 K% V18.假定一个类的构造函数为 “A(int aa=1, int bb=0) {a=aa; b=bb;}”,则执行 “A x(4);”语句后,x.a和x.b的值分别为(    )。6 e2 ?& J3 _+ [* P: w( Q
A. 1和0     B. 1和4      C. 4和1       D. 4和01 n8 `8 M) P7 c: b# F. Y. M+ s* e% S7 Y
19.假定AB为一个类,则(    )为该类的拷贝构造函数的原型说明。
1 \% O- g& A% zA. AB(AB x);           B. AB(AB& x);    C. void AB(AB& x);           D. AB(int x);- s# }$ ~* r0 u/ O: z" u' |
20.假定一个类的构造函数为 “B(int ax, int bx): a(ax), b(bx) {}”,执行 “B x(1,2),y(3,4);x=y;”语句序列后x.a的值为(    )。
! U' J# U* ?, N* O5 tA. 1           B. 2           C. 3           D. 4
% @. o8 @# A; l( s& r! X21.假定一个类AB只含有一个整型数据成员a,当用户不定义任何构造函数时,系统为该类定义的无参构造函数为(    )。$ N* l4 i3 k5 \! d7 L+ h
A. AB() {a=0;}           B. AB(int aa=0): a(aa) {}    C. AB(int aa): a(aa) {}           D. AB() {}
, y" `# V4 ]6 ^: V4 L1 W% D3 S22.假定一个类AB只含有一个整型数据成员a,用户为该类定义的带参构造函数可以为(    )。
9 i6 _- w4 D5 N  @1 P6 IA. AB() {}            B. AB(): a(0){}    C. AB(int aa=0) {a=aa;}          D. AB(int aa) {}
) g+ _  E3 b) _7 c4 P7 U) H23.对于任一个类,用户所能定义的构造函数的个数至多为(    )。
9 j- W/ P: L9 |) Q; |' bA. 0      B. 1      C. 2      D. 任意个
$ ~7 C0 b# f. T0 u24.对于任一个类,用户所能定义的析构函数的个数至多为(    )。
3 u/ i( v# L1 BA. 0      B. 1      C. 2      D. 任意个
5 ^/ j7 h0 }  g" }" g. c9 x+ D& C25.假定AB为一个类,则执行 “AB *px=new AB[n];”语句时将(    )。
5 r! R8 S& q( X! \' v9 oA. 动态分配一个数组   B. 动态分配一个对象  C. 静态分配一个数组           D. 静态分配一个对象
+ D5 T$ n6 l6 E3 Z. ^26.设px是指向一个类对象的指针变量,则执行 “delete px;”语句时,将自动调用该类的(    )。
4 H8 L0 @* [8 T% CA. 无参构造函数        B. 带参构造函数   C. 析构函数          D. 拷贝构造函数
7 y/ }5 ^: i8 ~: {9 C27.当一个类对象离开它的作用域时,系统自动调用该类的(    )。  L  g6 I' B6 E6 W" ?$ n
A. 无参构造函数            B. 带参构造函数   C. 拷贝构造函数          D. 析构函数& y) d- e/ t( X/ X2 ]9 F/ Q9 @. G
28.假定一个类对象数组为A[n],当离开它定义的作用域时,系统自动调用该类析构函数的次数为(    )。7 x6 m" J/ k( V0 G7 ]
A. 0      B. 1      C. n      D. n-1
9 F8 ?/ k& `9 _) T# K6 @1 b3 @29.假定AB为一个类,则执行 “AB a[10];”语句时调用该类无参构造函数的次数为(    )。
2 F1 u3 \3 V. L# S! I; D4 G4 x, ?. hA. 0      B. 1      C. 9      D. 10
, W5 J0 {2 H4 N; _) D" }30.假定AB为一个类,则执行 “AB *px=new AB[n];”语句时调用该类无参构造函数的次数为(    )。
) q* {& T+ d% b* ?- W" ~A. n      B. n-1      C. 1      D. 0
0 q+ F8 Y# p* G. }& B31.假定AB为一个类,则执行 “AB a, b(3), *p;”语句时共调用该类构造函数的次数为(    )。
" U7 y2 |5 v  }A. 2      B. 3      C. 4      D. 5/ w- U$ K1 H( E/ b& m. ?
32.假定AB为一个类,则执行 “AB a(2), b[3], *p[4];”语句时共调用该类构造函数的次数为(    )。& Y1 m2 v% d; d& Z, I+ |
A. 3      B. 4      C. 5      D. 9' E" N% i! t& X. O) a7 u& g4 ~
33.. 假定AB为一个类,则执行“AB a, b(2), c[3], *p=&a;”语句时共调用该类无参构造函数的次数为(    )。3 a- z8 G' @4 x7 v) n5 S( p0 ^) B
A. 5      B. 6      C. 3      D. 4
! E( B1 p' \  w4 j4 b7 M1 I34.假定AB为一个类,则执行“AB *p=new AB(1,2);”语句时共调用该类构造函数的次数为(    )。* V6 m9 L( w$ b; b: p" h3 p
A. 0      B. 1      C. 2      D. 3
* ?. F# ^  U0 G0 T+ [- ~# U35.假定AB为一个类,px为指向该类的一个含有n个对象的动态数组的指针,则执行“delete []px;”语句时共调用该类析构函数的次数为(    )。
3 N! G: J3 q7 F* ]3 \A. 0      B. 1      C. n      D. n+1
4 w$ `. F% o& w' I36.对类对象成员的初始化是通过构造函数中给出的(    )实现的。
9 d) H' X) J8 JA. 函数体        B. 初始化表   C. 参数表           D. 初始化表或函数体
& K: w; ]( V7 _7 E. Z. ~37.对类中常量成员的初始化是通过构造函数中给出的(    )实现的。
8 D: \" z% ?# Y0 \( `4 j" jA. 函数体           B. 参数表    C. 初始化表             D. 初始化表或函数体' K- X6 s. q0 P- I! ?: W  r) }% n
38.类的析构函数可以带有(    )个参数。6 }& [% f( ^7 t, T* _5 z
A. 0      B. 1      C. 2      D. 任意填空题:5 t$ P  g- `" y: [: O: |7 S3 O0 g
1.一个类的(  )函数实现对该类对象的初始化功能。. M; Q% L3 ~) y9 v) L
2.一个类的(  )函数通常用于实现释放该类对象中指针成员所指向的动态存储空间的任务。% n0 p! k  v* O* M5 t
3.当用户为一个类定义有(  )时,则系统不会为该类再自动生成一个默认构造函数。* v" R  {& D' s, v2 W5 `. ?8 D7 E! ?
4.假定用户没有给一个名为AB的类定义构造函数,则系统为其定义的构造函数为(  )。& I6 B# V# g( _
5.假定用户没有给一个名为AB的类定义析构函数,则系统为其定义的析构函数为(  ) 。0 b7 m  M& Z; F6 d1 L) L+ Q7 i" Q
6.定义类动态对象数组时,其元素只能靠自动调用该类的(  )来进行初始化。% `$ N7 c  S4 S! }: d, x/ u
7.在一个类中定义拷贝构造函数的目的,是为了当利用该类的一个对象初始化另一个对象时,能够避免这两个对象的同一指针同时指向同一块(  )。
/ m/ B, ^& t( R" A- W9 c  v8.为了释放类对象中指针成员所指向的动态存储空间,则需要为该类定义(  )。
( v- R  o. }7 X1 R& `7 Q9 G9.?假定?AB为一个类,则执行“AB?a[10];”语句时,系统自动调用该类构造函数的次数为(  )  。3 U7 t* B, z" D9 e' q
10.假定一个类对象数组为A[N],当离开它的作用域时,系统自动调用该类析构函数的次数为(  )。3 }3 J8 g; j/ \7 M! u* B
11.对类中对象成员的初始化是通过在构造函数中给出的(     )来实现的。# r3 O, k  C2 B
12.对类中常量成员的初始化是通过在构造函数中给出的(     )来实现的。2 |0 V( F  l, T  R- t) d6 o
13.对类中引用成员的初始化只能通过在构造函数中给出的(      )来实现。
) s$ s, @4 N* N: z7 X! B* w( C14.对类中一般数据成员的初始化既可以通过在构造函数中给出的初始化表来实现,也可以通过构造函数中的(    )来实现。: `2 v2 `/ {# T0 G7 y
15.?假定要把aa定义为AB类中的一个常量整数型数据成员,则定义语句为(      )。
9 D+ @  W+ x4 e. O16.?假定要把aa定义为AB类中的一个引用整数型数据成员,则定义语句为(      )。( f; g5 \; k& |( J: N2 _
17.?假定AB类中只包含一个整型数据成员a,并且它是一个常量成员,若利用参数aa对其进行初始化,则该类的构造函数的定义为(     )。7 l" ~) e, ~+ g: G4 A
18.?假定AB类中只包含一个整型数据成员a,并且它是一个引用成员,若利用引用参数aa对其进行初始化,则该类的构造函数的定义为(        )。
6 U& W7 t! }; T! G19.假定指针p指向一个动态分配的类对象,则当执行“delete?p;”语句时,在释放p所指向的动态存储空间之前将自动调用该类的(    )。+ e9 k3 ^( ^9 M4 O
20.假定用户为类AB定义了一个构造函数“AB(int?aa)?{a=aa;}”,则系统(会/不会)(    )为该类自动定义一个无参构造函数"AB()?{}"。
( z7 v& b: n. ?- M21.?假定用户为类AB定义了一个构造函数“AB(int?aa,?char?*bb=NULL):a(aa),b(bb){}”,则该类中至少包含有(  )  个数据成员。+ }- J- w3 d3 p- a
22.假定用户为类AB定义了一个构造函数“AB(int?aa)?{a=aa;}”,该构造函数实现对数据成员(  )的初始化。
" e8 c- i; Z, I23.假定用户为类AB定义了一个构造函数“AB(int?aa=0):a(aa){}”,则定义该类的对象时,可以有(  )种不同的定义格式。5 d5 W5 E/ M$ A& L6 f
24.假定用户为类AB定义了一个构造函数“AB(int?aa):a(aa){}”,则定义该类的对象时,有(  )种定义格式。  v4 M- H! }) B) k' p: ]
25.假定用户只为类AB定义了一个构造函数“AB(int?aa,?int?bb=0)?{a=aa;?b=bb;}”,则定义该类的对象时,其实参表中至多带有(  )个实参。) u" N' m4 i! h1 ]
26.假定用户只为类AB定义了一个构造函数“AB(int?aa,?int?bb=0)?{a=aa;?b=bb;}”,则定义该类的对象时,其实参表中至少带有(  )个实参。' w8 U% C0 E3 G( q4 q* j
27.假定用户为类AB定义了一个构造函数“AB(int?aa=0,?int?bb=0)?{a=aa;?b=bb;}”,则定义该类的对象时,可以有(   )种不同的定义格式。
1 q' U# r+ B$ q2 M) ]28.假定用户只为类AB定义了一个构造函数“AB():a(0),b(0){}”,则定义该类对象x的定义语句“AB?x();”是(      )(     )的。! i4 w+ p" I" ^+ m5 |% m- m
29.假定用户只为类AB定义了一个构造函数“AB():a(0),b(0){}”,则定义该类对象x的定义语句“AB?x;”是__(    ) __(      )的。9 z1 C) i- M3 G* T2 c
30.假定用户只为类AB定义了一个构造函数“AB():a(0),b(0){}”,则定义该类对象x的定义语句“AB?x(5);”是__(    ) __(     )的。( z( x& J. I9 u* m+ K
31.假定AB为一个类,则类定义体中的“AB(AB?x);”语句为该类(      )的原型语句。* u( Q0 I0 E, H# G
32.假定AB为一个类,则该类的拷贝构造函数的函数头为(     )。
4 |) q( \- y) O# t3 t) H5 E0 Z33.假定AB为一个类,该类中含有一个指向动态数组空间的指针成员pa,则在该类的析构函数中应该包含有一条(        )语句。简答题:
6 _# Y" c1 a! }  b简述什么是浅拷贝和深拷贝。程序设计与分析题:
% B, I4 W! T% u7 j, B1.程序: (﹡﹡﹡)
0 _3 m, Y  O, T  v; o  y1 Y; B#include <iostream.h>+ F+ e: L/ g. C6 O- g- M  E
#include <math.h>
2 T! n' |0 ]0 Dclass Point{
; }/ N7 P" d2 b* F! s5 \0 Zpublic:
+ Q. T3 c5 w& x+ h$ I+ V  void Set(double ix,double iy)    //设置坐标  ^3 t9 C3 W1 c4 m8 {5 s- w
  {    x=ix;  y=iy;  }, @! H7 X( g9 `. N
  double xOffset()         //取y轴坐标分量$ v' T4 J# Q# w: ^; o; p- m
  {    return x;  }) p& A- j7 A! k# T
  double yOffset()      //取x轴坐标分量
8 L+ P1 K( j( w6 H) S& z3 C  {    return y;  }- P  V9 @2 R! t/ m0 H' y! {
  double angle()        //取点的极坐标/ l1 J* e1 ~; r9 o# u
  {    return (180/3.14159)*atan2(y,x);  }
3 L. a: C  Y' V1 T" [  X1 G  double radius()        //取点的极坐标半径" i! s& E4 K1 ^% f
  {    return sqrt(x*x+y*y);  }
2 n+ A7 k; m" O! N% n* A- _2 D, Z; o+ @protected:
3 B# k& o5 Z( `3 {  double x;      //x轴分量* Z4 Z2 c3 y. B1 J2 [8 P+ `6 m
  double y;      //y轴分量2 b' T6 @! C9 s
};
9 V! l) r7 R9 Evoid main()5 g) M/ P3 q  s+ z& R
{  Point p;
- K/ [6 V5 ^6 H8 q1 H  double x,y;
5 ~3 ~8 C- x7 v" ^; @" f0 G0 \  for(;;){      //重复输入x和y轴分量,直到x分量值小于04 L3 Q1 H' v: M+ m
    cout <<"Enter x and y:\n";$ T9 l! w! O3 V  F: p
    cin >>x >>y;
5 _, u/ Y. e# _    if(x<0): w0 x1 n$ j+ L( q7 i3 X
      break;2 O. ]3 J6 ^7 J0 k
    p.Set(x,y);
9 w% I2 T& m$ j0 t* |    cout <<"angle=" <<p.angle()" E7 b3 N# F% ^
         <<",radius=" <<p.radius()
9 O. h( w8 X$ a6 T* E         <<",x offset=" <<p.xOffset()
9 B6 ~9 A- ^% k9 b8 W         <<",y offset=" <<p.yOffset() <<endl;
0 {: _0 e- r. Y) O0 F) m8 F  }
8 b% X) d  @* E}! k( e; h( w+ y8 m/ i* S. g
问题: 根据类的封装性,不改变该类的公有接口,不改写主函数的情况下,只改变该点类的定义与实现,要求把原有点类的私有成员x,y改写成另外两个私有数据成员a,r分别代表该点在极坐标系下的弧度值和半径值。请写出修改后的类的定义与实现。
; y. w& U4 C2 ]; D6 J. Y8 Y3 U2.?根据下面类中构造函数的原型和注释写出它的类外定义。(﹡﹡﹡)
% F8 g# \) ^3 s  O2 uclass?Array?{
! U+ }4 B, @4 T" u" H' X! d; s6 Dint?*a;??//指向动态分配的整型数组空间- ^8 Y' b; G5 z% w% Z
int?n;????//记录数组长度9 y8 m5 G* O; K2 i
public:
! P7 ~$ s! e+ L3 ?* `Array(int?aa[],?int?nn);??//构造函数,利用aa数组长度nn初始化n,
) Y1 _4 u5 ~; k$ B5 V% _1 r" X" \# I??????????????????????????//利用aa数组初始化a所指向的数组空间
! d6 s  b7 V% [0 [- oArray(Array?aa);???//拷贝构造函数
+ H/ G# e4 J* pArray?Give(Array?aa);??//实现aa赋值给*this的功能并返回*this8 k- \  ]8 x" p
????Array?Uion(Array?aa);???//实现*this和aa中的数组合并的
0 b7 e& C) l8 q) Z?????????????????????//功能,把合并结果存入临时对象并返回0 @$ R& P1 U, e8 |
int?Lenth()?{return?n;}??//返回数组长度
' {3 V, q2 D6 N+ I* O/ ~0 H0 yvoid?Print()?{???????//输出数组
: @2 a' `/ v; ]. L* cfor(int?i=0;?i<n;?i++)% U" `% o# J9 O( t. g/ ~3 K
cout<<a[i]<<?;: y) m& I- U/ Y
????cout<<endl;- r- @5 r% E0 N. A0 i3 _- }  {
}% i5 n8 o* Y1 a( ^$ |
};第四章  堆和拷贝构造函数+ g8 \; i0 j1 Y! Q0 x) X% P
程序填空题:; a4 O* S7 n) ~3 N( V1 k
1.class?A?{       2 L! o$ s2 D5 s6 K0 r, q1 O) h5 R
?????int?a;
4 {' J! M- o; F" y& j???public:' S3 S; K' p7 R
?????A()?{a=0;}, c9 k7 [! m/ C1 D
?????___(1)___{}??//定义构造函数,用参数aa初始化数据成员a
+ y7 C- ^- ^) m5 c/ T4 Y4 h???};
* l6 B  e* h+ J7 i2 o0 j9 ~8 Y???main()?{
* _4 D0 u( y2 T?????___(2)___;??//定义类A的指针对象p
. T  A) Z$ ^+ {5 H?????___(3)__;???//用p指向动态对象并初始化为整数5/ q$ m3 R  V# h; D* M0 s6 L
???}2.class?A?{         ' S7 t8 ^- M' t; \$ w5 N1 K0 B6 X
?????char?*a;' s, z* d' n- s3 C  V6 P4 k6 d
???public:. q% I1 s" r+ A' C* q- ?
?????___(1)___??//定义无参构造函数,使a的值为空% _6 i# ]1 L- P
?????A(char?*aa)?{& ]' x2 s$ U' x3 S2 h
???????a=___(2)___;??
7 z: X9 M$ f* h# }2 i# b???????strcpy(a,aa);??//用aa所指字符串初始化a所指向的动态存储空间
- U3 k) N. Q- F8 s( l?????}
; ]8 G, {6 t! j" U?????___(3)___??//定义析构函数,删除a所指向的动态存储空间
1 u+ a5 a" u# k. C1 n8 p4 V, q???};3.class?A?{          4 M1 w6 P3 t8 g; y$ j" F- L
??????int?a,b;) {1 c$ B3 z) ^* N6 P, g' [
????public:
" O; I2 k! E- d+ E/ C9 G" t$ h3 {??????A(int?aa=0,?int?bb=0)?___(1)___?{}?//分别用aa和bb对应初始化a和b% v1 r1 B7 P) x
????};
, y: N& p' v- M( q. ?0 I5 F& omain()?{  U2 J8 Q; k9 x! c5 P+ f
??___(2)___?;??//定义类A的对象x并用5初始化,同时定义y并用x初始化
1 n0 M6 e; ?- m: B??___(3)___?;??//定义p指针,使之指向对象x/ _: Y. H5 V3 E  z& i2 T5 P
}4.class?A?{     - A9 t, I+ Y& m6 X3 ~5 A
??????int?a,b;
5 E& _, z5 I+ U& t' J????public:* i0 e: ^1 n( ~8 d1 G* t
??????___(1)___?//定义构造函数,使参数aa和bb的默认值为0,  {! w: v; U1 \& {/ U- g5 Y; A' v
????????????????//在函数体中用aa初始化a,用bb初始化b
% p* o! u! T1 X7 F! @% l????};
$ m8 f# \* b4 lmain()?{" i; A/ X6 k  ?7 C0 R
??A?*p1,?*p2;
; y, O" J% Y6 t, s??___(2)___?;??//调用无参构造函数生成由p1指向的动态对象$ ]* f0 U4 F6 V$ n, C- @) x: V
??___(3)___?;??//调用带参构造函数生成由p2指向的动态对象,# W3 U( O2 N) c$ B/ M' t+ U+ ]
???????????????//使a和b成员分别被初始化为4和59 j1 `% T7 x" {1 t$ r* S' _
}5.?#include<iostream.h>    2 U  c' w: V5 J' N
????#include<stdlib.h>% j; B! |- e" g7 y$ M: t6 ^, j) g
????class?A?{
& W8 c7 k9 ~" q* w* \9 }% s??????int?*a;?int?n;?int?MaxLen;4 D2 ^% |4 r( k; `* k; O# _0 e  [
????public:! l* U6 ?1 o# ]! j2 {8 \
??????A():?a(0),?n(0),?MaxLen(0)?{}0 Q, L8 b- x; j+ F) b
??????A(int?*aa,?int?nn,?int?MM)?{' V9 p. M3 L8 V. z
????????n=nn;- J) V0 z1 h$ E9 e# D( O
????????MaxLen=MM;
; _2 b) @* a7 ^/ w: e????????if(n>MaxLen)?exit(1);: A$ I$ e7 i$ z' d1 p
????????___(1)___;??//由a指向长度为MaxLen的动态数组
5 W1 ]8 ?  A8 ^/ Y????????for(int?i=0;?i<n;?i++)?a[i]=aa[i];
+ C. ^- a4 P0 G- v3 `' b% w% a+ f??????}??# c: m2 q+ N/ _% Z7 E: n& V  f
??????~A()?{delete?[]a;}
; b' a1 c5 s" S7 I??????int?GetValue(int?i)?___(2)___?//函数体返回a[i]的值
3 \* v9 O& V0 X( e????};8 M+ t" j! w" M! H
????void?main()$ _" Y! V/ o0 J/ h+ f
????{
5 i2 s. H# c+ i+ e* U* J; N8 |????????int?b[10]={1,2,3,4,5,6,7,8,9,10};3 u% X6 a4 q# ^$ D, A# F( J
????A?r(b,10,10);
" O# o. v' n1 Q2 ?- j$ J, Y????????int?i,s=0;
" ^+ E7 F7 R. d+ Q0 x4 _. o????????for(i=0;?i<10;?i++);?___(3)___?//把r对象的a数据成员中的每个" D7 v. K% Z; @( z. s4 d( d# E/ q7 Z
???????????????????????????????????????//元素值依次累加到s中3 O" q6 y/ R; K# [
????????cout<<"s="<<s<<endl;, ^. A* Y) p+ P6 Y; [
????}6.?#include<iostream.h>      
2 H" i. e2 }& C$ v8 E2 D????#include<stdlib.h>
0 B4 {9 A$ L5 [7 R3 u! W' I7 i????class?A?{6 e7 q% W# b7 m5 x* `
??????int?*a;?int?n;?int?MaxLen;
0 i/ M( x# `  _5 z( ]5 p????public:
2 ~( c  H4 h: W" m' ~! N* r5 A??????A():?a(0),?n(0),?MaxLen(0)?{}1 X* p! Q( L' j( W: \* y* N' Q
??????A(int?*aa,?int?nn,?int?MM)?{
7 y  N3 D* e  e1 M????????n=nn;
' D, w2 `- Q; L, _% S????????MaxLen=MM;
1 ]( V3 b2 ]6 P% C????????if(n>MaxLen)?exit(1);
8 n9 Q4 k, a8 X8 S9 @" |????????a=new?int[MaxLen];
' ?3 h( E3 |4 |) D9 u1 I* `????????___(1)___;??//以i为循环变量把aa数组中每个元素值
; f; U6 d: D  \5 W7 r: D????????????????????//传送给a数组的对应元素中+ b4 u2 o5 L/ J; X. {' i
??????}??: C0 L3 u% u' ?
??????~A();
# R5 X9 {# I; l) ?: W0 L??????int?GetValue(int?i)?{return?a[i];}?//函数体返回a[i]的值0 q+ u, t/ f9 K' |1 n' |
};___(2)___???//析构函数的类外定义
1 G' ~6 V* @/ r, q????
. `' q% N9 Z- g# ]. n????void?main()
0 ~  f$ W: B6 @. |9 z; A????{+ r% E% \0 b% X& }' h
????????int?b[10]={1,2,3,4,5,6,7,8,9,10};4 {$ ^, i$ Z* a8 U% N
????A?r(b,10,10);- Y1 g5 x3 V( v; N! k
????????int?i,s=0;
& V+ J1 S1 q8 f4 L# q' ~1 W????????___(3)___?;?//以i为循环变量,把r对象的a数据成员中的  U: w1 H* s* s7 @8 l# `: i5 \
????????????????????//每个元素值依次累加到s中  c+ f2 m* u$ P
????????cout<<"s="<<s<<endl;8 t; @  x0 m+ ]% H6 H
????}写出程序的执行结果:0 s5 i0 z/ `0 A) Q, Y1 |0 k, U
1. 请写出下面程序的运行结果:
" X' F' v# ^6 h  b; b程序:2 B1 @+ K8 Y- X  h; |  ?7 B& b
#include <iostream.h>  w" ~3 l- f# s& z# n2 q- V
class Tdate{
6 c2 m, [& \- g* G% Xpublic:
" C+ z* [5 V" k1 p: ~  Tdate();! L& `) ?5 @" O3 u) G
  Tdate(int d);
1 g  Y4 b5 @4 N1 J: G3 [% O3 y2 `  Tdate(int m,int d);2 \  u3 N( D* V# Y
  Tdate(int m,int d,int y);3 `$ E) m9 ^7 V" a- _
  //其他公共成员. z( b5 C/ s; X; j. b9 j5 _
protected:
8 U# j% w  M- S- N" A( K+ P. E9 w  int month;
) T4 }; u; a: `& E, X- W) x  int day;
+ v- [  n0 X. Q8 ?  z  int year;; [/ Y. P& a8 z0 U) k
};Tdate::Tdate()) K3 q; P) u# H
{
% {$ p% L& h0 ~  month=4; day=15; year=1995;
, [+ W4 ?  n6 @  cout <<month <<"/" <<day <<"/" <<year <<endl;
0 x% u/ [2 T; S$ M$ s}
( O! _4 i8 A; P" w5 xTdate::Tdate(int d)' [; Y* `+ p9 i4 b( [6 j
{4 j! j, U: V$ a& j; s
  month=4; day=d; year=1996;
. @; C4 l0 Q8 V* ]% D  cout <<month <<"/" <<day <<"/" <<year <<endl;
* w0 E3 F( C5 t: _6 h; ]}" J5 c. l# g# M+ w
Tdate::Tdate(int m,int d)' Y" l$ K: V1 b
{; O6 ~# n% i" w! ^/ h* O' d. D
  month=m; day=d; year=1997;6 H/ d; X. v3 _
  cout <<month <<"/" <<day <<"/" <<year <<endl;
7 O0 p- B% `/ |3 a" _}
8 v/ N9 f/ ~$ v% STdate::Tdate(int m,int d,int y)9 |) S6 N" V9 J4 c
{, g7 P7 G6 K: }. y$ t6 y8 H& A( c
  month=m; day=d; year=y;1 J+ k; e5 e7 e
  cout <<month <<"/" <<day <<"/" <<year <<endl;- l( M; c( r4 R/ y
}void main()4 F1 r# i: L) ?2 l  L
{: `( n8 P, M; P6 Y+ p, a  `
  Tdate aday;
; b) H% S$ e: I7 c) z  Tdate bday(10);. ?5 c# E! ~0 }1 ~8 N1 _9 h  m
  Tdate cday(2,12);/ r# b* |  g, L7 a
  Tdate dday(1,2,1998);. W- q8 K; z2 D. q; y
}
" U; ~: p; {* m5 U: x+ v程序设计与分析题:
8 ]4 P5 p; V; E& Q1. 程序:(﹡﹡﹡)/ K! X/ ^2 D$ S. S+ k2 y% N) d
   # include <iostream.h>                      //  (1)& o8 N' K. J4 a& l: u( p# M
   class  Clock         
& ^( G' M( R. p- T) B   {. U0 q5 L! Q! [* H! k3 J& g: j
public:
/ q$ B- ~8 o, ]( t" R/ H/ t& M     Clock (int H=0,int M=0, int S=0)         //  (2)1 }# l* B& g5 s$ |; N0 i
        {Hour=H ;Minute=M ;Second=S;}     //  (3)
! @: T$ n2 U- K. |. n      Clock ( Clock  & c)                  //  (4)7 F# O5 G8 H# z4 ^9 M! k3 l
        { Hour=c.Hour;Minute=c.Minute;Second=c.Second;}// (5)& }" e9 }3 Z. N7 }  l
      void SetTime (int H=0,int M=0,int S=0)             // (6)- J3 f5 p  O( o7 t
        {Hour=H ;Minute=M ;Second=S;}               // (7)
0 m* |; [3 }# Z1 Y3 i$ K0 P      void ShowTime ()                               // (8)- t# Y6 g" O( ~1 O# y8 r
        {cout <<Hour<< “:” <<Minute<< “:” <<Second <<endl;   // (9)
. G! C. v8 |/ a# v1 n      ~Clock () { }                                        // (10)
3 R9 E6 Q. Z$ d; ~0 a) xprivate:% \* d% n/ i7 U1 v7 \( @
    int Hour , Minute , Second;                               // (11)
/ G+ E6 B6 x# E0 k5 l* R% S* f  Z};6 b' o' l  W; S0 `, m: N
void  main( void )$ x& n7 @" u% L8 _3 V4 B0 }0 F
{
  s) |7 ~. Q7 C& A; z8 B    Clock meClock (8,30,0);                                   // (12)
$ b1 R( h" ~" t/ C8 Q' _2 N    MeClock.ShowTime ( );                                    // (13)" a8 J, {* m' n
    Clock yourClock (meClock);                                // (14)
+ _4 m- Q: ~+ x% @$ K    yourClock.SetTime ( );                                     // (15)' x+ j: v# i3 |& L0 P8 v
     yourClock.ShowTime( );                                   // (16)8 z6 d" s/ {& M6 }/ g
}% k, `7 G% v7 I+ ^, M+ J. E/ _
问题:' N# K+ Z( X/ j4 W
指出Clock类的外部接口的行号。& u* g0 o! f2 q4 E: H/ n8 ?
指出Clock类的构造函数和拷贝构造函数以及析构函数所在行号。0 z! k) d4 \% Y$ B, {2 U
执行那行语句时系统自动调用了构造函数并写出被初始化的对象名。
6 @4 \# R% p- c" Q+ ^1 l0 g执行那行语句时系统调用了拷贝构造函数并写出被初始化的对象名。
6 T  m) _8 M6 q/ c& \写出程序的运行结果。2.?根据下面类中拷贝构造函数的原型写出它的类外定义。(﹡﹡﹡)
% C. g& K0 D8 mclass?Array?{" Q/ T7 d. \" c) S  s' Y, m6 |0 T
int?*a;??//指向动态分配的整型数组空间
: i' u- }7 I$ _. t% Pint?n;????//记录数组长度7 i/ q! P) t3 u+ ~
public:
  ~; m+ o6 @! u9 e7 tArray(int?aa[],?int?nn);??//构造函数,利用aa数组长度nn初始化n,
1 J( a4 c( ~$ Q4 ~??????????????????????????//利用aa数组初始化a所指向的数组空间
) t7 H( R: P) o( f/ M, OArray(Array?aa);??//拷贝构造函数
! f& o( w6 @: P5 k0 J' t% V) ]Array?Give(Array?aa);??//实现aa赋值给*this的功能并返回*this3 I- i9 Y' M6 u- c/ V( J
????Array?Uion(Array?aa);???//实现*this和aa中的数组合并的
0 y" A3 P1 v* M?????????????????????????//功能,把合并结果存入临时对象并返回
7 P. t+ K+ F/ Y+ lint?Lenth()?{return?n;}??//返回数组长度
8 X" _  ~. y( ovoid?Print()?{???????????//输出数组; j: z; Q& r( Y: D: a, Y
for(int?i=0;?i<n;?i++); ?- U+ {0 T/ \
cout<<a[i]<<?;
8 a+ T) F8 E. b6 b( a????cout<<endl;
4 [1 z1 J1 r4 b. h& S: u}) w, Z0 ?. b& A4 L
};3.?根据下面类中Give函数的原型和注释写出它的类外定义。(﹡﹡﹡)" F7 ]5 \( a" d
class?Array?{6 x! O& F1 p0 i  P- g" z. R% v
int?*a;??//指向动态分配的整型数组空间9 Y8 n) ?( {6 `' G! T! B; i
int?n;????//记录数组长度7 [, R" d2 m7 p8 P
public:/ y3 T( \/ z+ u. b3 O
Array(int?aa[],?int?nn);??//构造函数,利用aa数组长度nn初始化n,/ |/ x5 S6 m9 W( _' l  J; p" G$ m
????????????????????//利用aa数组初始化a所指向的数组空间
& J0 ~2 I" f& L8 KArray(Array?aa);??//拷贝构造函数4 I4 S$ `4 s: j, F- d
Array?Give(Array?aa);??//实现aa赋值给*this的功能并返回*this$ D+ S  T- _  V, r
????Array?Uion(Array?aa);??//实现*this和aa中的数组合并的
) f7 }* L. J1 ^0 u# c?????????????????????//功能,把合并结果存入临时对象并返回3 e' m  X; [9 ^; I4 o1 G3 v$ O8 [
int?Lenth()?{return?n;}??//返回数组长度
( }% w8 F6 {4 D( x, l; xvoid?Print()?{???????//输出数组# C6 s/ I$ R0 P1 Q! |5 c! e
for(int?i=0;?i<n;?i++)
2 r* U. ]5 }+ F! b# ?. dcout<<a[i]<<?;
# m# v! H1 Q  w  }????cout<<endl;. R- L! u) H  O1 k
}9 {3 ~: E- V  L; Q& I7 F% T
};4.?根据下面类中Uion?函数的原型和注释写出它的类外定义。(﹡﹡﹡)
5 F# ?0 [  e9 _% {5 ]7 ^9 a' `class?Array?{
) @3 z  ~* Q! o2 c0 Kint?*a;??//指向动态分配的整型数组空间. ~1 G9 b8 X, W! b4 P# F
int?n;????//记录数组长度% u; {. r& ^, w! y
public:3 U& t; \% a3 C6 Z
Array(int?aa[],?int?nn);??//构造函数,利用aa数组长度nn初始化n,  g0 J. k7 ?9 Z' v8 J! L
????????????????????//利用aa数组初始化a所指向的数组空间$ w5 H; }9 l7 x( k  B7 F0 k
Array(Array?aa);??//拷贝构造函数" h3 \7 J) F4 [' {' n! [
Array?Give(Array?aa);??//实现aa赋值给*this的功能并返回*this
! ~5 `8 f. _$ ^! @: S& W9 c9 l3 ^3 bArray?Uion(Array?aa);??//实现*this和aa中的数组合并的功能,把合并7 U6 \  E" b/ q2 ]1 L
??????????????????//结果(其长度为两数组长度之和)存入临时对象并返回
' A. \  C6 C$ f; A/ W6 @; {int?Lenth()?{return?n;}??//返回数组长度
8 E: ^" |, l8 U7 w( P3 i' C8 Jvoid?Print()?{???????//输出数组( a* L% Y0 d4 c  \. A2 I
for(int?i=0;?i<n;?i++)0 |! K) R4 d7 O9 A
cout<<a[i]<<?;) T5 l4 V1 K2 v* ]
????cout<<endl;
- Q% ]4 M0 L% P6 X# z5 N. Z}: i5 {% _8 k& n# s
};5.?根据下面类中构造函数的原型和注释写出它的类外定义。(﹡﹡﹡)
% V/ {" @9 c" g! U4 N' E% a8 ]7 Nclass?Strings?{
3 W& L. I% Z' m- C8 U+ X3 ^char?*s;??//指向动态分配的字符串数组空间: _% U; h* a, k( U
int?n;????//记录字符串长度
/ ~  A- m" P6 Q2 a4 }, f) K+ }public:/ G( B. F+ |( T- h+ _' e, m
Strings(char*str);??//构造函数,利用str字符串长度初始化n,
& ]$ o: {3 G$ P; x1 h6 `0 j5 }????????????????????//利用str字符串初始化s所指的字符串空间8 n7 [7 `% W( i. L2 o& j
Strings(Strings?str);????????//拷贝构造函数
% U3 n5 A: S; j' Q% `Strings?Give(Strings?str);??//实现str赋值给*this的功能$ B* S* d/ u* {3 b( q
????Strings?Uion(Strings?str);???//实现*this和str中的字符串合并的1 H0 d: Y" s, H% x$ @
?????????????????????//功能,把合并结果存入临时对象并返回
  {2 v" ^$ Y6 uint?Lenth()?{return?n;}???????//返回字符串长度  G8 [0 _, O) \2 {  @
void?Print()?{cout<<s<<endl;}?//输出字符串2 S% h% a# y# N- X
};6.?根据下面类中拷贝构造函数的原型写出它的类外定义。(﹡﹡﹡)6 j: g; Z" M0 |- R+ }& A( z
class?Strings?{9 T0 k# t& Y& C9 I7 a
char?*s;??//指向动态分配的字符串数组空间
/ x" k5 O' E% bint?n;????//记录字符串长度% _* s- O& M, Q" {6 U' ?
public:
( [1 t0 g/ L  R. eStrings(char*str);??//构造函数,利用str字符串长度初始化n,
  i) x/ v  B& p* w/ e" `* N????????????????????//利用str字符串初始化s所指的字符串空间
' w( b- U& w3 ?' B+ R- p0 WStrings(Strings?str);????????//拷贝构造函数9 K( C. s& J3 ]2 H& N* y* a: l
Strings?Give(Strings?str);??//实现str赋值给*this的功能
# T/ X3 |% G4 x) S) V8 v# Q????Strings?Uion(Strings?str);???//实现*this和str中的字符串合并的
3 z6 P* i* |: y- T6 w0 j?????????????????????//功能,把合并结果存入临时对象并返回  c" F& f' I! T7 y
int?Lenth()?{return?n;}???????//返回字符串长度
( ]9 ~+ _( i9 z; p& ^void?Print()?{cout<<s<<endl;}?//输出字符串
' }) R" g7 y- r  Y, a2 w- k/ U& w) j};7.?根据下面类中Give函数的原型和注释写出它的类外定义。(﹡﹡﹡)
: A8 I0 K: {! u  n4 u6 Y: U! l) O7 t5 v( gclass?Strings?{
5 u8 ~( F- y! m; Dchar?*s;??//指向动态分配的字符串数组空间/ b1 b' X' m4 H% H! }2 z! C
int?n;????//记录字符串长度
2 t1 u$ ?. d. N& e3 qpublic:
% v; j# i7 O' Y) r3 DStrings(char*str);??//构造函数,利用str字符串长度初始化n,
$ T+ S  |) M$ o' g+ j3 x????????????????????//利用str字符串初始化s所指的字符串空间8 c, e( f+ v! s# R8 v8 k7 ]$ N# o; q
Strings(Strings?str);??//拷贝构造函数
4 v) s" u1 N8 v$ H* j5 PStrings?Give(Strings?str);??//实现str赋值给*this的功能并返回*this
4 Q/ p( p. }/ b% A1 V- {4 h????Strings?Uion(Strings?str);??//实现*this和str中的字符串合并的- O) C7 n; [5 J6 w0 O3 q
?????????????????????//功能,把合并结果存入临时对象并返回5 g/ L# i( R5 J& A* f
int?Lenth()?{return?n;}??//返回字符串长度+ e# U  Y% {/ y
void?Print()?{cout<<s<<endl;}??//输出字符串! s/ z, V/ u1 y; ^
};8.?根据下面类中Uion函数的原型和注释写出它的类外定义。(﹡﹡﹡)& C6 v9 {) ^- I' K) b5 t2 T! v* }
class?Strings?{7 s( @# A/ T, l2 O3 b2 H
char?*s;??//指向动态分配的字符串数组空间
/ `0 m* i- D0 N, x) a. r% e" S. ^int?n;????//记录字符串长度6 R+ v4 V$ p- ]* @7 r# W/ t7 L
public:
. O+ T1 p4 T7 b; [2 j& RStrings(char*str);??//构造函数,利用str字符串长度初始化n,/ m+ D' Y8 K2 c6 X
????????????????????//利用str字符串初始化s所指的字符串空间
+ l  `3 z5 f" p& gStrings(Strings?str);??//拷贝构造函数* W1 Z2 b. r. ~& \- x% `/ k% {
Strings?Give(Strings?str);??//实现str赋值给*this的功能并返回*this
" |, X( W- h& I! H% ^, GStrings?Uion(Strings?str);???//实现*this和str中的字符串连接的功能,
2 N" K6 d0 J# `' |! F1 v??????????????????????????????//把连接结果存入临时对象并返回
0 T* L& T3 r( [# ?int?Lenth()?{return?n;}??//返回字符串长度, Z" t$ s8 C, g2 j
void?Print()?{cout<<s<<endl;}??//输出字符串) F$ I+ f2 w  _# @' `
};第五章  静态成员与友元3 b! ]: C& b% J; ?$ X
单项选择题:5 A* W9 Q# X6 \
1.一个类的静态数据成员所表示属性 (   )。
% _* l5 Y/ S9 d' q. UA. 是类的或对象的属性   B. 只是对象的属性  C. 只是类的属性          D. 类和友元的属性
  V. |) m+ V3 J0 v% [4 y2.类的静态成员的访问控制(   )。
% q/ Y' X2 a1 X% g9 B4 rA. 只允许被定义为private  M0 m4 ~' V1 }/ P  Y
B. 只允许被定义为private或protected9 l) [* M. O9 w6 q+ v5 |
C. 只允许被定义为public
6 |3 _6 k  M" l9 T2 i2 t/ QD. 可允许被定义为private、protected或public" @9 D, g( }1 E
3.静态成员函数对类的数据成员访问(    )。- }2 n# f4 p0 Y- }+ m
A. 是不允许的                 B. 只允许是静态数据成员
' u: q! d9 [' w1 ~& ^3 I, k' fC. 只允许是非静态数据成员     D. 可允许是静态数据成员或非静态数据成员4 \- @. A( V# ?% X
4.被非静态成员函数访问的类的数据成员(  )。+ ]6 x" g# C! R
A. 可以是非静态数据成员或静态数据成员    B. 不可能是类的静态数据成员5 I8 A( v6 e7 b
C. 只能是类的非静态数据成员              D. 只能是类的静态数据成员& N/ Y2 @' Y+ j; F6 c' R
5.静态数据成员的初始化是在(    )中进行的。
. l6 _1 S  F: x% X9 yA. 构造函数          B. 任何成员函数    C. 所属类          D. 全局区, w, z7 K5 i6 l6 o: V
6.当将一个类A或函数f()说明为另一个类B的友元后,类A或函数f()能够直接访问类B的(    )。
- s5 n; ~5 T* ~. a9 W2 s9 sA. 只能是公有成员                              B. 只能是保护成员+ P+ K; v! |( p/ A, M2 X
C. 只能是除私有成员之外的任何成员              D. 具有任何权限的成员
6 P# O1 y3 O+ k" n2 F/ f7.引入友元的主要目的是为了(    )。3 s) U5 N& E  G7 S
A. 增强数据安全性                                     B. 提高程序的可靠性5 l5 ^/ P' ~/ e; C8 Z, W/ z" P7 p
C. 提高程序的效率和灵活性                             D. 保证类的封装性8 m* Z/ Q7 v% R& u
8.一个类的成员函数也可以成为另一个类的友元函数,这时的友元说明(    )。
% I) U/ V7 \2 [- l2 ~A. 需加上类域的限定                                    B. 不需加上类域的限定6 `  O4 y: [  Z
C. 类域的限定可加可不加                                D. 不需要任何限定! J  P. u5 f" t8 V  R
9.一个类的友元不是该类的成员,与该类的关系密切,所以它(    )。" t" M, @, @* n" H( D
A. 有this指针,有默认操作的对象
+ [6 |8 ^' [0 o( n8 d: L- V# D4 ^+ zB. 没有this指针,可以有默认操作的对象" h; S) R3 N/ M% q$ A, F( D6 B
C. 有this指针,不能执行默认操作
4 P; h- |+ r, Y" gD. 没有this指针,也就没有默认操作的对象填空题:
; N( R% e# k! B4 x6 k" q1.?静态成员函数????(  )访问类的静态数据成员,?(  )访问类的非静态数据成员。/ t* N% |% C- k& [2 j
2.?静态数据成员必须在所有函数的定义体外进行(  )。
  P" Y' N' S: Q& u7 u3.?一个类的成员函数也可以成为另一个类的友元函数,这时的友元说明必须在函数名前加上?(  )?的限定。. J* s; B' N& H- |
简答题:5 x/ n0 v  [# D+ D# \4 n, o5 Z
简述静态数据成员的主要应用。2. 简述静态成员函数与一般成员函数的主要差别。程序填空题:
& ?* P( P7 d, E4 `6 o8 u8 Y. P?1.?一种类定义如下:
8 ^% r) [) f: v9 H" F8 W4 Zclass?Goods9 M# u" W* z( L% J* Q' F0 O
{
3 _* V$ ^/ s' U  x% l! V??private:, c& U. D9 w  `1 X$ o* {) V- x+ u
????char?gd_name[20];???????????//商品名称
3 G7 Y6 Y1 u! O4 m" k????int?weight;?????????????????//商品重量
/ u" W* I8 S9 T4 t1 o????static?int?totalweight;?????//同类商品总重量
+ e- B+ ~4 X4 L- `5 Z??public:
. }2 t  S1 {; L, n# ]; _! eGoods?(char*str,int?w){?????//构造函数; U8 X# Z7 E" u9 n
????strcpy(gd_name,str);& W2 Z& ]$ m  O# p2 Q, G
????weight=w;, ^/ c- y# v8 ?* _' [% K
????totalweight+=weight;
- j2 O2 r1 v4 \  n/ s}( ]3 c+ g! Q: ~- V1 ~8 ?/ A
????~?Goods?(){totalweight?-=?weight;}?1 L5 Q* ^( S9 _( c* w, P
????char*?GetN(){___(1)___;}??//返回商品名称; K% ^, [* A+ {6 y! z
????int?GetW(){return?weight;}
: D" m" X( i$ J* q: g( d: ^( {+ G___(2)___??GetTotal_Weight()?{??//定义静态成员函数返回总重量
. i7 I% z. T* S( ?* I) c????___(3)___;, L1 w  a# I, n: C7 L! Q
}
2 F0 o. v4 W6 ^& \- Z3 V}2.
2 x* x  X  N# m% B% Hclass?Point7 p2 N5 P6 C. j# h6 h' K
{
1 V) a% e- u: a* V  t* }: f??private:
  E; Q0 N8 E: @- N- w3 U2 M????int?x,?y;
' j, ~2 h0 y, \; I: S2 y4 D??public:
9 t8 Z2 J6 K7 v# v' E????Point(){x=y=0;}
* K8 f3 j( R/ c! q% w????Point(int?x0,int?y0)?{x=x0;y=y0;}
; T1 o2 ]# s+ n& D* [" [????int?GetX()?{?return?x;?}
1 n, h) j5 ]% E/ v????int?GetY()?{?return?y;?}
( F) S- Q1 R# z- c3 j. [" g% _????void?Print(){cout<<"oint("<<x<<","<<y<<")"<<endl;}
) h' p. D* S8 j% a5 u????___(1)___;??//友元函数声明/ ^- D8 R1 I! _, I
????___(2)___;??//友元函数声明* n7 {+ M! \1 |. \' R! W
}oint?operator+(Point?pt,int?dd)?) y" R- a, _: z" s, w2 z0 c" ^
????//加号操作符重载函数,实现Point类对象与整数加法# j4 N( _. R- `$ f: K
{
' a$ T6 s$ b9 K' n- N??Point?temp=pt;$ u/ j; ~% a) k- V' C% J- n' A. I. F
??temp.x+=dd;' J  D) N8 @$ B
??temp.y+=dd;
& p# E! q; m$ k+ i  I, V4 d??return?temp;) F2 n- o7 @' ?  S* F7 M6 J
}Point?operator+(Point?pt1,Point?pt2)?
# a" [3 ]  Z2 R, A2 K2 y????//加号操作符重载函数,实现两个Point类对象的加法. l& r  t7 k9 v3 |5 E4 S. J
{
8 i2 N1 q/ Q' P  A1 n??Point?temp=pt1;
# C5 b" }3 l/ l; {4 R, p??temp.x+=pt2.x;. N# k0 F. D$ u! J' e/ F+ [
??___(3)___;
$ Q7 ?' G" h* J/ a% \??return?temp;! V( W% a+ P+ e1 D
}写出程序的执行结果:
* F6 \: M2 `, W0 k3 w1.请写出下列程序的运行结果。
2 v; @! S3 y. `程序:# include <iostream.h>: Z7 t- r9 F- W
      void fun ()/ ^: U4 o: X' [7 o
      {6 f7 z! F. m, n( a  {$ H3 ~9 ?
         static int i=25;
0 L( ?. R9 c" b9 K6 P* z& {5 V          i++ ;
; s0 v9 ^" {7 p          cout<< “i=”<<i<<endl;: @9 e' p+ }3 j; T% O% _
       }
; Z$ m6 p" S+ D9 E       void main ()% F+ [1 N4 ]9 Z% R: w- Z- q" ^
       {! F; a! f& D1 [) w5 m# K
          for (int j=0;j<2;j++)
. {8 h5 r9 Q. a7 d* p             fun ();. G" T2 p3 k8 M9 Z4 ?# T
       }程序设计与分析题:
* C3 v) v! Z* ]7 g9 o% }1. 程序:(﹡﹡﹡); f0 G8 S; P/ u; D6 E2 E1 c
# include <iostream.h>   //(1)
6 N1 @  ?* s( j3 H# include <math.h>      //(2)
+ L/ w% F( e# S/ z. i; Y/ gclass point {            //(3)
- B8 G- a  X6 ~9 J) `     private:           //(4)- x+ ^+ E+ ~+ Q/ B2 {  ]
         float X,Y;     //(5)+ ?# Q5 ~. P+ O& k  F. \/ S
     public:           //(6)* c9 {% A% f' I# o$ W
         point (float xi, float yi ) {X=xi ,Y=yi; }       //(7)
1 X) o' ~$ e% a" c# a1 e2 W3 G         float GetX() {return X}                   // (8)
1 [; s- F% V8 b2 u# N- U         float GetY() {return Y}                   // (9)
, I, h% }, r4 k+ o; o         friend float distance (point & a ,point & b);    // (10)# G% w5 F& k. T. \
};                                              //(11)
/ ?9 Y% I  S' |. ]5 k2 f0 E6 R, cvoid main ()                                      //(12)3 D$ F- m1 T  L2 R, I4 d( x. x
{                                               * c, {% N4 n! Q- R8 s( d
         point pl (3.5,5.5), p2 (4.5,6.5);              //(13)
% k* T" l' C# h, S5 B# Y, E         float d = distance (p1, p2);                 //(14)
0 s1 m% |7 E6 X4 L9 T         cout << “The distance is ” << d;             //(15): q: b/ [- I2 H4 h4 \
}
# l+ p; u3 d3 m, v! L7 C6 p/ }8 j& {float distance (point & a ,point & b)                   //(16)
- R8 b+ U9 \/ r$ M3 @$ O+ O! K{
3 N- O6 F" j: H6 ~- V        float dx = a.X – b.X;                       //(17)5 A' B4 r% ?; |# b5 Z8 E: u+ o8 N
        float dy = a.Y – b.Y;                       // (18)
9 Q5 v7 w$ V: Z: G1 w( l$ ~        return sqrt ( dx * dx + dy * dy );             // (19)6 b9 }! x" P0 r  r7 X2 c, V4 c% P) x
}
6 X' u- O+ I, _8 y, L; g' i6 v0 O问题:1) 第(10)行的作用,有什么特点?( r( f) H& W. ~0 a- w% X/ [6 ?
2)如果把它改写成这个类的成员函数,应该怎样改?2. 下列程序段中,A_class的成员函数Variance()可求出两数的平方差,请改写该程序段,把Variance()函数从A_class类中分离出来,用友元函数来实现该函数的功能。(﹡﹡﹡)
8 i7 z/ a6 B+ U7 }class?A_class?{1 n: m. x% O( ]6 \7 q  m
??private:6 b4 R: _* @1 N" t# i( E+ Z- Z
????int?x,y,t;?  e" p8 f# Z, z5 P9 D
??public:: h9 M1 L$ V$ }- F7 P
????A_class(int?i,int?j):x(i),y(j)?{
0 o; H( @- H; B??????if(y>x){t=x;x=y;y=t;}
( ?7 e" ]7 v) P5 a/ g????}
& z5 n3 X, W5 J0 l) V; G. P% p??int?Variance(){return?x*x-y*y;}?
4 _8 o4 F5 u# i??//其它函数从略5 F2 ], f$ Q# z
};
4 `0 A) a6 ~2 b9 z3 g2 gvoid?main()?{
% Q9 [% h0 C8 y??A_class?A_obj(3,5);
% @3 h$ O+ y7 w: T) [??cout<<"Result:"<<A_obj.Variance()<<endl;3 c9 V' ?( w; A, t2 T% K; ?
}3.?下面给出了矩阵类Matrix定义。为了求两个矩阵对象的乘积,需要定义一个Matrix的友元函数Multiply()。请按照友元函数Multiply()的声明编写出该函数的定义。(﹡﹡﹡)
1 Y9 O8 Q" z! o3 }  mclass?Matrix?{
4 w+ }1 |5 R: L" j; ^??public:4 ^/ ^7 \  m$ [% V
Matrix(int?row,int?col);???//构造一个具有row行col列的矩阵! G; a0 p! S, ?$ m) B! v) N: F
????~Matrix()?{delete?[]mem;} ???//析构函数
: n% V8 p/ i6 z8 f4 a7 H/ Kfriend?bool?Multiply(Matrix?m1,?Matrix?m2,?Matrix?m3);?
( l  P9 k# C) [% T; g$ ~???????????//定义Multiply()为友元函数,该函数把m1×m2的值赋给m3: _( ?, R2 [3 ?$ o
//其他成员函数从略0 ~$ K* W) N. l7 h! X7 i+ |% R# n
??private:; S/ c) k. y6 M4 d6 o4 N
int?*mem; ?????????????????//动态申请矩阵空间( \8 I. x3 }7 O  h: w
const?int?rows,cols; ?????????//矩阵的行数和列数& s# t# ^5 @# n! F
};% N7 ]" P5 n! N+ Y2 a6 i
Matrix::Matrix(int?row,int?col):rows(row),cols(col)
* f/ X; P9 }' L& G9 `6 o2 l{+ V- [0 v% g% T3 ^' [4 v
????mem?=?new?int[row*col];
: p4 f, f1 ^: X. x: {" q8 B/ @}bool?Multiply(Matrix?m1,?Matrix?m2,?Matrix?m3)% H% l# e2 o' i7 C3 r6 d" {
{4 e' V. q+ T+ n; t" \9 V3 o
//确定矩阵是否能够进行相乘; g* O0 X( O1 y* m
??if(m1.rows?!=?m3.rows?||m2.cols?!=?m3.cols?||?m1.cols?!=?m2.rows)???return?false;5 h: N! Z3 N- P& `2 p. r
//定义sum变量,用于计算乘积矩阵m3中每个元素的值# i! b& z+ ?2 T
??int?sum;* ~; B/ P/ n7 m0 P& |$ u$ g! r
//请在下面编写剩余部分
' z! P$ l# |# {( d* u}" t7 e( U9 {% p, m! e0 b
第六章 继承
; f: L/ f/ {+ _* i单项选择题:
% Z3 P1 C: U5 y# j; R9 R+ \1.在C++中,定义虚函数的关键字是(      )。
/ L( A, o" w* v3 {A.virtual    B.protected    C.operator    D.  this5 `) H+ S  A) h6 [. `" A5 V
2.从一个基类派生出的各个类的对象之间(    )。
* }; @; I% \- G( `. uA. 共享所有数据成员,每个对象还包含基类的所有属性) q5 E, I7 G- M, c  i; m/ H, Q" |
B. 共享部分数据成员,每个对象还包含基类的所有属性$ T- `$ |' q6 H" t# E) d  z
C. 不共享任何数据成员,但每个对象还包含基类的所有属性, R0 a+ r6 l3 D& B# o
D. 共享部分数据成员和函数成员
+ e3 s0 v3 v7 o1 x+ [3.如果是类B在类A的基础上构造,那么,就称(   )。
7 D! ]4 }+ U- Z5 c% v9 K- |A. 类A为基类或父类,类B为超类或子类
: b! m# c: Q4 e! t5 rB. 类A为基类、父类或超类,类B为派生类或子类+ ^8 |4 @- K4 i  x( ^
C. 类A为派生类,类B为基类
1 d# T1 l7 `( W1 YD. 类A为派生类或子类,类B为基类、父类或超类: B  ~( ?4 N( b
4.C++的继承性允许派生类继承基类的(   )。
# V3 V) Z: d" MA. 部分特性,并允许增加新的特性或重定义基类的特性4 x5 \0 e: r$ q' w9 s; `8 ~* {! K/ n3 w
B. 部分特性,但不允许增加新的特性或重定义基类的特性! |8 N1 b, p5 p
C. 所有特性,并允许增加新的特性或重定义基类的特性* _  |$ H5 }( U* e# @  o
D. 所有特性,但不允许增加新的特性或重定义基类的特性* O! V  T9 Q! L# l$ g0 r" x
5.派生类的成员函数可以直接访问基类的(   )成员。
$ i* x0 S0 |; E7 aA. 所有         B. 公有和保护         C. 保护和私有         D. 私有* Y7 I5 l- r" B! G' F- C
6.对于公有继承,基类的公有和保护成员在派生类中将(   )成员。# @& ~) I8 w8 y+ }
A. 全部变成公有                  B. 全部变成保护
, ~) u- O( `# {' N! n9 Y( IC. 全部变成私有                  D. 仍然相应保持为公有和保护5 M. t" W. T1 Y: D4 Z
7.对于公有继承,基类中的私有成员在派生类中将 (   )。5 g( o0 Y# H% |" C7 K& A
A. 能够直接使用成员名访问        B. 能够通过成员运算符访问
6 f3 D! A7 J+ mC. 仍然是基类的私有成员          D. 变为派生类的私有成员
$ Q5 `' O0 D; ]1 e% B8.当保护继承时,基类的(    )在派生类中成为保护成员,在类作用域外不能够通过派生类的对象来直接访问该成员。6 \" t! l) }* Y( v# @  N# K& @
A. 任何成员                      B.公有成员和保护成员- U' C+ K6 d6 D' M
C. 保护成员和私有成员            D.私有成员6 @4 ^1 z: r; F% b6 _) X/ O; n9 r
9.在定义一个派生类时,若不使用保留字显式地规定采用何种继承方式,则默认为(   )方式。# S! }! j; u4 w
A. 私有继承     B. 非私有继承   C. 保护继承     D. 公有继承
. H6 M5 I9 X' s% V% h10.建立包含有类对象成员的派生类对象时,自动调用构造函数的执行顺序依次为(    )的构造函数。! u! j  [) N. Z$ B& {9 w
A. 自己所属类、对象成员所属类、基类   B. 对象成员所属类、基类、自己所属类8 ^9 J" F: F  v# F  l
C. 基类、对象成员所属类、自己所属类   D. 基类、自己所属类、对象成员所属类
/ D4 \% V( n2 a3 b+ ]. ]9 H11.当派生类中有和基类一样名字的成员时,一般来说,(  )。$ q. D0 Y7 ]' _0 F$ S
A. 将产生二义性              B. 派生类的同名成员将覆盖基类的成员
3 E: x- @% e* B$ w9 o( y9 i% X! p; KC. 是不能允许的              D. 基类的同名成员将覆盖派生类的成员
4 }- ?- ^5 S1 E2 y12.C++中的虚基类机制可以保证:(  )。6 w& m3 u. F- n# S2 I
A. 限定基类只通过一条路径派生出派生类
2 v# O% l+ X) z: b: i  I; gB. 允许基类通过多条路径派生出派生类,派生类也就能多次继承该基类1 K- G: k5 i6 V5 H
C. 当一个类多次间接从基类派生以后,派生类对象能保留多份间接基类的成员
* p/ B: R0 f+ ~7 c5 mD. 当一个类多次间接从基类派生以后,其基类只被一次继承
& J' M# d0 s4 Y2 h/ r13.下列对派生类的描述中错误的说法是:(    )。3 {% W* B8 K! L- @3 ]; u
A. 派生类至少有一个基类
% q' N" ?+ K% F" _B. 派生类可作为另一个派生类的基类( P  ?. S! p/ L/ D, b# A3 L
C. 派生类除了包含它直接定义的成员外,还包含其基类的成员
% q1 e) F; \4 UD. 派生类所继承的基类成员的访问权限保持不变
* d- ~* g: E; U& M; ]14.派生类的对象对其基类中(    )可直接访问。1 n! `" {2 }8 `
A. 公有继承的公有成员   B. 公有继承的私有成员  C. 公有继承的保护成员   D. 私有继承的公有成员填空题:
, E, I2 o* x$ n' G, X. j1.?在一个或若干个类的基础上构造一个新类,被称为( 继承(派生) )。
1 x0 o& j" L4 E' R9 i2.?派生类的成员函数可以直接访问基类的?( 公有和保护 )成员,不能直接访问基类的??( 私有 )成员。
0 L% k( r. b" U0 s3.?当保护继承时,基类的( 公有和保护 )?成员在派生类中成为保护成员,派生类对象不能直接访问基类的?( 任何 )成员。
( X5 _) p5 Q; f8 S) L6 n5 A4.?在定义一个派生类时,使用( private )关键字或者不显式地使用它则表示为( 私有 )继承。- P) T( G( q! _  n$ `6 o
5.?若多个基类及其派生类中都定义了同名函数成员,要访问相应函数时,就需要在函数名前加上( 类名 )和类区分符。??% u* T0 e7 D- J# B9 z+ r
6.?若要保证一个公共的基类在派生类中只产生一个基类子对象,则必须都以( 虚基类 )的方式直接继承它。0 i8 {4 P6 x" U# K
7.?引进虚基类的根本目的是为了消除( 二义性 )。
# [* G9 a0 M8 r' V* ]) ~8.?在每个成员函数中,隐含的第一个参数的参数名为( this )  。简答题:: @+ C, B" v# J5 F3 h1 O9 N0 b
1. 类的派生方式共有几种,基类成员权限在派生类中的权限怎样变化?  w; k# x+ a/ L7 m8 |! f5 V* A
程序设计与分析题:
5 |& A% d' e" S$ {( [4 c6 S1. 已知类定义如下,其中Shape为基类,Circle和Rectangle分别Shape的直接派生类,Square为Rectangle的直接派生类和Shape的间接派生类。请模仿Circle类,写出Rectangle类的所有成员函数。(﹡﹡﹡)3 R! k+ J' R( S
/******************文件shape.h*************************/. T4 t+ L( h0 }& I8 G
const?float?PI=3.14159f;??//定义圆周率常量class?Shape???//几何图形抽象类5 g+ \$ F) w: W% P/ R
{( ^" h% {$ [( R9 u1 m
??public:
- ~9 S6 @9 f/ X1 h5 i????virtual?float?GetPerimeter()=0;?????//纯虚函数,计算周长
! U9 P; V7 J# }) [9 I6 P????virtual?float?GetAre()=0; ????????//纯虚函数,计算面积7 W' s" t7 m( E3 F3 j
};class?Circle:?public?Shape????//圆类
6 J9 s) |0 c3 z( b$ S! f; S, a{
; g, c( n7 p. h1 @' z6 O' d??public:. e9 v+ T0 B8 p" g2 l
Circle(float?rad):rad(rad){}
% y! r5 F: a; \" X2 v1 }4 u~Circle(){}
# U( L1 R( m2 P4 \7 Q????float?GetPerimeter()?{return?2*PI*rad;}???//计算圆形周长) Q6 `$ Q! C7 E, |: B
????float?GetAre()?{return?PI*rad?*rad;} ??????//计算圆形面积& {( `- |9 g: s5 x2 I) K9 n
??private:0 r4 v! s6 t. F! ?) W$ @
????float?rad;??//圆的半径
) \" Z0 K. b3 F" y6 Y6 a1 d};class?Rectangle:?public?Shape????//矩形类6 v$ g( R, \8 m6 b( ^
{4 _2 n! ^" }" @7 j/ ?% {' A
??public:??//在下面编写每个成员函数
2 {( `6 d' E8 @  X# z( S0 l. ~??private:5 b8 d3 @  k2 B$ C8 U3 B/ b
????float?length,?width;??//矩形的长和宽; T  v* \* T" z
};class?Square:?public?Rectangle???//正方形类& `6 l4 B) Y/ `" j' c
{
; _) ?. U5 Z- o. F: `, ]??public:
3 R7 ~; l/ a1 l' j# HSquare(float?len):?Rectangle(len,len){}
# [- M( b: x" F& a) K# g~Square(){}   n2 W+ b5 |  L4 |0 e# \, w
};2.?已知类定义如下,其中Shape为基类,Circle和Rectangle分别Shape的直接派生类,Square为Rectangle的直接派生类和Shape的间接派生类。请模仿Rectangle类,写出Circle类的所有成员函数。(﹡﹡﹡)
) e4 H! `, E9 ^/******************文件shape.h*************************/
5 f% k! m6 W+ W( X8 rconst?float?PI=3.14159f;??//定义圆周率常量class?Shape???//几何图形抽象类
5 \  O" ~3 V, r0 Q" k( @2 |& Z{2 j8 r& K' m9 n+ c9 f9 ~" b- ^
??public:( X( g  k: R3 l3 h6 Y3 b
????virtual?float?GetPerimeter()=0;?????//纯虚函数,计算周长. v0 G& |! ^9 K1 J
????virtual?float?GetAre()=0; ????????//纯虚函数,计算面积' g3 B5 e- A8 q+ o4 x
};class?Rectangle:?public?Shape????//矩形类
' O) d; j4 I. p% y1 z8 T{
8 f- K  Y0 o4 [0 p/ I??public:
9 U$ F1 S+ P/ ?$ ~0 |9 zRectangle?(float?len,float?wid):length(len),width(wid){}
8 D* B' N: i$ e8 d3 J" F~Rectangle?(){}
! p7 O. n; I, o????float?GetPerimeter()?{return?2*(length+width);}???//计算矩形周长" J+ L+ e) W1 `  S
????float?GetAre()?{return?length*width;} ????????//计算矩形面积
8 d7 z( N8 D; x+ n4 m! P' S8 F??private:
$ _5 z& }  l6 G/ m7 i8 B????float?length,?width;??//矩形的长和宽
+ b* F2 p( C& T$ u" D};class?Circle:?public?Shape????//圆类! |4 d  T6 ]5 k+ y# b* f$ U7 c/ }
{
, D  M( O0 F3 b9 I??public:??//在下面编写每个成员函数
8 J. k, p1 b9 w# n2 R* x??private:" m6 _. v5 I9 a: ?7 M1 f
????float?rad;??//圆的半径7 R$ g1 T6 j, X6 S+ k0 ]7 ]: i1 A
};class?Square:?public?Rectangle???//正方形类. b. n& q7 D  \3 U- j2 X' X
{
% w# P- c9 o2 A! v" @public:
1 {. ]# K# @- ^& e  ]Square(float?len):?Rectangle(len,len){}   R+ U) ]$ i: A7 Q  i
~Square(){} ; D2 P  K1 G8 H/ r
};
% p$ y, I1 C/ o& O+ m4 M- c第七章 多重继承2 Q' D1 e! R! L; \0 i
简答题:) F3 D3 p$ R% W8 y0 q4 n' K. y
1. 简述多继承中构造函数被调用顺序。程序填空题:
2 p  p: v9 Z) Z0 ]/ {% R. h1.?在下面一段类定义中,?Derived类是由直接基类Base?1和Base?2所派生的,Derived类包含有两个间接基类BaseBase,在初始化函数Init中,需要把x1和x2的值分别赋给属于基类Base1的x成员和属于基类Base2的x成员。
8 f+ f* @& h( \% i8 R% vclass?BaseBase?{2 L1 M+ j. |7 K8 P; z% S- p
??protected:
9 w' J* |. q8 H5 Z$ V9 s????int?x;4 H3 M; O$ r1 n$ \9 c
??public:
' @( t4 p& y: Z1 z. Y% \, @( b9 K????BaseBase(){?x?=?1;}! g% ^  z7 T. A# b! n, G
};class?Base1:?public?BaseBase?{
( T: V9 S4 y! [0 c- {??public:( a; Y8 n- [# a( M3 Z
????Base1(){}
' B8 L$ ~, z2 h6 H3 N3 T% W( c};class?Base2:?public?BaseBase?{7 p$ u! u$ |! \  P+ S! ]% `
??public:6 a$ x! g/ s& x3 t( P& O* v
????Base2(){}/ P6 g. u4 O$ A
};class?Derived:?___(1)___
, Y- D+ j" @3 k) B) \{/ s" _1 G& z0 w. f: w0 W& N
??public:
" ~; j9 w7 Y. }% i& V??Derived()?{}; S/ K: k7 G2 m- i
??void?Init(int?x1,?int?x2)?{$ t, @% v8 N% }! d/ S; c
??___(2)___;?___(3)___;1 v9 M3 r2 h- A% ~
??}9 X9 z/ J2 D. \- B3 D
??
2 ]. ^& U; J+ k??void?output()?{cout<<Base1::x<<?<<Base2::x<<endl;}' l* g8 z% I5 \+ y
};
1 A! Q) T- R1 ]2.?在下面一段类定义中,?Derived类公有继承了基类Base。需要填充的函数由注释内容给出了功能。- C. F2 O# U! v% d! v5 Y- T
class?Base* H! c" G) p+ T) r' m
{
# E+ U* ]0 q4 V  w6 s' P7 i??private:
, z/ o/ p& k/ Y9 ?' G. u9 r????int?mem1,mem2;????//基类的数据成员% Y8 U# C$ N0 D
??public:
. e( C0 w: {/ ~* F7 O/ X; Z) E! }- i??Base(int?m1,int?m2)?{?' K/ k' D$ L1 p/ _3 E( v& q
mem1=m1;?mem2=m2;* w* _" o; B4 |& w0 b( P& p  N
??}% L  B9 Q" F+ U9 C9 O
??void?output(){cout<<mem1<<?<<mem2<<?;}
% y6 R  x2 {4 q3 j' u9 [?????//...
( W. Z: P, [" J. @2 q, U};class?Derived:?public?Base' Y# m! i* d% D3 ?0 D+ r: F
{7 e  l  Z; b5 H: P: o: W9 q+ C
??private:
8 z. R! q+ \% y" `- b????int?mem3;?????????//派生类本身的数据成员2 L" W. ^& }# |5 ?& m" U
??public:: J6 E* T: N( i1 i9 ^& U9 F* x
??//构造函数,由m1和m2分别初始化mem1和mem2,由m3初始化mem3
+ |+ Y# P/ u7 a4 k( g' T# a& H????Derived(int?m1,int?m2,?int?m3);?
; t6 R/ r# R. Z2 b; d. Q??//输出mem1,mem2和mem3数据成员的值- n" z. s7 R! ^' G: y5 m
????void?output(){?0 f( I$ J9 I: L- O: X/ h# B
___(1)___;?cout<<mem3<<endl;6 F3 X4 Q: P# C
}
8 e9 d1 o- P* l7 u2 m//...2 g$ M9 M( T3 y; n
};Derived:erived(int?m1,int?m2,?int?m3):?___(2)___?{___(3)___;}5 f5 R2 M( q( [  ]4 S/ j. D) n0 H
3.?在下面一段类的定义中,需要填充的函数由注释内容给出了功能。3 m8 v- B" C/ I
class?Point?//定义坐标点类
0 X" ~$ L' u/ X9 D{
; l  o; r2 ~" {2 i??public:' l' t& z- l  j$ X
????int?x,y;???//点的横坐标和纵坐标# L. v, p2 q8 y7 D4 I
????Point(){x=0;y=0;}1 V3 n0 {& v/ I2 O5 J  S
????Point(int?x0,int?y0)?{x=x0;?y=y0;}?6 {5 R# O8 i. {7 [; k/ N, J
????int?X(){return?x;}
& v- X  B% d% }' b. W% I3 ^????int?Y(){return?y;}/ [5 {9 V8 c3 v
????void?PrintP(){cout<<"oint"<<x<<","<<y<<")"<<endl;}
6 b1 p4 A0 z% c( G2 `4 u% y$ J}; class?Line:?public?Point???//利用坐标点类定义直线类0 ]4 v- B0 T7 V" F6 J
{* R/ s0 W( q, B0 `# E! i
??private:
9 o: q3 f/ S1 D7 ]4 x# ?????class?Point?pt1,pt2;???//直线的两个端点
8 P8 m4 o! x( h& J- S4 l??public:
! g/ q+ P9 d& k# u6 e" o. R& zLine(Point?pts,?Point?pte);??//构造函数,分别用参数初始化对应的端点
2 u# Q% r9 Y4 Z9 g; A( W????double?Dx(){return?pt2.x-pt1.x;}
4 I9 K4 q2 s3 O0 E9 Z0 @????double?Dy(){return?pt2.y-pt1.y;}: F9 S9 Y5 w6 T5 f9 a
????double?Length(){?//计算直线的长度, W- v- u) \* S- O. @$ b
return?sqrt(___(1)___);
- p. ~, b( B, I. `; Z};
3 c  F1 h4 l- F# L$ C+ S????void?PrintL();??//输出直线的两个端点和直线长度
% ^# V0 k2 E& y% X0 Y( G+ Y};Line:ine(Point?pts,?Point?pte)?___(2)___?
  A/ \# @3 \' I# Y  L& Nvoid?Line:rintL()
! O9 U4 J5 N2 A' `; Z- _{
7 y. }0 e6 P6 _1 B( r7 R" `??cout<<"1st?";
6 A- X1 m) k6 x! o??pt1.PrintP();. F1 q% e# w  G2 u1 e8 @
??cout<<"2nd?";
  z' t/ ~, I" k! E??pt2.PrintP();
. Q% b9 k# Q0 @* N! b  i??cout<<"The?Length?of?Line:?"<<___(3)___?<<endl;
! `5 y% p+ |' v}
+ w, t6 O- n( X& s6 a+ R  f/ l答案:(1) Dx()*Dx()+Dy()*Dy(); c# v2 x+ I6 j0 W) r
(2) {pt1=pts;pt2=pte;} (或 :pt1(pts),pt2(pte){})5 T" k) c& Q! Q5 Q7 ~( U
(3) Length()4.?在下面一段类的定义中,自行车类的虚基类为车辆类,机动车类的虚基类也为车辆类,摩托车类的基类为自行车类和机动车类,类之间均为公有继承。
+ B- |) h. o1 f' [/ ^- e4 Wclass?vehicle??//车辆类
. e+ G8 D( V5 ^{7 X  G. z" ~- `, @% J" U' r
??private:
4 g( E/ ?  W8 u5 G9 s% W# L6 s????int?MaxSpeed;??//最大车速0 R7 v" L$ B3 b4 s, ]; _; o
????int?Weight;????//车重+ ~: x8 U# q( K5 m8 e
??public:
6 D. l8 p8 Q0 E& ?4 \????vehicle(){MaxSpeed=0;?Weight=0;};; R9 W2 h  Y! ?4 Z
????virtual?void?Run()?{cout<<"A?vehicle?is?running!"<<endl;}) q$ U( B: m* t: [1 [8 e
};class?bicycle?:?___(1)___??//自行车类2 k7 |. {# |0 [+ u
{?
$ a( c* z7 z3 a" n" w??private:
6 ^4 G" ~; V: O9 d2 J????int?Height;??//车高
" y" r, ]7 B5 z0 m??public:
% B9 p, n- S9 s????bicycle(){};; J2 H: B1 _+ q7 g* G
????void?Run()?{cout<<"A?bicycle?is?running!"<<endl;}) p- p# K1 A, K1 I' a. v! _9 G# i
};class?motorcar?:?___(2)___??//机动车类% T7 o) f  C, m) \) r. C* t8 I
{?; X1 X: H) X: c8 U
??private:
" M- w8 l7 i: N5 `????int?SeatNum;??//乘人数+ q, P8 A) R+ j0 c
??public:
4 n/ r, \* N8 h* ^7 P????motorcar(){};$ h+ W3 `6 U, X- m: `
????void?Run()?{cout?<<?"A?motorcar?is?running!"?<<?endl;?}  C0 c- @( ]* v/ l, _
};: O) D9 \  r, A3 b
class?motorcycle:?___(3)___??//摩托车类
4 m& r0 }4 o4 i; I1 E{?
* L% q+ V1 y" v??public:
$ k0 V6 m$ y& K8 w7 _! M1 m????motorcycle?(){};+ \( u1 b- Q; u5 W3 \* K- d8 T: _
????void?Run()?{cout<<"A?motorcycle?is?running!"<<endl;}. o( K6 e% |1 E, c4 M
};
( ?3 s4 V# y0 m" v写出程序的执行结果:
% V$ L& I- H( r! T: Y! r1. 请写出下面程序的运行结果:# R* P3 \3 |0 Q9 w. ^$ H" `3 C
程序:#include<iostream.h>
1 F0 Z2 |5 M' e# M+ V6 tclass OBJ1{public:  OBJ1(){ cout <<"OBJ1\n"; }};
1 Q% Y9 a: B5 p! ^4 x; {class OBJ2{public:  OBJ2(){ cout <<"OBJ2\n"; }};
3 K, i5 t. [' [% S0 hclass Base1{public:  Base1(){ cout <<"Base1\n"; }};
& m8 J$ L2 u5 Q3 e2 s) h1 ?class Base2{public:  Base2(){ cout <<"Base2\n"; }};
* b3 x6 P" E8 m. W% b9 @class Base3{public:  Base3(){ cout <<"Base3\n"; }};+ H' Y# g+ [% T% c$ X4 `+ E6 c
class Base4{public:  Base4(){ cout <<"Base4\n"; }};
2 V8 h/ I% M) L$ I- \class Derived :public Base1, virtual public Base2,0 \( ?0 v) i% z. U- y
public Base3, virtual public Base4{
% X7 P; a, W+ e1 r5 xpublic:  Derived() :Base4(), Base3(), Base2(), Base1(), obj2(), obj1()  {
+ v, r9 f) {# c( G2 v- R$ [    cout <<"Derived ok.\n";  }
9 Q( D  e; w9 r0 o0 t0 J. w0 jprotected:  OBJ1 obj1;  OBJ2 obj2;};
1 H4 n8 ~* Y9 c) q% `void main(){  Derived aa;  cout <<"This is ok.\n";}
+ w+ Y  _7 T  I2 T第八章  运算符重载  F7 ~! D& c8 @; a
单项选择题:
" v# d3 k- z! M( o7 T9 w. T, }1.在成员函数中进行双目运算符重载时,其参数表中应带有(    )个参数。
) G0 w6 w  i6 C( W2 y8 F! UA. 0      B. 1      C. 2      D. 39 R( V& q7 j# d8 H( |6 D
2.双目运算符重载为普通函数时,其参数表中应带有(    )个参数。
* O( l& `: H+ RA. 0      B. 1      C. 2      D. 3
  X4 c) q8 \! T3 n3.如果表达式a+b中的“+”是作为成员函数重载的运算符,若采用运算符函数调用格式,则可表示为(    )。) E! p  I: Y) \1 a$ W( L" T
A. a.operator+(b)          B. b.operator+(a)    C. operator+(a,b)            D. operator(a+b)) D* G$ f1 g" w  w6 N+ x
4.如果表达式a==b中的“==”是作为普通函数重载的运算符,若采用运算符函数调用格式,则可表示为(    )。2 c5 b6 F% o: q$ P5 O  u/ @
A. a.operator==(b)           B. b.operator==(a)   C. operator==(a,b)          D. operator==(b,a)" Q. V3 v0 G) z6 q
5.如果表达式a++中的“++”是作为普通函数重载的运算符,若采用运算符函数调用格式,则可表示为(    )。
0 k! B* `+ K/ j" mA. a.operator++()           B. operator++(a)    C. operator++(a,1)           D. operator++(1,a)
4 x" ?3 o, g  _& S6.如果表达式++a中的“++”是作为成员函数重载的运算符,若采用运算符函数调用格式,则可表
: m& R7 s5 ?8 k; ~! O* ]+ u示为(    )。
( U7 C$ j: G* C5 B6 h- i2 HA. a.operator++(1)            B. operator++(a)    C. operator++(a,1)           D. a.operator++()9 Y2 e# l( u  D; p& y
7.关于运算符重载,下列说法正确的是(   )。2 w1 W: Q  T2 z3 l! i
A. 重载时,运算符的优先级可以改变。   B. 重载时,运算符的结合性可以改变。
7 V2 K) l* p' k9 K+ T- [6 Z5 kC. 重载时,运算符的功能可以改变。     D. 重载时,运算符的操作数个数可以改变。
$ }( P' Z; L; Y% z8.关于运算符重载,下列说法正确的是(   )。( S2 B( I% A. ?; g- {  S
A. 所有的运算符都可以重载。
: |( E2 X5 H+ aB. 通过重载,可以使运算符应用于自定义的数据类型。
$ Y: b: m3 g( q+ @; J, p, nC. 通过重载,可以创造原来没有的运算符。
; h/ p! y, G7 |# U4 p3 @D. 通过重载,可以改变运算符的优先级。
/ o5 T  V. z, I+ j9.一个程序中数组a和变量k定义为“int a[5][10],k;”,且程序中包含有语句“a(2,5)=++k*3;”,则此语句中肯定属于重载操作符的是(  )。
0 g( c% K0 r# R6 ?; W/ x4 L7 M" uA. ( )     B. =      C. ++      D. *
; @3 @& g, }% C: E0 p10.假定K是一个类名,并有定义“K k; int j;”,已知K中重载了操作符 ( ),且语句“j=k(3);”和“k(5)=99;”都能顺利执行,说明该操作符函数的原形只可能是(  )。2 U8 F6 R; ]# |8 d; D# |* H# D. ?
A. K operator ( ) (int);                        B. int operator ( )(int&);( s2 ?" Z! ~% R3 B
C. int & operator ( )(int);                     D. K &operator( )(int);; G& x! I7 q  E' T1 H/ L. A
11.假定M是一个类名,且M中重载了操作符=,可以实现M对象间的连续赋值,如“m1=m2=m3;”。重载操作符=的函数原型最好是(  )。
- y; ?3 z2 I  W3 R, JA. int operaotor=(M);          B.  int operator=(M&);  C. M operator=(M&);          D.  M& operator=(M);1 y3 n# P; G/ ?9 F" q& f
12.下面是重载双目运算符+的普通函数原形,其中最符合+原来含义的是(   )。4 Q/ ?$ {  [7 Q* u0 f% \1 a5 R; X
A. Value operator+(Value, Value);           B. Value operator+(Value,int);
. A" F8 h+ R7 NC. Value &operator+(Value, Value);          D. Value &operator+(Value&, Value&);, V1 U3 o" b* h* X) d4 o
13.下面是重载双目运算符-的成员函数原形,其中最符合-原来含义的是(   )。* {% Z/ ?$ e; W$ _0 n5 i# }
A. Value Value:perator-(Value);      B. Value Value:perator-(int);* R' y' M/ o* C7 b
C. Value& Value:perator-(Value);    D. Value& Value:perator-(Value&);0 z4 i0 Z3 i, o/ A
14.在重载一运算符时,若运算符函数的形参表中没有参数,则不可能的情况是(   )。' t6 T4 L6 q( h9 X' M+ x7 J, O+ s2 d
A. 该运算符是一个单目运算符。    B. 该运算符函数有一个隐含的参数this。. p* G$ ~5 i$ p8 ~% _8 A: G
C. 该运算符函数是类的成员函数。  D. 该运算符函数是类的友元函数。/ Z, z7 P. a& ^6 ]( |! r/ Q& G7 U4 f
15.关于插入运算符<<的重载,下列说法不正确的是(   )。9 g+ s. H8 ~( S; c4 U9 W' k. [
A. 运算符函数的返回值类型是ostream & 。  B. 重载的运算符必须定义为类的成员函数。4 ], k7 |& p; S- s. P( k
C. 运算符函数的第一个参数的类型是ostream & 。   D. 运算符函数有两个参数。* T( R/ c( R, t0 H2 R' b+ w8 N; I: t
16.在重载一个运算符时,其参数表中没有任何参数,这表明该运算符是(    )。
$ ]9 M( f6 U8 ~$ S; lA. 作为友元函数重载的1元运算符         B. 作为成员函数重载的1元运算符
: b0 y% G/ h0 o( h% Z! g1 T% kC. 作为友元函数重载的2元运算符         D. 作为成员函数重载的2元运算符填空题:( J' s6 x) Q4 _" ~+ x
1.?重载运算符时,该运算符的(  )、结合性以及操作符的个数不允许改变。
% Z5 d- o( r6 n6 E% l2.?一个单目运算符作为类的成员函数重载时有(  )个参数;如果作为独立函数重载,则有(  )  个参数。" ]1 p; ^3 v2 h; ^, j4 D
3.?一个双单目运算符作为类的成员函数重载时有(   )  个参数;如果作为独立函数重载,则有(  )  个参数。
; g: D7 r" ]: x/ U  b9 w2 _4.?除了(  )运算符外,其他重载的运算符都可以被派生类继承。8 r* W4 n& S6 u, w
5.?作为类的成员函数重载一个运算符时,参数表中只有一个参数,说明该运算符有(  )个操作数。; h0 F& K% C$ K- g. [
6.?在重载一个单目运算符时,参数表中没有参数,说明该运算符函数只能是类的(  )  。
# E& v5 l) Q; ]5 n  ?; {7.?重载插入运算符<<时,其运算符函数的返回值类型应当是(  )。
/ B3 ^( I0 z3 r+ T% @0 b( }8.?重载抽取运算符>>时,其运算符函数的返回值类型应当是(  )。/ i2 [/ l5 x2 k5 X7 R* \
9.?重载插入运算符<<或抽取运算符>>时,其运算符函数的参数有(  )个。
) ~* ?( U( d9 S9 X( v2 l10.?重载插入运算符<<或抽取运算符>>时,其运算符函数不能被定义为类的(  )函数。! X5 U/ }7 N! y. K8 [6 K4 b  y
11.?类型转换函数没有(  )类型,而且参数表为(  )  。程序填空题:
7 T/ ]7 V: y# C* i+ S9 _, `1.?已知一维数组类ARRAY的定义如下,ARRAY与普通一维数组区别是:其重载的运算符[?]要对下标是否越界进行检查。# @7 x# u1 S. [8 \4 d  Q7 o- O8 p. `
class?ARRAY{???7 U: H1 v3 r/ ]7 d' ~
int?*v;???????//指向存放数组数据的空间
* D0 O, U3 ^$ u6 _$ {' Iint?s;????????//数组大小??
2 k9 y/ L+ K  r7 x& Q! Bpublic:???
7 ?$ s4 ?  ~% X7 R# L* J- d3 lARRAY(int?a[],?int?n);
1 J9 S* Q) }1 Q6 u????~?ARRAY(){delete?[]v;}  i# N% T+ p6 x- Z. z$ _
????int?size(){?return?s;}?
) C8 x& F3 h  G" w5 |+ Lint?operator[](int?n);?
9 q- D+ E8 J8 k+ @};% z0 n) ~# c5 K7 e
___(1)___?operator[](int?n)??//[?]的运算符成员函数定义
/ Q( Z/ |  E! x7 f5 g, Q  F7 J{6 K, o. H+ e7 z: H8 ~6 p
if(n<0?||?___(2)___)?{cerr<<"下标越界!";?exit(1);}
# {+ ^+ e9 u2 a" X, p% d' u  s  b????return?___(3)___;
% l6 [# g* P8 a5 P5 R8 z}2.?已知一维数组类ARRAY的定义如下,构造函数的作用是把参数n的值赋给s,给v动态分配长度为n的数组空间,接着利用数组参数a初始化v所指向的数组。
$ ^' g' G+ L8 ^1 q+ l4 y4 Rclass?ARRAY{???
' L) o4 k+ v7 l* s" J$ M1 pint?*v;???????//指向存放数组数据的空间/ j) F5 z( I9 }1 a
int?s;????????//数组大小??+ t( O* D/ O7 g% p" f
public:???
0 k% Q$ r& b5 M; b! Z( H9 \ARRAY(int?a[],?int?n);
. {& ~" u. g+ V+ ?1 {' w+ b????~?ARRAY(){delete?[]v;}, ?  d$ p6 O8 _/ B3 `
????int?size(){?return?s;}?
4 k6 i6 }" M  ?8 I1 r# H. U2 Pint?operator[](int?n);?) H$ j  Z- ]/ i1 K" x: A( y
};4 V2 C+ e4 w5 e- ]% _9 o- a- v3 V
___(1)___?ARRAY(int?a[],?int?n)1 S6 K4 J: a, z4 B
{' Q# g0 o/ e9 E- |7 P9 q% M
if(n<=0)?{v=NULL;s=0;return;}
, @3 ~; J2 S. `* \1 R# cs=n;
4 c% c1 [9 A+ @1 g* Iv=___(2)___;
4 C* F- N2 u' W0 R. [for(int?i=0;?i<n;?i++)?___(3)___;0 v0 }) E- ^$ m$ l
}3.?下面是一维数组类ARRAY的定义,ARRAY与普通一维数组区别是:(a)用()而不是[]进行下标访问,(2)下标从1而不是从0开始,(c)要对下标是否越界进行检查。
1 w: R6 V8 f8 a/ J& f* q4 Hclass?ARRAY{???7 C5 e- z# ~7 g5 B% }4 G0 o* h
int?*v;??????//指向存放数组数据的空间" F$ T% t2 N$ d& j8 Z  O( B, J
int?s;????????//数组大小??) I$ v+ j8 n( E
public:???
6 Q/ L: a3 v- t- V( tARRAY(int?a[],?int?n);8 F% S! t+ b) ?" b2 M
????~?ARRAY(){delete?[]v;}
) P- |; _9 D' M& ^- F& j, D8 c; U" k????int?size(){?return?s;}?: O& z2 k% ~/ [5 w' M' ^
????int?operator()(int?n);
+ q2 ^/ M! ?+ e};?___(1)___?operator()(int?n)
( L# {# Y8 ~$ o1 m& r, I{??//?()的运算符函数定义??+ B+ k6 r/ L6 }. l
if(___(2)___)?{cerr<<"下标越界!";?exit(1);}( E% M2 W6 B0 {3 R( N4 N
????return?___(3)___;  a6 b- o2 ^5 m' G
}写出程序的执行结果:9 U' O# x0 r3 ?2 c* w
1. 请写出下面程序的运行结果:* h" O+ ]9 ~; t! p7 O
程序:: j2 w: V# ^7 K) Z8 G' i/ N) K
#include <iostream.h>     ) ]% D% G5 C" ~6 Z  B4 ^/ ?
#include <iomanip.h>//控制符是在该头文件中定义的对象" @, M7 g- o8 b( n& E
void fn(float interest, float amount){7 t5 _6 p& v) L5 g) B. z2 c) B
  cout <<"RMB amount = " <<setprecision(2) <<amount;
. H3 D; H- l) b- Q  cout <<"\nthe interest = " <<setprecision(4) <<interest <<endl;}
. z, @  K. r; Qvoid main(){
. V2 s7 q! ]* Q+ m  float f1 =29.41560067;0 r6 ?" \! r6 U
  float f2 =12.567188;
  I2 O: h9 O, _- ~  fn(f1,f2);}程序设计与分析题:% }$ J. ^: h9 w. Q' E, J
1.程序:
; d' `# j! v  S6 G#include <iostream.h>: X8 S- }2 H9 a
class complex{  private:   int real ; int imag ;
& e. ~' X9 ~+ Lpublic: complex(float r=0,float i=0);
, ^$ T2 v: H! Ucomplex operator + (complex&  c);
: ]9 Y3 @! N* X( b' G) Ncomplex operator - (complex&  c);
3 x, G, `' F. R. |' v2 n( f5 lcomplex operator - ( );  void print( );};4 ]9 |% ?# m8 F. P* f8 a1 T8 }8 I
complex::complex(float r=0,float i=0){real=r; imag=i}
  c5 t' U  q! k9 ?+ u7 b2 \9 `complex complex:perator + (complex&  c){3 ]' b' K' p- Y  E/ @2 h9 v
float r= real + c.real ;float i= imag + c.imag ;return  complex(r ,i );}
! ]7 H. p3 }/ vcomplex complex::operator - (complex&  c){
+ ], B+ p7 L( g6 s4 c1 M' Mfloat r= real - c.real ;float i= imag - c.imag ;return  complex(r ,i );}
+ |. J4 W" m: k4 [complex operator - ( ){return complex(-real,-img);}3 A- R& M2 h5 V# U0 P0 Y
void complex::print( ){cout<<"("<<real<<","<<imag<<")"<<endl;}6 V1 S( A$ f5 x) K4 H
void main(){complex x(2.5,3.8),y(4.7,5.4),z;
  a* ~) M  y3 e) L! q9 @z=x+y; z.print();z=x-y; z.print();z=-x;  z.print();}
1 W* l4 R- Q% Q$ d. C0 A问题:本例是使用类的成员函数来实现复数类的运算符重载,请在不改变主函数的情况下,采用友元的形式来实现复数类的运算符重载。写出相应的程序。第九章 模版
: _0 K- \, F- H- w0 Q: d$ v/ k" Z6 C单项选择题:7 h: Q" k6 j8 N
1.以下关于函数模板叙述正确的是(    )。
) C% H# R- f4 G3 h- IA. 函数模板也是一个具体类型的函数) X# Z  ~) Q+ L
B. 函数模板的类型参数与函数的参数是同一个概念
5 T, ?" Y5 q) |  l6 oC. 通过使用不同的类型参数,函数模板可以生成不同类型的函数4 k& C9 _/ ?4 P& @4 N  A
D. 用函数模板定义的函数没有类型填空题:
$ g7 W! [0 m3 q0 @" r' q0 w5 c3 W1.?定义一个函数模板要用到的第一个修饰符是( template )。
+ |- A+ j6 X9 H! [. c3 j# r  b' W2.?在函数模板的参数中,用class修饰的参数称为( 虚拟类型(或类型) )参数。
; ]8 O% w: n4 D0 O5 A' n& T2 @0 s3.?如果一个函数直接或间接地调用自身,这样的调用称为( 递归 )调用。
% H- G, n0 P! w1 {4.?已知int?cubin(int?n){return?n*n*n;}和double?cubin(double?n){return?n*n*n;}是一个函数模板的两个实例,假定类型参数用T表示,则该函数模板的定义是( template<class T>  T cubin(T n){return n*n*n ; }  )。写出程序的执行结果:
' C0 f6 }0 e1 H1. 请写出下面程序的运行结果:; m3 o# d3 O# Z' e: h2 Z6 |
程序:
# I; T5 C. m6 A0 s6 h  # include “iostream.h”                                        & r  I  S3 ?) B4 u+ r) z
  template < class T>                                             
: j6 K# _( Q: _7 t- `3 D  T  max (T x ,T y)                                            0 H1 a- I- K- E, u6 r6 }* I
  {  return (x>y)?(x): (y);                                       ( L9 ]( R$ ~  M9 C, S4 F
  }
. I* A& P, ]* y- I! Q" r7 T3 c  void main ( )
/ D/ @; J2 }8 p  {
5 x3 p7 b  i' p9 w6 [% N     int x=3 ,y =4;                                               + j) u7 `; k$ n: B( M6 \8 o
     double a =1.1 ,b =3.4;                                       
5 x! p8 i- F1 z5 Y     cout << max(x ,y)<<endl;                                     8 E0 L; ~- @! }. c& @4 ~$ B
     cout << max(a,b)<<endl;                                      : h/ S1 Y! B0 z4 |+ g& u
}2.请写出下面程序的运行结果:
7 k' M. A' Q( I5 {% {: t程序:1 {/ y$ }' z) X6 V; a
#include <iostream.h>! c/ l' Y' L* _$ M& D6 R0 |; k: i
void swap(int &x,int &y);
! Z& u4 C. m! W- Y3 B7 l3 [8 b$ Yvoid main(){
, f* k8 O0 `, T/ g0 U7 v  int x=5, y=6;  s5 q( Z9 [4 z2 r8 h
  cout <<"before swap, x:" <<x <<" ,y:" <<y <<endl;
; G+ I. l& O. G8 ~  swap(x,y);! A9 }* \- T( B; A, D. r& H& P
  cout <<"after swap, x:" <<x <<" ,y:" <<y <<endl;}
7 C- h* e5 V; O0 ^& N( T7 ?void swap(int &rx,int &ry){
* A+ O6 p0 k  K* U3 @  p/ m  int temp=rx;  rx=ry;  ry=temp;}www.ap5u.com提醒,答案可以联系 QQ或微信 761296021) a/ C& x7 V3 g% Y' A9 f
作业帮当前离线
高级会员

查看:167 | 回复:0

热点排行更多
手机版| 网站地图| 无忧答案网
免责声明: 本网不承担任何由内容提供方提供的信息所引起的争议和法律责任。
Copyright © 2020-2030 5u.studio. All Rights Reserved.   Powered by op5u X3.4
快速回复 返回顶部 返回列表