全国2008年10月自学考试C++程序设计试题答案.doc

全国2008年10月自学考试C++程序设计试题答案课程代码：047373 [+ V  b& P+ M/ C
一、单项选择题(本大题共20小题，每小题1分，共20分)
1．对C++语言和C语言的兼容性，描述正确的是（
A9 L& _+ |: E% T4 L+ q( k
）! L) C: s' l! n/ Z4 i3 Q% S
A．C++兼容C
B．C++部分兼容C) a+ i& Y; o0 m3 p- d
C．C++不兼容C
D．C兼容C++
2．在C++中使用流进行输入输出，其中用于屏幕输出的对象是（$ a" o  F+ g' X# a% V9 H$ E
C; J  i# o1 @  X
）# y9 z$ ^" G0 w+ R
A．cerr& a8 }  O- d1 V% e4 v+ W0 i: ^) Z
B．cin2 b- \- b& ~/ r/ W2 I( j9 k
C．cout
D．cfile6 z, J0 d5 V% \' ]7 n  Z! K
(cerr:标准错误输出（非缓冲方式）；cin:标准输入;clog 标准错误输出（缓冲方式）)
3．对使用关键字new所开辟的动态存储空间，释放时必须使用（
C$ [  ^  V+ D7 Q( n
）
A．free
B．create
C．delete
D．realse' w5 s# B! _7 i! J, {, ?9 j
4．如没有使用private关键字定义类的数据成员，则默认为（3 a. P; I. }# [  Q3 m7 a8 ]5 T5 a
A1 n, [: Y2 w2 d" Y! b
）/ l. ^6 v% l5 k* D  _
A．private- j* B; f( p: e' a
B．public
C．protected
D．friend
5．使用值传递方式将实参传给形参，下列说法正确的是（
A5 u8 L/ d, n6 Q
）: e; q7 u2 p" V8 I' R$ |
A．形参是实参的备份" D9 {& m5 Y. F) _5 q
B．实参是形参的备份1 ^  S3 O' D; h$ m, D! ?3 N, o
C．形参和实参是同一对象* Z. {0 L- V: u6 f- u3 U, S1 B
D．形参和实参无联系
6．在函数调用时，如某一默认参数要指明一个特定值，则有（
A
）: e$ l4 d1 t  m3 y7 D/ Z0 [, S4 O
A．其之前所有参数都必须赋值4 ~: @$ P7 \" [! \
B．其之后所有参数都必须赋值
C．其前、后所有参数都必须赋值
D．其前、后所有参数都不必赋值8 K, H8 v+ K9 ^% R! y4 w- x* _
7．设存在函数int max(int，int)返回两参数中较大值，若求22，59，70三者中最大值，下列表达式不正确的是（/ q8 W4 m$ B5 Z! g
C9 q: N! Q, }: ?2 G4 \/ @
）* ?& I2 V+ ]+ M
A．int m = max(22，max(59，70))；
B．int m = max(max(22，59)，70)；
C．int m = max(22，59，70)；
D．int m = max(59，max(22，70))；
8．下列哪个类型函数不适合声明为内联函数（2 J8 X1 z6 o% a7 b; `
A
）& ^9 F; o  `7 I; q5 X8 _
A．函数体语句较多: J: W( _6 \5 O+ K) _# ^2 U
B．函数体语句较少5 ?# Q: P) C( ^
C．函数执行时间较短
D．函数执行时间过长
9．int Func(int，int)；不可与下列哪个函数构成重载（& X" j# X2 X! n7 c9 ]" X
B1 ]; ]9 \0 J! @* h7 [$ E* P
）
A．int Func(int，int，int)；       B．double Func(int，int)；
C．double Func(double，double)；; y& ?1 j# Y  v. X
D．double Func(int，double)；
说明：不能以形参名来区分函数；不能以函数返回值来区分函数。必须是形参的个数或者类型不同才能构成函数重载。
10．对类中声明的变量，下列描述中正确的是（0 s" V5 V7 }: {9 Z- \0 n& e
C+ Z- R4 [) m! i& p
）
A．属于全局变量
B．只属于该类( V2 [$ K( K. E. _9 ]3 J1 b
C．属于该类，某些情况下也可被该类不同实例所共享
D．任何情况下都可被该类所有实例共享: e( u4 N4 N1 \! c4 K: p# X, h
11．类的私有成员可在何处访问（$ n% R$ \. h) t- w- h, z
D  t. Q2 Q( ^: L# H9 i% ~3 D5 ~5 S
）
A．通过子类的对象访问% r1 L" H1 o  h- |8 d8 [
B．本类及子类的成员函数中
C．通过该类对象访问8 a5 M  Z8 w/ T- E* C. ~5 @! R
D．本类的成员函数中
12．如果没有为一个类定义任何构造函数的情况下，下列描述正确的是（
A5 j" R/ `0 y' D4 d/ K! d+ e
）: L, I7 w9 q$ ~  c* R' c; l
A．编译器总是自动创建一个不带参数的构造函数2 |" k' L5 i. O/ A2 A$ g
B．这个类没有构造函数& y6 ~/ N/ {! \8 s5 I2 m* g" g
C．这个类不需要构造函数
D．该类不能通过编译
13．一个类可包含析构函数的个数是（+ l: g3 I' y( @6 e& F9 ~2 ]
B5 R' \/ P9 c) x9 t6 O
）
A．0个
B．1个9 [! ^5 H8 {6 g4 m/ q$ D
C．至少一个/ j+ A  @7 b8 @# C0 J5 O4 w" ?, b& {4 |
D．0个或多个) `4 B1 |3 ~* v8 p  d1 D# I
14．this指针存在的目的是（- C0 ^2 t9 }1 e2 W& T
B8 X6 x. A; s- |) {4 N( r" J( ^4 ]: M
）
A．保证基类公有成员在子类中可以被访问
B．保证每个对象拥有自己的数据成员，但共享处理这些数据成员的代码/ G7 `1 T* t/ V  t
C．保证基类保护成员在子类中可以被访问4 H7 y8 x- t  \9 c& t
D．保证基类私有成员在子类中可以被访问
15．下列关于类的权限的描述错误的是（
A# K& R  Z3 f( I. l7 n  ]1 s
）9 i+ [8 y$ N6 f% w5 j# r, ?
A．类本身的成员函数只能访问自身的私有成员
B．类的对象只能访问该类的公有成员
C．普通函数不能直接访问类的公有成员，必须通过对象访问
D．一个类可以将另一个类的对象作为成员
16．在编译指令中，宏定义使用哪个指令（3 r0 P- a- G" Z$ [1 z
B
）
A．#include0 x) _- d) G0 A  ]
B．#define
C．#if
D．#else* T8 D4 |8 b4 ~9 o1 l! W7 `9 E
17．设类A将其它类对象作为成员，则建立A类对象时，下列描述正确的是（
B& y  {- g4 Y+ d+ ^2 U
）0 V( O/ ~) |! y$ \7 f! O
A．A类构造函数先执行7 d! K% ]. z- \* H+ e
B．成员构造函数先执行  [4 F0 o4 L) }/ f( }
C．两者并行执行
D．不能确定- D+ ]9 R$ ?; J6 E, x! u: O
类的组合，描述的是一个类内嵌其他类的对象作为成员的情况，它们之间的关系是一种包含与被包含的关系。/ b& L) C, P( T3 |7 l% f
在声明一个组合类的对象时，不仅它自身的构造函数将被调用，而且还将调用其内嵌对象的构造函数。这时构造函数的调用顺序是：
(1)按照内嵌对象在组合类的声明中出现的次序，依次调用内嵌对象的构造函数；. O. I6 \% ?$ }
(2)执行本类构造函数的函数体
析构函数的调用执行顺序与构造函数刚好相反。4 K# F( X1 r$ X# c# M) ~! N
18．下列描述错误的是（
A
）
A．在创建对象前，静态成员不存在2 k, G; N) I& s) e- Z; E" V
B．静态成员是类的成员
C．静态成员不能是虚函数) p7 V; s9 k7 \7 y! q, |5 p' r/ `, T
D．静态成员函数不能直接访问非静态成员
说明：静态成员函数可以直接访问该类的静态数据和函数成员，而访问非静态成员，必须通过参数传递方式得到对象名，然后通过对象名来访问。, X6 c, ]- x" C7 y9 p, y* J- ]
19．对于友元描述正确的是（
B
）
A．友元是本类的成员函数
B．友元不是本类的成员函数
C．友元不是函数' p, d+ z1 k, Z3 r* X
D．友元不能访问本类私有成员
20．在哪种派生方式中，派生类可以访问基类中的protected成员（  `# J4 C  d- @4 o( O4 W2 W7 A% @
B
）
A．public和private6 ]1 {* l+ Y& p
B．public和protected
C．protected和private! a% @. B6 p2 S) Z9 A3 Y( U
D．仅protected
二、填空题(本大题共20小题，每小题1分，共20分)
请在每小题的空格中填上正确答案。错填、不填均无分。: g* g# P  j. {7 @2 q( [' o
21．设要把一个文件输出流对象myFile与文件“f：＼myText.txt相关联，所用的C++语句是：myFile.open(“f:\\myText.txt”);。
22．C++中ostream类的直接基类是ios 类。
23．运算符[8 V2 g" W2 C3 S
]只能用 成 员 运算符来重载，不能用友元运算符来重载。1 C% x5 I6 ^9 i; K/ i- u. B. {
24．定义虚函数所用的关键字是virtual。
25．vector类中用于返回向量中第1个对象的方法是front( )。
26．在C++中，利用向量类模板定义一个具有20个char的向量E，其元素均被置为字符‘t’，实现此操作的语句是vector<char>E(20,‘t’)。
27．类的继承是指子类继承基类的数据成员和成员函数。7 D1 Q, P- a/ s. ~8 d( ~: i
28．不同对象可以调用相同名称的函数，但可导致完全不同的行为的现象称为多态性或(类的多态性)。
29．#include指令指示编译器将一个源文件嵌入到带该指令的源文件之中。
30．设类A有成员函数
void Fun(void)；- E1 v- `$ D- _
若要定义一个指向类成员函数的指针变量pafn来指向Fun，该指针变量的声明语句是：void(A::*pafn)(void);。! W6 }5 O. A5 R# w5 O: z! w
31．设在程序中使用如下语句申请了一个对象数组：
Point * ptr = new Point[2]；9 \0 I3 [- Q7 B3 ?) |
则在需要释放ptr指向的动态数组对象时，所使用的语句是delete[ ]ptr;。
32．在保护派生中，基类权限为Private的成员在派生类中 不可访问。
33．类A有如下成员函数
int A::fun(double x){return (int) x／2；}
int A::fun(int x){return x*2；}
设a为类A的对象，在主函数中有int s=a．fun(6.0)+a.fun(2)，则执行该语句后，s的值为 7 。
34．对象传送的消息一般由3部分组成：接收对象名、调用操作名和必要的参数。
35．将指向对象的指针作为函数参数，形参是对象指针，实参是对象的地址值。
36．在使用string类的find成员函数来检索主串中是否含有指定的子串时，若在主串中不含指定的子串，find函数的返回值是 -1 。
37．在C++中，声明布尔类型变量所用的关键字是
bool 。
38．执行下列代码1 y% f  p5 Z8 M- @) @6 Y
int a=29，b=100；% L: }; B1 a- g0 |6 I0 |4 \4 e5 Q
cout <<setw (3) << a << b << endl；. j; h5 L3 p" B! _7 G
程序的输出结果是：__29100 。% K2 f% g  @0 i! w) m
39．执行下列代码7 g3 B, `6 ^( P( j& R  w9 K
cout <<″Hex：″<< hex << 255；; \3 B, ?+ x8 {" H
程序的输出结果为 4 E$ O7 g% U/ E+ V2 t& @+ a; B9 J
Hex:ff 。& \3 T+ P: j; i* a1 T
40．C++语言中可以实现输出一个换行符并刷新流功能的操控符是_ endl _。
* U9 A& q& Z( [) w: U6 n1 [

三、改错题(本大题共5小题，每小题2分，共10分)- Y, D/ F0 Q6 |" |9 d+ @
下面的类定义中有一处错误，请用下横线标出错误所在行并给出修改意见。& U, M4 |3 O. i( f) v7 d: p
41．#include<iostream．h>! n8 @, F  O+ x& B: s" j: v
void
main( ) {
int x=5，y=6；% T( i- h% `/ I/ A; v
const int * p=＆x；
*p=y；: e' F) `( X: E5 J
cout<<*p<<endl；
}
0 A# \8 K+ a% C
*p=y;$ @3 ]& _9 f7 [6 }0 \9 z  x  T7 q4 H6 V! Z
指针p所指向的为一常量，不能进行左值操作
42．#include<iostream．h>
class f{
private：int x，y；( y" R- k9 p7 z' E/ G5 ~
public：f1( ){x=0；y=0；}* j. o& d7 K6 D* G0 o
print( ){cout<<x<<″<<y<<endl；}
};
void main( ){
f a；. H+ u2 W* s6 t, a. @+ K
a.f1(1,1)；
a.print( )；/ r( j6 S6 A5 O$ p; q- T! k
}/ y% J5 P- |5 H8 }7 N- D1 o
a.f1(1,1); f1( )调用时实参与形参数量不一致
43．#include<iostream.h>, k3 B8 m$ f; ~9 t0 |3 e
7 A+ V- i1 ]! A" z" H* v
class f{, ?! S. |. V4 O1 |: n/ R
6 K9 F0 Q5 d2 L0 `# B
private：int x=0，y=0；

public：void f1(int a，int b){x=a；y=b；}+ q& f9 ~1 ?0 v4 d" @8 w& K
+ a. Q; b4 }7 M# g
void get( ){cout<<x<<’<<y<<endl；}5 g1 J2 _3 ^8 D! x9 o) Q  w# o
5 M) G" J1 f: A$ l5 A: Q
}；
    void main( ){( {4 a% L$ C7 _
* v; C/ ^% n! i4 C% F% w' A  b
f a；: ~% \9 I$ p5 g, g7 t) C
7 E7 g9 O2 ^& L4 m' B) N+ f, \
a.f1(1,3)；0 x# [: d- P( T% k$ ^4 j

a.get ( )；

}
private:int x=0,y=0; 数据成员声明时不允许直接赋值/ ~5 t( O0 R+ l  a+ p
44．#include<iostream.h>2 |9 c9 l. M4 y9 l
$ [2 t4 I+ f  `$ h& D
class point{private：float x；! S& F7 K+ R* y0 x5 G) ~/ q) i

