|
! u/ Q4 N% p) Z( I7 [/ n! f* l/ e7 d16春学期《面向对象程序设计》在线作业 + G9 S; n9 ~' g6 ~
" ^/ U% f$ Y/ h& o1 l& q
5 |6 V2 V- q3 @% C
) e. g1 B3 B, T8 k$ ~7 ?+ H, z1 T( E0 X j( x
一、资料来源(谋学网www.mouxue.com)(共 35 道试题,共 70 分。)! ]1 d2 K- {* t- ` o9 G. {
: }; b! d# Y/ t# s E, d% O1. 下列关于动态联编的描述中,错误的是()。
7 P6 d0 e, s o5 E) J) Z! z( y. 动态联编是以虚函数为基础的
3 s' }# ~( R5 l& h/ a( n. 动态联编是在运行时确定所调用的函数代码的2 s0 `; J0 g/ e* J
. 动态联编调用函数操作是通过指向对象的指针或对象2 \- F" e2 A: u/ a. |8 M$ T, k
. 动态联编是在编译时确定操作函数的
# i; m" Q: F4 m4 [正确资料:
. \* Q" G! l( C( x$ t7 K& f$ p2. 下面关于构造函数和析构函数的描述,错误的是()。1 B9 G( J3 u" h8 H9 ^4 c; p# G
. 析构函数中调用虚函数采用静态联编7 o6 M; j5 J7 [" P/ |+ l( b
. 对虚析构函数的调用可以采用动态联编, I) l. P; t& Q0 \3 A% Z
. 当基类的析构函数是虚函数时,其派生类的析构函数也一定是虚函数
2 a) f/ i3 p& V; k. 构造函数可以声明为虚函数
& E) ]4 _ ]* H正确资料:' h6 x: r5 z y
3. 结构化程序设计方法以()为中心进行分析和设计。8 ~6 b( E7 |; |- Z- z" O
. 结构3 ^ ?0 F8 G5 @0 X" @, p! `6 c
. 模块
/ S+ ~! ? ]/ i. 对象
5 q& \8 f- A, u' q1 u7 }* s$ W6 b. 类
0 O B& ]' d$ J3 b3 C/ x" B正确资料:
% Z$ y$ m A K& E7 i7 ?4. 如果一个类至少有一个纯虚函数,那么就称该类是()。) s$ ?; D8 M/ d( O& |' W B+ Z
. 抽象类
9 Y/ y+ g* b. }# m. r; _9 _. 虚基类, q0 |, w5 ]1 s/ Z* f
. 派生类' }* Q' l; y2 ~1 z4 {
. 以上都不对 j% j* a( ?2 _2 a. J- s
正确资料:* |( F7 W2 V. E* |* d/ S
5. 下面对静态数据成员的描述中,正确的是()。
! G: ]! B, K e9 D& z3 k4 e. 静态数据成员可以在类体内进行初始化
# ~$ O& s8 I( |( a4 ~+ I9 t. 静态数据成员不可以被该类的对象调用$ l3 c/ s7 L" c1 L6 [5 |0 i, ?% o
. 静态数据成员不能受privte控制符的作用6 S$ R% i4 @6 n2 l0 P* G3 |
. 静态数据成员可以直接用类名访问
& c% J" @* s, o3 t# n正确资料:. W. k; w" ~6 i* ~2 ` ~
6. 下列关于继承的描述中,错误的是()。
: a K0 K! }: \" V6 r" y( D) y. 基类中的析构函数不能被派生类继承: q) d- Q6 \- u8 P6 }, J$ u2 J3 M, ~
. 基类中的保护成员在派生类中无法直接访问# s7 m) X j0 i
. 派生类的成员除了包括派生类中自己定义的成员外,还包括它从基类继承的成员2 t8 [2 A4 G2 V/ e
. 在公有继承方式下基类中公有成员和保护成员的访问权限到派生类保持不变/ B! i9 d4 R# r6 f
正确资料:5 D5 b, B1 c& E P# s: R
7. “#inlue <iostrem>”是()预处理命令。* H- }. W6 ]1 B' A8 P% g
. 宏定义
: E/ X( z+ U" b, I9 m. 文件包含7 e9 o" ~+ H8 {6 n% ]
. 条件编译8 s+ h5 K% \4 e8 p
. 工程配置
- t& ~( i8 r* h. y2 B( o; Y+ E正确资料:
( ?# ~) P; P) x5 I' {7 j6 L' X8. 使用string类,必须在程序中包含头文件()。3 V$ d) z7 F( B& b, E6 u
. string.h
- h4 _. L/ M9 l, z9 y7 `. string
& t! L& V3 A3 H1 g. string.h
; ]% W+ {. l0 ?5 y$ |; \5 E: b. string
0 t. E0 H; D9 I" D正确资料:
" {& ?0 k+ O( g$ k( u* N" o* J9. 多继承的构造函数顺序可分为如下4步: ①所有非虚基类的构造函数按照它们被继承的顺序构造。 ②所有虚基类的构造函数按照它们被继承的顺序构造。 ③所有子对象的构造函数按照它们声明的顺序构造。 ④派生类自己的构造函数体这四个步骤的正确顺序是()。1 L9 q' u8 X5 Q' V' [! q" t
. ④③①②7 g. m! G' l Z9 X- [
. ②④③①
+ {% ]& C0 J+ ~1 j) f1 M8 S. ②①③④
$ H' w! ?; P2 q3 x. ③④①②% t, S" }; }9 e) f- @5 a
正确资料:5 V" m6 J2 Z, m9 _
10. 抽象类不能定义对象,但可以声明抽象类的()。
Y0 J4 m9 X* N' |' f' ?( S5 U. 指针或引用
, X7 y7 E6 T' J. 函数返回类型
& R% w7 y0 }" z" k; w9 |% [" F. 显式转换
, u9 J9 A# E* Q/ v4 I. 以上都是
7 G$ q# f% {! k6 _/ K& n( Y$ ]* Q. Q正确资料:
2 b1 y" k, i3 Q# t11. 下列虚基类的声明中,正确的是()。/ S5 i4 ~+ G Y$ ~$ [7 ]2 n
. lss virtul :puli " B, G7 D8 ^ T" X) N) |. E' j
. virtul lss :puli 0 @+ |( C" K/ s5 g' ~
. lss : puli virtul% m5 A5 R7 b$ Y/ O4 J+ k1 n
. lss : virtul puli
! Y0 U" `" U# O6 z5 J, b正确资料:
i% O; H4 p1 \8 \2 x9 I5 }! f% a6 G12. 已知“int =10;int &r=; r=r+20;out<<;”,则输出为()。! Z! K# U% L1 z7 ^% J
. 10: o% Y& `5 w; P E
. 20( Y) p |, U# H# {* @7 [
. 303 m1 | g( `; `! r; J
. 不确定值
4 f: q! ~- W/ M+ _# T正确资料:
/ k* j. d* ~2 @/ A7 u13. 已知“int =10,=8;int &r=; r=;out<<<<","<<<<","<<r;”,则输出为()。& E P2 L, Q# }' d z7 }( M
. 10,8,10) z" w& }0 U0 z# l, S; K$ _
. 10,8,8
, s! [- C( d- r. u, p. 8,8,10* ]7 {% e, g& n6 r
. 8,8,89 |0 P- w4 |; g6 E
正确资料:
Y3 K, B% L: I! `$ ?' |2 z! w14. 执行语句“string str("");”时,系统会自动调用string类的构造函数()。
4 D# P: `% w" n/ M+ D3 j% m: W% A3 w. string(). C( x, O7 t) p8 o' p
. string(onst hr *s)! Q# L' D7 W+ X1 S
. string(onst string &str)
) ?2 j5 Y' I( S. string(size_type n, hr )# b& o7 {9 H3 Q. [# U
正确资料:
$ j- f ~1 ]' N/ a5 G15. 下面描述中,错误的是()。
( o7 k9 |7 X/ C* Z. Q% O; p: y. 公有继承时,基类中的puli成员在派生类中仍是puli的7 @8 J; k* c1 L- p4 h7 c- r
. 公有继承时,基类中的privte成员在派生类中仍是privte的4 \# ~% t, z, E5 \1 }! B
. 公有继承时,基类中的protete成员在派生类中仍是protete的% U% |2 U9 k6 v/ @, {
. 私有继承时,基类中的puli成员在派生类中是privte的
( p# a) S1 U* F3 ^; }3 h6 X2 L6 c正确资料:& Q4 c1 k8 \: R7 F+ L9 n) h: ?9 {
16. 有关重载函数的描述正确的是()。1 c- F, e1 E i# m) s# s7 q0 \
. 函数名相同的函数就是重载函数& B" R$ c' G2 `8 z$ W' s
. 函数名相同但返回值类型不同的函数就是重载函数
- F( F; x) y: T, ]) I* e5 T% H. 函数名相同但参数个数或类型不同的函数就是重载函数4 \! f# p, V. Q. f. m/ H: {& z/ D
. 函数功能相同的函数就是重载函数
9 y. [8 D! J6 M, S6 L1 J正确资料:
2 V* d5 m& N0 Z9 Z5 U. B4 E: m7 `17. 以下为重载函数的一组函数声明的是()。5 {4 ?! C* p* d i/ U
. voi print(int); voi print(oule);" G; ?, w3 B( z6 `
. voi fun(int); int fun(int);) o1 y) Y# Q" J" A& y
. int mx(int,int); int min(int,int);
$ T5 _/ U$ o) _ ]( I5 `. voi mm(); int mm();
" h0 A5 `$ _ E正确资料:- J* o: k& Z7 f% ^% k% C+ h
18. 对、两个类进行多重继承得到派生类,则创建派生类的对象时,从基类中继承过来的成员变量由()类的构造函数进行初始化。
8 ^- y1 I3 D0 D# M& g" T m7 M. ) @7 b- b0 h+ I( A V9 L" \4 E5 z" d5 x
.
! ]9 G F! \7 y5 u- G" c4 F.
2 {0 j- h1 ?% s. 都可以
' |4 J/ Q8 N! E) Y3 k正确资料:
4 f; k' H7 G7 ?6 C19. 运算符重载的目的是()。4 W5 x6 ^ Z& Q) L! w
. 提高程序的效率
4 r" |, t$ Y5 i$ s. 提高代码复用能力& l( \7 J0 s9 R" g
. 简化程序,减少目标代码# m+ I4 N# \$ m- g# g
. 使程序代码直观易读4 C; O4 G9 ?: E+ ^, ?/ B
正确资料:" C4 j! Q. F; l4 {3 N
20. 要在类对象上使用运算符,以下不用必须被重载的运算符是()。
7 B3 m0 V2 K0 i9 B, e. [ ]
4 V* {/ K- _7 V5 w: X. =* E" P: r& h& B
. ++
1 N7 B8 i' F9 a: _% p$ }. --2 }6 f( K! E. s, r9 J- K/ D
正确资料:
- x- P5 }3 u" d21. 关于纯虚函数和抽象类的描述中,错误的是()。
. ?! s# J! s) D. 纯虚函数是一种特殊的虚函数,它没有具体的实现。7 u; s x$ q8 p4 c
. 抽象类是指具有纯虚函数的类。' ]* X9 a. o/ x7 z1 U( w) P
. 一个基类中有纯虚函数,该类的派生类一定不再是抽象类。9 q; f# m1 w7 M% e' P
. 抽象类作为基类来使用,其纯虚函数的实现由派生类给出。
+ o) u5 t5 r* e4 p! S) h正确资料:) Z2 w7 H. s) d1 Z
22. 对于拷贝构造函数,正确的描述是()。8 G0 I$ e, H6 q- q( n0 F/ z; o; k, P
. 在++语言中,如果不自定义类的拷贝构造函数,则每个类都有默认的拷贝构造函数
/ |: w( d( m) ]: g- q. 必须为每个类定义拷贝构造函数
$ \) G6 E& K7 j, H% L7 a, G) A. 如果要使用拷贝构造函数,则必须在类中先定义
/ r$ |. H! p& _: k5 u. 当定义了类的构造函数时,如果要使用拷贝构造函数,则必须定义拷贝构造函数
, t( z+ x- Q6 U( B6 V, k {正确资料:
* D- u; M x4 E0 k+ X" W23. 下列关于赋值运算符重载的说法中正确的是()。 p$ x% N) c# S6 i+ a, I
. 返回值一般是以引用方式返回的对象,而函数体中总是用语句“return *this;”返回this指针所指向的对象0 n9 Z% C1 q! ~0 z7 T5 M( @
. 赋值运算符只能以非成员函数的方式重载; M5 l$ d/ d8 G w0 W y: @# L4 q+ u1 J- A
. 赋值运算符既可以以成员函数的方式重载,又可以以非成员函数的方式重载
6 [* }. B2 C* p$ u* Q' l. 以上均不正确2 x( Y( n6 Q7 s- Y E! P
正确资料:0 J& T! M) ^5 {# ]
24. 友元重载运算符oj1>oj2被++编译器解释为()。
z% Y M( |1 o2 P$ ]3 D$ Q: d% ?6 F/ F- J. opertor>(oj1,oj2)6 @. Q0 k/ B- Y! i
. >(oj1,oj2)1 ^3 ^* W+ W4 c
. oj1.opertor>(oj2)
% ?, o H3 c m: b. ]& Q. oj2.opertor>(oj1)
$ Z# b' Y$ o# C1 J! l: u# u正确资料:
5 C3 m& y t# ]9 m/ z' I( e25. 下列关于类和对象的叙述中,错误的是()。 B2 ~7 s7 F8 O- ^8 p$ K
. 一个类只能有一个对象
& f s4 r5 O8 y* I2 t1 W U. 对象是类的具体实例
! _+ U Z% n& ?2 b3 K. 类是某一类对象的抽象' p' d9 X; h- e/ ]
. 类和对象的关系是一种数据类型与变量的关系
) p/ J ]8 h& p: U正确资料:% E6 O' n( Z9 \8 x# P. T4 ?
26. 下列关于拷贝构造函数的描述中,错误的是()。
' C4 P0 O! h5 L) m8 _$ O1 A. 一个类可以定义多个拷贝构造函数+ t3 Z0 v1 c T: J. I( M, {0 c Q% H
. 若未定义拷贝构造函数,则系统会提供一个默认拷贝构造函数
+ T2 D G; d. h+ l# M ^: M8 i j. 当类中有指针成员变量时,通常要为这个类定义一个拷贝构造函数来实现深拷贝: x4 _7 H1 N" `4 i; n
. 拷贝构造函数中的参数按引用方式传递2 H" L/ G- ~+ W. r. H
正确资料:
* W; @8 p" C. x: _' t* M27. 有如下类声明: lss Smple { int x; }; 则Smple类成员x是Smple类的()。' A! M Z* x1 M4 q/ Y5 c0 C
. 公有数据成员( w$ b9 ^4 K6 R6 ^; c2 |
. 保护数据成员( P7 |+ r2 x1 F& I$ `1 J& P/ T
. 私有数据成员& D J, C( v8 `+ l( _
. 以上选项都不正确
' l* N6 n/ Z- {% y- ?4 Q8 e; @0 |正确资料:; j, Q( V2 J1 G; b2 |( b8 H
28. 已知“flot *p; p=new flot[2];”,若要释放p所指向的堆中的这些字节,下列语句正确的是()。. J" l+ W1 v7 ~$ z8 G. Z( ~9 A* R
. elete p;( g. I$ N* Z# K" v
. elete p[];
4 m2 B7 o6 Q/ s( k6 C- C! j. elete []p;
+ q$ R+ t5 o: E- F3 U, M. elete p[2];; [) p, p8 S) Z6 G( C6 V+ {
正确资料:& k: K9 O8 w% B# M( M
29. 在派生类中重新定义虚函数时,除了(),其他方面都应与基类中相应的虚函数保持一致。# c4 ?* i1 l5 P5 d3 L7 G1 m
. 函数名* O6 E1 U5 f" ^0 N& E+ I0 V' @
. 参数
2 _; B) R: W7 Q4 D. 函数体8 }0 p6 g& _' {8 T5 B7 P* @
. 返回值类型8 F: T4 D, Z; m- z& R- v
正确资料:8 I% U, @$ U* U3 v1 `; x# v. d1 r' Q
30. 有关带默认参数的函数的描述正确的是()。 b( ^4 p0 }1 z7 T9 J3 G1 i& F0 }
. 只能在函数定义时设置默认参数值6 q% u# k$ j* E) m8 ?: h
. 只能在函数声明时设置默认参数值
& w# B" S C8 G' e% i4 J3 r8 [* R! S. 函数调用时,必须使用默认的参数值,不能给出新的实参值# W1 ~5 S' ? a ~ e
. 设置默认参数时,应该设置最右边的若干个参数的默认值
; \! E, I4 g; Q5 k* q2 N正确资料:
. H2 d& _0 y2 R: ?. |31. 在表达式x+y*z中,+ 是作为成员函数重载的运算符,*是作为非成员函数重载的运算符。下列叙述中正确的是()。! W! p2 |7 O6 }7 m% w3 k7 u, @' j
. opertor+有两个参数,opertor*有两个参数( Z& Y4 J% W7 _7 j
. opertor+有两个参数,opertor*有一个参数0 z, Y1 x0 c- O. ^0 Z- \& i
. opertor+有一个参数,opertor*有两个参数
, H# c1 }) J- _& X/ m. opertor+有一个参数,opertor*有一个参数5 I6 U- n% \( D* d( v
正确资料:. z* H& T9 s- |8 r. R
32. 下列对派生类的描述中错误的是()。$ v2 w: D. D/ Z3 n* T7 y7 P' ~+ y
. 派生类至少有一个基类" ]! W3 Y) Q2 {7 o2 B
. 派生类可作为另一个派生类的基类4 o6 m6 }7 R9 u2 d+ F+ Y
. 派生类除了包含它直接定义的成员外,还包含其基类的成员
# B! t; B! d; O- j/ B. 派生类对其继承的基类的成员访问权限保持不变
+ f( C: T& s: k O" y; T p正确资料:
4 I5 ^8 w; S2 L6 L' P33. 类Mylss的定义如下: lss Mylss { puli: Mylss() { vlue = 0;} SetVrile(int i) { vlue = i; } privte: int vlue; } 则对下列语句序列正确的描述是()。 Mylss *p,my; p=&my;
" |. U9 @: E: z; P" |. 语句p=&my;是把对象my赋值给指针变量p
- S: |: r$ I+ H$ \1 T* I) p& T8 U/ U. 语句Mylss *p,my;会调用两次类Mylss的构造函数
3 h" ^" ~ v$ Q: e. 对语句 *p.SetVrile(5)的调用是正确的
; K2 r i6 j' Q. 语句p->SetVrile(5)与语句my.SetVrile(5)等价8 O( }) o: i8 ~. a4 h; f
正确资料:9 ]7 A5 U: y( P
34. 下列运算符中,()在++中不能重载。! W8 |: F5 }" r8 o
. ?:4 `2 Y7 ~; K( [- x7 x0 Q* F& a
. +3 N5 Z$ w' J8 X& W
. -
# U1 y& D- x) b5 \3 H, ~. <=
% P5 M* }3 s I" F正确资料:, E8 d% p, _: A4 p
35. 已知函数原型:voi f(int , int =3,hr ='*'); 则下面的函数调用中,不合法的调用是()。" Q0 k0 e# ~$ I7 t1 _0 i u
. f(5)1 u, j. ?3 c8 U4 t: L6 W
. f(5,8)) D+ N C' s* K/ v- e
. f(6, , '#') `. X4 B$ k+ _( ?+ `
. f(0,0, '#')
- r) R5 o! g0 w正确资料:, w0 p; R! Y8 J# _6 K
* |! S; B. w* S2 J Z
' T! p. k: e* n3 ~) @' J, O) S
" S: q1 I! @' p4 }9 r* c+ i C1 I
16春学期《面向对象程序设计》在线作业
5 B, K3 s& ~. [8 _# y5 [3 Q2 H) K; Z! Y2 K" Z! y
, ~: I! [ l4 ^: I% x
- D' K1 g4 N1 u8 J' u
$ r E1 b# V& d3 ^, W1 v4 ~$ U4 W二、资料来源(谋学网www.mouxue.com)(共 15 道试题,共 30 分。)
" @6 t, z+ U8 i4 f( a6 q# M3 X: A- T1 Q$ b5 G' e
1. 抽象类虽然也是一种数据类型,但它不能建立对象,只能作为基类被其他类继承。* g) g! Z9 }/ `; K- [
. 错误9 A [# `& | X3 ?
. 正确5 U r2 d9 X) T# ?% f
正确资料:0 i8 ^% w- |1 s/ e# A1 M. W1 L6 E
2. 为Mylss类对象,“stti voi SetRte(oule r){...}”是Mylss类的静态成员函数,则执行语句“.SetRte(0.05);”时,SetRte成员函数中的this指针指向对象的地址。
3 q2 x7 Z$ T# n- J. 错误
$ Y! a2 Q5 p* D4 Q# l. 正确. L, s, V' i# l3 m' l8 S
正确资料:' N# [4 R% s6 P8 u3 P1 B$ ~
3. 抽象类不能定义对象,但可以声明抽象类的指针或引用。3 h6 f* e7 l" k0 J
. 错误1 u1 n( M3 q; S+ [0 ]- x+ D7 k
. 正确
6 O; ] w' v3 ?3 P [5 U正确资料:* P. M5 y) M' t' v
4. 一个类的静态数据成员被该类的所有对象共享。- m% ~7 h& M' \! C) j4 Z4 R
. 错误* I$ F* L7 w& }1 C! v5 _
. 正确1 M C+ t) h# _/ H5 w( p3 s
正确资料:
4 O6 M% n( [5 V1 I' g9 c4 d5. 在++中,可以声明虚构造函数和虚析构函数。
1 t; X! k* i6 R8 x& u. 错误
0 J* ]2 e$ D1 R# s- l/ P& D2 y. 正确
3 H @. f. }" V5 w' `+ a: x正确资料:1 N9 i+ f$ D, ~ Z# Y! g9 ]" q
6. 在一个类中声明了某个静态数据成员,并在类外给出其定义和初始化后,若未定义该类的对象,该静态数据成员则不存在。% s4 J1 x/ Z- W, ~
. 错误
* _% }3 K8 K( }( i8 h. 正确
. h3 @# c+ z1 v! S1 X& [7 U( \, ^正确资料:6 C& w$ ^' X$ G* ~+ W( t
7. 类中所提供的成员函数可以直接访问该类的私有成员。
c' p* @: K2 d2 e. 错误
& j. }# v+ O8 ~ J, z2 H. 正确
+ L( v+ D! M+ k `* U8 G' ?- }正确资料:
: {# t4 q! L: s1 D& i( @8. 在派生类构造函数的成员初始化列表中,可以包含基类构造函数的调用。5 I0 |0 K% f8 v3 e2 b' U8 w
. 错误
& g1 v/ Q$ q Z/ f' O X( i: {" B. 正确1 v) x7 I' f; m. t) H ^
正确资料:/ O T/ r, s; h% ^
9. 在++程序中,有且仅能有一个主函数,且其函数名必须是min。) f- D' w; Q& p( Y+ E/ y2 Q
. 错误
5 D& i+ Q7 V: d! n. 正确
; p% P k0 i k5 [/ S4 O. P% m/ F正确资料:( a4 g" j% J8 m/ N* s5 u6 d
10. 假定要对类定义加号操作符重载成员函数,实现两个类对象的加法,并返回相加结果,则该成员函数的声明语句为: opertor+( &, &);, S! b% r, a8 @8 ]" r
. 错误
8 k* o) A( F- @& Q, H0 [& `. 正确9 ^0 f- ~( m" ^" a) u! s4 ?
正确资料:4 H, Z5 v, h# v* ]& c- ?' q
11. ++语言类定义中默认的访问权限是puli。( Q' j8 f) n3 \6 F
. 错误4 p# i4 l" K" V' I$ e
. 正确) n3 D. x4 ]( V7 Y Q8 s# h
正确资料:
7 Q8 _) {, b# P) b9 p8 B12. 在++中,允许从一个类派生出任意多个类,但不允许某个类同时从多个类派生。+ f0 E' g, z- L5 W
. 错误+ j0 R V* ]3 }
. 正确: y2 A' Y# W- s) l
正确资料:8 [! G+ Y# Y) J" D5 g9 K
13. 定义一个虚基类后,则该虚基类后继类层次中的类都需要调用虚基类的构造函数对虚基类中定义的成员变量进行初始化。5 H' K* B+ u, X/ a {
. 错误
3 N! Q/ r' u1 }2 P9 i1 n" L. 正确, d S( d- H0 |: P0 f
正确资料:8 ]' ]: O; j7 W& D5 O; R
14. 要使语句“Mylss ;”能够编译通过,必须在定义Mylss类时编写无参构造函数。
! F2 Q9 }* T* B8 b$ q5 C. 错误
( o, t9 Z" R3 l6 c2 C. F0 Y. 正确* _& b. ^8 n1 |3 N( H; P* U! y
正确资料:
1 X7 T: L& J4 k4 q2 i15. 构造函数不能被派生类继承。) C% T( S/ V+ K* [7 t
. 错误
+ w: ]! V( n: P+ d+ R1 f4 N9 H. 正确& X* C$ a3 C0 ^. F6 N
正确资料:
+ B0 X7 Y8 w5 h5 Z% }. c K t1 I9 B8 e6 X1 s* B) U) [
- _ a- l1 u6 p0 Y8 m
# Z/ A' j2 c* I( x! D& |
谋学网(www.mouxue.com)是国内最专业的奥鹏作业资料,奥鹏离线作业资料及奥鹏毕业论文辅导型网站,主要提供奥鹏中医大、大工、东财、北语、北航、川大、南开等奥鹏作业资料辅导,致力打造中国最专业的远程教育辅导社区。 |
|