public：void f(float a){x=a;}+ _. p& m4 c! [+ B; f; t' H3 a/ M

void f( ){x=0;}

friend float max(point& a，point& b)；* H, e" i3 g$ `9 ]

}；

float max(point& a，point& b)1 f2 V$ l; c' u
{return(a.x>b.x)? a.x：b.x；}4 P+ y- ~! a# M9 p! y. T' F4 W. H
void
main( ){

point a，b；5 @2 u9 m0 L% J% W8 m4 a

a.f(2.2)；b.f(3.3)；

cout<<a.max(a,b)；
" p! x: f+ D! ~9 @) C1 a, S1 Q% G
} 
cout<<a.max(a,b); max()不是类的成员函数，不能用a.max( )方式调用2 F5 R( A0 z  X' l
45．#include<iostream.h>5 |6 }7 i. ^2 O" Y" S3 ]3 P+ r% n
+ x' x- `% V8 s1 K
template<class T>+ E: ]2 ~. u4 V: ?' l4 j
class f{
private：T x，y；! Y0 {! M6 V$ c+ _2 e
public：void f1(T a，T b){x=a；y=b；}) A9 p! k# T8 k
T max( ){retum(x>y)?x:y;}" r+ K, B+ O& x
}；7 B$ Q4 l2 w! v" T$ R
void main( ){
f a；
a.f1(1.5,3.8)；
’
cout<<a.x<<a.y<<a.max( )<<endl；
} cout<<a.x<<a.y<<a.max()<<endl; x,y是私有类型，不能在主函数中直接使用  W+ Q7 S+ C3 A) }" D& ]1 \
四、完成程序题(本大题共5小题，每小题4分，共20分)
46．完成下面类中的成员函数的定义。6 ?$ H: T  ?5 J* W. P
. t* A' j& e. f- V. ?* v: X# @
class point

{; p+ ~# N) P0 f  |

private：

int m，n；) O% W3 q; P3 x  H& e+ w9 @. A
( ~1 o  }" K% c
public： 

point(int，int)；% K5 O0 w, n+ d- V8 o7 Q4 p' h
: P) ^+ x6 _* T" z( @( G
point(point&)；
' r! u8 {( L5 ]0 f
}；! _4 s/ g' q$ r  i5 X. V
5 ~. M2 i0 p# G" @4 W0 e
point::point(int a，int b). T  Z7 B" U, l: R

{8 `5 ~2 z2 F+ ]. k# ~" w
0 A2 Y9 N  D- k( n
m=a；
_ n _=b；" T5 \+ W3 ~- o% y6 k' A2 ?
}

point::point(_point&t _)' @3 q% x; b2 W9 y

{
1 s- @5 K- q7 v+ C
m=t.m；  r7 S& }8 A4 U- w0 \
/ Z6 B/ B5 o+ I& z: O' k# v. t
n=t.n；
: y% Z1 K# d; X% Z' ], I) |
}. H8 Z7 l7 z2 f4 N$ i% R
47．下面是一个输入半径，输出其面积和周长的C++程序，在下划线处填上正确的语句。* d* [; K' O/ K4 I7 Q8 h' e: V
2 @' i/ b, u3 L0 I* V
#include<iostream>; B4 Z! M6 J0 a' ~
' J+ j2 l; ^- n! p. w9 y! L* z  I
using namespace std；
    const double pi=3.14159；
) S3 v+ U6 x, S3 e$ R9 F
void main( )
8 P/ t% c7 H  [6 Q
{
' G) M7 r, x6 F" E' z& \- P
double r；9 r4 g4 g# X; ^! }4 i# a6 x3 W2 H0 p

cout<<″r=″；
    cin>>r
;
$ @4 H2 w5 @1 ]/ o
double l=2.0*pi*r；+ _# b+ `5 \; C
double s=pi*r*r；
cout<<″＼n The long is：″<<l<<endl；

cout<<″The area is：″<<s<<endl；6 k% y6 k: w2 h$ O! j
+ d5 }( j6 S, u3 N% ]
}+ W/ g1 R3 V9 L: B
48．在下划线处填上缺少的部分。

#include<iostream>
6 I' P( ]/ n* i  Y% }
#include<fstream>

using namespace std；

class complex- @  A) D9 k* V1 ?

{
0 u* w2 Z' \& i* S# ^4 d' {- \- V8 Y
public： * q& Q3 E6 b" B* p
  {: J  n5 w, ~4 _
int real；

int imag；

complex(int r=0，int i=0) 
0 V. {9 ?8 v7 D* o
{5 i+ Q& E" d* t

real=r；" x4 k: E: a  e. n, ]. x3 Z
" c% a9 n0 o  O9 _0 X* [
imag=i；$ `7 [: V+ I0 B# E* s
. R/ A+ i; p% n1 z$ o/ T
}
$ g2 R- a; ?, @( `3 I2 ?% `% r
}；; E, @' B& V4 A, \. `- C9 T& H
% U2 \+ D) C5 G4 L$ B' I
complex operator+(% i$ z. S$ E' |$ _, H1 E
complex&a，complex& b)# `, g; U# C3 t6 ?9 r

{" N1 Q+ Y- a! Z; c5 g7 r' Y& ?
# N. h5 j3 H! U+ \' z
int r=a.real+b.real；

int i=a.imag+b.imag；
; B, i+ j3 V  o) D8 f
return
complex(r,i)；8 d, g0 W; v5 }
4 Z1 R6 V' m7 {' r) p9 w

}3 G% o) }, M% F. }9 n; |" t

void main( )  K9 u  N; k/ ]# R2 S3 I

{' C! m: e& ]" l! O& u

complex x(1，2)，y(3，4)，z；
6 z& j0 P' {4 K
z=x+y；2 R9 h4 A, z+ u% p9 s) |
/ y/ e& V* X6 {! u& D" }
cout<<z.real<<″+″<<z.imag<<″i″<<endl；
! k2 U( @1 O! s; s+ O7 P
}+ p! g9 |( f" S7 i0 |3 N
49．程序的输出结果如下：
; y; m; h% F! i1 P1 B
1，9! R* }. w% i8 {, n+ l
0 C# i8 n0 m# K! K( x
50，30
  请根据输出数据在下面程序中的下划线处填写正确的语句。3 y: M$ @* U2 a
  源程序如下：! _2 ], B/ c4 B3 y
: S5 B7 S5 d! v1 x3 I: B
#include<iostream>

using namespace std；
6 b& F( b3 Y7 N, \4 C
class base
3 d; C4 |( S; d/ |
{

private：

int m；% v# L& n8 y) c* u* X) m, {) A

public：
5 d0 q. R* \; L2 H$ @
base( ){ }；
. O0 t8 r& i% ?& ?
base(int a):m(a){}. \# i% N' t, g( i5 e

int get( ){return m;}7 ]( s, g! B$ R2 t8 W

void set(int a){m=a;}

}；$ j! f% s5 B- m
. z# k/ D! c1 }6 U; U/ Z; f
void main()
7 |* b/ r: e  a) C/ M( N' k3 X! Q  _
{) Q4 L: B- D; A) R% r: r* F

base*ptr=new base[2]；
# V2 c+ f5 {3 q
ptr- >set(30)；$ C! J6 E; Y. H  c9 w' B2 d

ptr= ptr+1;;
$ }* |( L) W2 q
ptr- >set(50)；
$ x4 J" y9 U( l  r$ H: J$ I- R4 y
base a[2]={1，9}；. Y6 w( t, H5 ^7 w6 I# S, X

cout<<a[0].get( )<<″，″<<a[1].get( )<<endl；) J# H7 I9 h# T+ l* R1 ]( B

cout<<ptr- >get( )<<″，″；3 @# v, }' V: \
) G% e% E5 [; ~8 ^1 G( L% P, A+ T
ptr=ptr-1；) ~# z# c* s/ o- w9 A( W
, T4 p/ A, d; P2 L$ d, a$ |
cout<< ptr->get( )<<endl；
3 s7 \* A4 g) S: T- y* e) ^
delete[ ]ptr；/ G7 c% |0 f( ^2 N' i8 w

}
50．在下面横线处填上求两个浮点数之差的cha函数的原型声明、调用方法。
% n$ M8 D; L3 z. B- g! t
#include <iostream>
5 X  g7 X4 p" e; z5 o
using namespace std；
: a, R5 P; P8 e
void main( )0 i1 e# h9 M, c5 [) x1 ?% |

{9 O) U& D# U% k3 b% z

float a，b；

float cha(float,float);／／函数cha的原型声明

a=12.5；
( k! f4 s7 m- ~0 Y* V( W: h4 y1 |4 ?
b=6.5；
* e) b5 m& `4 c' G# `' R6 ~+ p
float c= cha(a,b)；    ／／调用函数cha
2 o' U; W9 j. @
cout<<c<<endl；

}, |  p' X, T4 k/ v# A2 {
) l, o5 o* v* }* R5 F5 _8 U, q
float cha(float x，float y)
# m8 M) U3 B: c! ~3 j- {+ s2 v0 f
{

float w； 7 J8 K0 A9 O2 a8 Q( s; I

w=x-y；

return w；1 b" O' g: y, t6 n+ t; H

}
五、程序分析题(本大题共4小题，每小题5分，共20分)& V1 |  x1 \4 j  @3 s9 w- X" F
51．给出下面程序的输出结果。
8 U, ~0 k  a7 q) D1 w; N2 b( r* V
#include <iostream．h>: ?0 d7 O9 u$ E3 F! M$ ]3 @

template <class T>

class Sample
) l; u4 ~) |% k6 i* u- |
{1 i0 `$ H/ c- F: Z

T n；- w9 M/ n) V, t; P; C: ?6 p

public：! L& w9 r% ]8 ^! A

Sample(T i){n=i;}$ S* d( X# J& ^4 _2 u) A) B$ r1 [
6 y1 E$ t8 d5 V; _* z1 k
int operator==(Sample &)；) x8 `' k0 ?- h3 @5 _
. k# l+ d1 M! U# j
}；
0 c$ b7 M4 M9 B; Q9 u2 A" w, X2 {
template <class T>$ i6 ]0 C# W& }% y* c% z# J
! O) E" y1 d. p6 u
int Sample<T>:perator==(Sample＆s)

{, C# }+ T; p! F; F5 D, W) k7 [% ?: A
! Q7 k+ L6 Z7 x' E: h
if(n==s.n)7 k1 E. @* j; L7 \9 w# T
/ q/ t9 ]' F# h8 w
return 1；

else

return 0；) n" e" ^( K* y% C- n5 f7 ~

}/ ?9 u; B. h+ W9 b

void main( )/ Q1 V7 f- R) Q! f9 X8 l
8 a5 K9 L$ H3 k' g
{0 k' Q4 I* r1 H/ R* [7 i* t0 a8 k
4 `# D0 u- W4 K& t- Z4 [( ~" p
Sample<int>sl(2)，s2(3)；    ．7 Y: v& n- M* M4 L: Y7 ?8 J& i$ R6 L

cout<<″s1与s2的数据成员″<<(sl==s2 ?″相等″：″不相等″)<<endl；
7 E( g. v) t5 h. A7 s1 F$ a* {
Sample<double>s3(2.5)，s4(2.5)；0 f" w8 W% m5 l* ]) r' ~6 h

cout<<″s3与s4的数据成员″<<(s3==s4 ? ″相等″：″不相等″)<<endl；. ?8 B. \+ B, ~& k5 N3 y% s

}

S1与S2的数据成员不相等 
  O- P3 Q* }0 C+ o
S3与S4数据成员相等 2 e+ K8 U5 V3 g% X+ d. ]
52．给出下面程序的输出结果。
; {9 l' N# m! a) r$ }
#include<iostream>; P, w4 P% Y- `* p
3 ?8 V& j4 q' n3 S2 ^- f( ^
using namespace std；
- @8 [' o  m) A3 w
template<class T>0 }8 q* A% R1 G  y' e

T max(T ml，T m2)3 E& A% o9 n* I2 B

{return(m1>m2)?ml:m2:}. V- t6 \+ }, _( M- R8 M' Z

void main( )
{

cout<<max(1，7)<< ″\t″<<max(2.0，5.0)<<endl；

cout<<max(′y′,′b′<<″＼t″<<max(″A″，″a″)<<endl；* k$ R- S% Z$ A/ {- L+ e% P* v) B

}9 K, q. }8 e" u" D
2 a1 H0 C, \, J' w! T
7   n3 y4 b* E$ H  @; t5 K
5
y 
a
53．给出下面程序的输出结果
: K3 C( I8 ?* Y. A
#include <iostream>3 ?9 r9 w% \* w: n, D' _
  G9 [  P8 p& G; P% x
using namespace std；

class A) ~9 F8 _, N( V6 j7 M1 t0 F
{4 P# g  H3 e- T" t) @
4 |, X2 e9 V1 c+ z# Y5 [
public：- Y( v8 s' V9 t& B
6 T$ {$ ]! q% K
int x；
$ E' D) N- ?4 e7 ]1 ~
A( ) { }3 c" V% c& M* D1 d) J! n+ b
) B/ T$ a- Q& c8 O/ M0 S
A(int a){x=a;}7 l' S' `& L; U" X+ u6 W2 J

int get(int a){return x+a;}9 U8 r0 e+ r/ P' m$ I1 I) b
}；
& z5 i9 z+ N3 ?5 l& n- A
void main( )
{
' i; l" q! a3 [
A a(8)；

int(A::*p)(int)；
6 [. o2 @- g: d5 A* G
p=A::get；1 S" Q$ t. `5 A, V2 W: Q/ R- t

cout<<(a.*p)(5)<<endl；
" @( G& i, X* H' A* u; c
A*pi=＆a；4 T7 @: {- K# F9 B* e

cout<<(pi- >*P)(7)<<endl；}
13
15

  _& x0 c  d4 e8 m! F
54．给出下面程序的输出结果。

include<iostream>9 b' D, w2 n. m/ h' s( U) k! V. H
3 @/ ]3 o+ `9 w( n* E  b
#include<string>1 w/