09计科(1)(2)《面向对象程序设计》C 综合练习(学生版 - ) - - - 含答案- 副本

C++面向对象 程序设计习题册

姓名 学号 学院 班级

第三章 类和对象

一、选择题

1. 在一个类的定义中，包含有（ C ）成员的定义。

A. 数据 B. 函数 C. 数据和函数 D. 数据或函数

2. 在类作用域中能够通过直接使用该类的（ D ）成员名进行访问。 A. 私有 B. 公用 C. 保护 D. 任何

3. 假定AA为一个类，a为该类公有的数据成员，x为该类的一个对象，则访问x对象中数据成员a的格式为（ D ）。

A. x(a) B. x[a] C. x->a D. x.a

4. 假定AA为一个类，a()为该类公有的函数成员，x为该类的一个对象，则访问x对象中函数成员a()的格式为（ B ）。

A. x.a B. x.a() C. x->a D. x->a()

5. 假定AA为一个类，a为该类公有的数据成员，px为指向该类对象的一个指针，则访问px所指对象中数据成员a的格式为（C ）。

A. px(a) B. px[a] C. px->a D. px.a

6. 假定AA为一个类，a为该类私有的数据成员，GetValue()为该类公有函数成员，它返回a的值，x为该类的一个对象，则访问x对象中数据成员a的格式为（ D）。 A. x.a B. x.a() C. x->GetValue() D. x.GetValue() 7. 假定AA为一个类，int a()为该类的一个成员函数，若该成员函数在类定义体外定义，则函数头为（A ）。 A. int AA::a() B. int AA:a() C. AA::a() D. AA::int a() 8. 假定AA为一个类，a为该类公有的数据成员，若要在该类的一个成员函数中访问它，则书写格式为（A ）。 A. a B. AA::a C. a() D. AA::a()

9. 若需要把一个类外定义的成员函数指明为内联函数，则必须把关键字（ B ）放在函数原型或函数头的前面。

A. in B. inline C. inLine D. InLiner

10. 在多文件结构的程序中，通常把类的定义单独存放于（ D ）中。 A. 主文件 B. 实现文件 C. 库文件 D. 头文件

11. 在多文件结构的程序中，通常把类中所有非内联函数的定义单独存放于（ B）中。 A. 主文件 B. 实现文件 C. 库文件 D. 头文件

12. 在多文件结构的程序中，通常把含有main()函数的文件称为（A ）。 A. 主文件 B. 实现文件 C. 程序文件 D. 头文件

13. 在C++程序中使用的cin标识符是系统类库中定义的（ A ）类中的一个对象。 A. istream B. ostream C. iostream D. fstream

14. 在C++程序中使用的cout标识符是系统类库中定义的（ B ）类中的一个对象。

A. istream B. ostream C. iostream D. fstream

15. 假定AA是一个类，abc是该类的一个成员函数，则参数表中隐含的第一个参数的类型为（ D ）。 A. int B. char C. AA D. AA*

16. 假定AA是一个类，abc是该类的一个成员函数，则参数表中隐含的第一个参数为（ C）。 A. abc B. *this C. this D. this&

17. 假定AA是一个类，“AA& abc();”是该类中一个成员函数的原型，若该函数存在对*this赋值的语句，当用x.abc()调用该成员函数后，x的值（A ）。 A. 已经被改变 B. 可能被改变

C. 不变 D.不受函数调用的影响

1

18. 假定AA是一个类，“AA* abc()const;”是该类中一个成员函数的原型，若该函数返回this值，当用x.abc()调用该成员函数后，x的值（ C ）。 A. 已经被改变 B. 可能被改变 C. 不变 D. 受到函数调用的影响 19. 类中定义的成员默认为（ B ）访问属性。 A. public B. private C. protected D. friend 20. 结构中定义的成员默认为（ A）访问属性。

A. public B. private C. protected D. friend

21. 当类中一个字符指针成员指向具有n个字节的存储空间时，它所能存储字符串的最大长度为( C )。 A. n B. n+1 C. n-1 D. n-2

22. 对于一个类的构造函数，其函数名与类名( A )。

A. 完全相同 B. 基本相同 C. 不相同 D. 无关系 23. 对于一个类的析构函数，其函数名与类名( C )。

A. 完全相同 B. 完全不同 C. 只相差一个字符 D. 无关系 24. 类的构造函数是在定义该类的一个( C)时被自动调用执行的。 A. 成员函数 B. 数据成员 C. 对象 D. 友元函数 25. 类的析构函数是一个对象被( B)时自动调用的。 A. 建立 B. 撤消 C. 赋值 D. 引用 26. 一个类的构造函数通常被定义为该类的( A )成员。 A. 公用 B. 保护 C. 私有 D. 友元

27. 一个类的析构函数通常被定义为该类的( C )成员。 A. 私有 B. 保护 C. 公用 D. 友元

28. 假定AB为一个类，则执行 “AB x;”语句时将自动调用该类的( B )。 A. 带参构造函数 B. 无参构造函数 C. 拷贝构造函数 D. 赋值重载函数

29. 假定AB为一个类，则执行 “AB x(a,5);”语句时将自动调用该类的( A )。 A. 带参构造函数 B. 无参构造函数 C. 拷贝构造函数 D. 赋值重载函数

30. 假定AB为一个类，则执行 “AB *s=new AB(a,5);”语句时得到的一个动态对象为____D___。 A. s B. s->a C. s.a D. *s

31. 假定AB为一个类，则执行 “AB r1=r2;”语句时将自动调用该类的( D )。 A. 无参构造函数 B. 带参构造函数 C. 赋值重载函数 D. 拷贝构造函数

32. 若需要使类中的一个指针成员指向一块动态存储空间，则通常在( B )函数中完成。 A. 析构 B. 构造 C. 任一成员 D. 友元

33. 当类中的一个整型指针成员指向一块具有n*sizeof(int)大小的存储空间时，它最多能够存储( A )个整数。

A. n B. n+1 C. n-1 D. 1

34. 假定一个类的构造函数为 “A(int aa, int bb) {a=aa; b=aa*bb;}”，则执行 “A x(4,5);”语句后，x.a和x.b的值分别为( C )。

A. 4和5 B. 5和4 C. 4和20 D. 20和5

35. 假定一个类的构造函数为 “A(int aa=1, int bb=0) {a=aa; b=bb;}”，则执行 “A x(4);”语句后，x.a和x.b的值分别为( D )。

A. 1和0 B. 1和4 C. 4和1 D. 4和0

36. 假定AB为一个类，则( B )为该类的拷贝构造函数的原型说明。

A. AB(AB x); B. AB(AB& x); C. void AB(AB& x); D. AB(int x);

37. 假定一个类的构造函数为 “B(int ax, int bx): a(ax), b(bx) {}”，执行 “B x(1,2),y(3,4);x=y;”语句序列后x.a的值为( C )。

A. 1 B. 2 C. 3 D. 4

2

38. 假定一个类AB只含有一个整型数据成员a，当用户不定义任何构造函数时，系统为该类定义的无参构造函数为( D )。

A. AB() {a=0;} B. AB(int aa=0): a(aa) {}

C. AB(int aa): a(aa) {} D. AB() {}

39. 假定一个类AB只含有一个整型数据成员a，用户为该类定义的带参构造函数可以为( C )。 A. AB() {} B. AB(): a(0){}

C. AB(int aa=0) {a=aa;} D. AB(int aa) {}

40. 对于任一个类，用户所能定义的构造函数的个数至多为( D )。 A. 0 B. 1 C. 2 D. 任意个

41. 对于任一个类，用户所能定义的析构函数的个数至多为( B )。 A. 0 B. 1 C. 2 D. 任意个

42. 假定AB为一个类，则执行 “AB *px=new AB[n];”语句时将( A )。 A. 动态分配一个数组 B. 动态分配一个对象

C. 静态分配一个数组 D. 静态分配一个对象

43. 设px是指向一个类对象的指针变量，则执行 “delete px;”语句时，将自动调用该类的( C )。 A. 无参构造函数 B. 带参构造函数 C. 析构函数 D. 拷贝构造函数 44. 当一个类对象离开它的作用域时，系统自动调用该类的( D )。 A. 无参构造函数 B. 带参构造函数 C. 拷贝构造函数 D. 析构函数

45. 假定一个类对象数组为A[n]，当离开它定义的作用域时，系统自动调用该类析构函数的次数为( C )。 A. 0 B. 1 C. n D. n-1

46. 假定AB为一个类，则执行 “AB a[10];”语句时调用该类无参构造函数的次数为( D )。

A. 0 B. 1 C. 9 D. 10

47. 假定AB为一个类，则执行 “AB *px=new AB[n];”语句时调用该类无参构造函数的次数为( A )。 A. n B. n-1 C. 1 D. 0

48. 假定AB为一个类，则执行 “AB a, b(3), *p;”语句时共调用该类构造函数的次数为( A )。 A. 2 B. 3 C. 4 D. 5

49. 假定AB为一个类，则执行 “AB a(2), b[3], *p[4];”语句时共调用该类构造函数的次数为(B )。 A. 3 B. 4 C. 5 D. 9 50. 假定AB为一个类，则执行“AB a, b(2), c[3], *p=&a;”语句时共调用该类无参构造函数的次数为( D )。 A. 5 B. 6 C. 3 D. 4

51. 假定AB为一个类，则执行“AB *p=new AB(1,2);”语句时共调用该类构造函数的次数为( B )。 A. 0 B. 1 C. 2 D. 3

52. 假定AB为一个类，px为指向该类的一个含有n个对象的动态数组的指针，则执行“delete []px;”语句时共调用该类析构函数的次数为( C )。 A. 0 B. 1 C. n D. n+1

53. 对类对象成员的初始化是通过构造函数中给出的( D )实现的。 A. 函数体 B. 初始化表 C. 参数表 D. 初始化表或函数体 54. 对类中常量成员的初始化是通过构造函数中给出的( C )实现的。 A. 函数体 B. 参数表 C. 初始化表 D. 初始化表或函数体 55. 对类中引用成员的初始化是通过构造函数中给出的( C )实现的。 A. 函数体 B. 参数表 C. 初始化表 D. 初始化表或函数体 56. 一个类的静态数据成员所表示属性 ( C )。 A. 是类的或对象的属性 B. 只是对象的属性 C. 只是类的属性 D. 类和友元的属性

3

57. 类的静态成员的访问控制（ D ）。 A. 只允许被定义为private

B. 只允许被定义为private或protected C. 只允许被定义为public

D. 可允许被定义为private、protected或public 58. 静态成员函数对类的数据成员访问（ B ）。

A. 是不允许的 B. 只允许是静态数据成员

C. 只允许是非静态数据成员 D. 可允许是静态数据成员或非静态数据成员 59. 被非静态成员函数访问的类的数据成员( A )。

A. 可以是非静态数据成员或静态数据成员 B. 不可能是类的静态数据成员 C. 只能是类的非静态数据成员 D. 只能是类的静态数据成员 60. 静态数据成员的初始化是在（ D ）中进行的。 A. 构造函数 B. 任何成员函数

C. 所属类 D. 全局区

61. 当将一个类A或函数f()说明为另一个类B的友元后，类A或函数f()能够直接访问类B的（ D ）。 A. 只能是公有成员 B. 只能是保护成员

C. 只能是除私有成员之外的任何成员 D. 具有任何权限的成员 62. 引入友元的主要目的是为了（ C ）。

A. 增强数据安全性 B. 提高程序的可靠性 C. 提高程序的效率和灵活性 D. 保证类的封装性

63. 一个类的成员函数也可以成为另一个类的友元函数，这时的友元说明（ A ）。 A. 需加上类域的限定 B. 不需加上类域的限定

C. 类域的限定可加可不加 D. 不需要任何限定

64. 一个类的友元不是该类的成员，与该类的关系密切，所以它（ D ）。

A. 有this指针，有默认操作的对象

B. 没有this指针，可以有默认操作的对象 C. 有this指针，不能执行默认操作

D. 没有this指针，也就没有默认操作的对象

二、程序填充题

1. 已知一个类的定义如下： #include class AA {

int a[10]; int n;

public: void SetA(int aa[], int nn); //用数组aa初始化数据成员a，用nn初始化数据成员n

int MaxA(); //从数组a中前n个元素中查找最大值

void SortA(); //采用选择排序的方法对数组a中前n个元素，进行从小到大排序

void InsertA();//采用插入排序的方法对数组a中前n个元素进行从小到大排序 void PrintA(); //依次输出数组a中的前n个元素 };

4

for(int i=0; i

~A() {delete []a;} int GetValue(int i) ___(2)_return a[i];__ //函数体返回a[i]的值 };

void main() {

int b[10]={1,2,3,4,5,6,7,8,9,10};

A r(b,10,10); int i,s=0;

for(i=0; i<10; i++)___(3) s+=r.GetValue(i);___ //把r对象的a数据成员中的每个 //元素值依次累加到s中 cout<<\ }

13. #include #include class A {

int *a; int n; int MaxLen; public:

A(): a(0), n(0), MaxLen(0) {} A(int *aa, int nn, int MM) { n=nn;

MaxLen=MM;

if(n>MaxLen) exit(1); a=new int[MaxLen];

___(1)for(int i=0;i

___(2)AA::~A( ) {delete [ ]a;}___ //析构函数的类外定义

void main() {

int b[10]={1,2,3,4,5,6,7,8,9,10}; A r(b,10,10);

int i,s=0;

___(3) for(i=0; i<10; i++) s+=r.GetValue(i);___ ; //以i为循环变量，把r对象的a数据成员中的 //每个元素值依次累加到s中 cout<<\ }

10

14. 一种类定义如下: class Goods {

private:

char gd_name[20]; //商品名称 int weight; //商品重量 static int totalweight; //同类商品总重量 public:

Goods (char*str,int w){ //构造函数 strcpy(gd_name,str); weight=w;

totalweight+=weight; }

~ Goods (){totalweight -= weight;}

char* GetN(){___(1) return gd_name ___;} //返回商品名称

int GetW(){return weight;}

___(2)_static int __ GetTotal_Weight() { //定义静态成员函数返回总重量 ___(3)_ return totalweight __; }

}

三、写出下列程序的运行结果 1. #include #include class CD {

char* a; int b; public: void Init(char* aa, int bb) {

a=new char[strlen(aa)+1];

strcpy(a,aa); b=bb; }

char* Geta() {return a;}

int Getb() {return b;}

void Output() {cout<

dx.Init(\

dy.Init(\ dx.Output(); dy.Output();

}

11

2．#include #include class CD {

char* a;

int b; public: void Init(char* aa, int bb) { a=new char[strlen(aa)+1];

strcpy(a,aa);

b=bb; }

char* Geta() {return a;}

int Getb() {return b;} void Output() {cout<

char a[20];

dx.Init(\ strcpy(a,dx.Geta()); strcat(a,\

dy.Init(a,dx.Getb()+20); dx.Output(); dy.Output();

}

3. #include class CE { private: int a,b;

int getmax() {return (a>b? a:b);} public: int c; 第3题运行结果：

void SetValue(int x1,int x2, int x3) {

a=x1; b=x2; c=x3;

}

int GetMax(); }; int CE::GetMax() { int d=getmax(); return (d>c? d:c);

}

12

void main() { int x=5,y=12,z=8; CE ex, *ep=&ex;

ex.SetValue(x,y,z);

cout<SetValue(x+y,y-z,20); cout<GetMax()<

}

4. #include class CE { private: int a,b;

int getmin() {return (a

void SetValue(int x1,int x2, int x3)

{

a=x1; b=x2; c=x3; 第4题运行结果：

}

int GetMin();

};

int CE::GetMin() { int d=getmin(); return (d

void main() { int x=5,y=12,z=8; CE *ep; ep=new CE; ep->SetValue(x+y,y-z,10); cout<GetMin()<

cout<

}

5. #include

class Franction { //定义分数类 int nume; //定义分子

int deno; //定义分母

public:

//把*this化简为最简分数，具体定义在另外文件中实现 void FranSimp();

//返回两个分数*this和x之和，具体定义在另外文件中实现

13

Franction FranAdd(const Franction& x); //置分数的分子和分母分别0和1 void InitFranction() {nume=0; deno=1;} //置分数的分子和分母分别n和d void InitFranction(int n, int d) {nume=n; deno=d;}

//输出一个分数

void FranOutput() {cout<

void main()

{ Franction a,b,c,d; a.InitFranction(7,12); b.InitFranction(-3,8); c.InitFranction(); c=a.FranAdd(b); d=c.FranAdd(a);

cout<<\

cout<<\

cout<<\ cout<<\ }

第5题答案： a:7/12 b:-3/8 c:5/24

d:19/24

6. #include

class Franction { //定义分数类 int nume; //定义分子

int deno; //定义分母

public:

//把*this化简为最简分数，具体定义在另外文件中实现 void FranSimp();

//返回两个分数*this和x之和，具体定义在另外文件中实现 Franction FranAdd(const Franction& x); //置分数的分子和分母分别0和1 void InitFranction() {nume=0; deno=1;} //置分数的分子和分母分别n和d void InitFranction(int n, int d) {nume=n; deno=d;}

//输出一个分数 void FranOutput() {cout<

14

void main() { Franction a,b,c,d;

a.InitFranction(6,15); b.InitFranction(3,10); c.InitFranction(); c=a.FranAdd(b);

d=c.FranAdd(a); 第6题答案：

cout<<\ a:6/15

cout<<\ cout<<\

cout<<\

}

7.

#include #include class A { char *a; public:

A(char *s) {

a=new char[strlen(s)+1]; strcpy(a,s); cout<

~A() {

delete []a;

cout<<\ }

};

void main() {

A x(\ A *y=new A(\ delete y; }

8.

#include class A { int *a; public:

A(int x=0):a(new int(x)){} ~A() {delete a;} int getA() {return *a;} void setA(int x) {*a=x;}

b:3/10 c:7/10

d:11/10

第7题运行结果：

15

};

void main() {

A x1,x2(3); 第8题运行结果：

A *p=&x2;

p->setA(x2.getA()+5); x1.setA(15+x1.getA()); cout<

#include class A { int a;

public:

A(int aa=0): a(aa) {cout<

void main() { 第9题运行结果：

A *p; A x[3]={1,2,3},y=4; cout<

p=new A[3]; cout<

cout<

10. #include class A { int a,b;

public:

A() {a=b=0;}

A(int aa, int bb) {a=aa; b=bb;} int Sum() {return a+b;} 第10题运行结果：

int* Mult() { int *p=new int(a*b);

return p;

} };

void main() { int *k; A x(2,3), *p;

p=new A(4,5);

cout<

cout<Sum()<<' '<<*(k=p->Mult())<

16

11.

#include class A {

int a[10]; int n;

public:

A(int aa[], int nn): n(nn) {

for(int i=0; i

int Get(int i) {return a[i];} 第11题运行结果：

int SumA(int n) { int s=0;

for(int j=0; j

return s;

} };

void main() {

int a[]={2,5,8,10,15,20}; A x(a,4); A y(a,6);

int d=1; for(int i=0; i<4; i++) d*=x.Get(i); int f=y.SumA(5); cout<<\

cout<<\

} 12.

#include class A { int a,b;

public:

A(int aa, int bb) {a=aa; b=bb;} float Multip(char op) { switch(op) {

case '+': return a+b; case '-': return a-b; case '*': return a*b;

case '/': if(b!=0)return float(a)/b; else {cout<<\除数为0!\

default: cout<<'\\n'<

return 0;

} } };

17

void main() { A x(10,4);

char a[6]=\ int i=0;

第12题运行结果：

while(a[i]) { float k=x.Multip(a[i]); if(k!=0) cout<

cout<

四、程序设计题

1. 根据下面类中Count函数成员的原型和注释写出它的类外定义。 class AA { int* a;

int n;

int MS; public: void InitAA(int aa[], int nn, int ms) { if(nn>ms) {cout<<\ MS=ms; n=nn;

a=new int[MS];

for(int i=0; i

int Count(int x); //从数组a的前n个元素中统计出其值等于x的个数并返回。};

第1题答案： int AA::Count(int x) {

int i,c=0;

for(i=0; i

18

2. 根据下面类中Search函数成员的原型和注释写出它的类外定义。 class AA { int* a;

int n;

int MS; public: void InitAA(int aa[], int nn, int ms) { if(nn>ms) {cout<<\ MS=ms; n=nn;

a=new int[MS];

for(int i=0; i

}

int Search(int x); //从数组a的前n个元素中顺序查找值为x的元素， //若查找成功则返回元素的下标，否则返回-1。};

第2题答案： int AA::Search(int x) {

int i;

for(i=0; i

return -1; }

3. 根据下面类中MaxMin 函数成员的原型和注释写出它的类外定义。 class AA { int* a; int n; int MS; public: void InitAA(int aa[], int nn, int ms) { if(nn>ms) {cout<<\ MS=ms; n=nn;

a=new int[MS];

for(int i=0; i

int MaxMin(int& x, int& y); //从数组a的前n个元素中求出 //最大值和最小值，并分别由引用参数x和y带回， //同时若n大于0则返回1，否则返回0。 };

第3题答案：

int AA::MaxMin(int x, int y) {

int mx,my; mx=my=a[0];

19

Strings(Strings& str); //拷贝构造函数

Strings& Give(Strings& str); //实现str赋值给*this的功能 Strings Uion(Strings& str); //实现*this和str中的字符串合并的

//功能，把合并结果存入临时对象并返回 int Lenth() {return n;} //返回字符串长度

void Print() {cout<

};

第12题答案：

Strings::Strings(char*str) { n=strlen(str); s=new char[n+1]; strcpy(s,str);

}

13. 根据下面类中拷贝构造函数的原型写出它的类外定义。 class Strings { char *s; //指向动态分配的字符串数组空间 int n; //记录字符串长度

public: Strings(char*str); //构造函数，利用str字符串长度初始化n， //利用str字符串初始化s所指的字符串空间 Strings(Strings& str); //拷贝构造函数

Strings& Give(Strings& str); //实现str赋值给*this的功能

Strings Uion(Strings& str); //实现*this和str中的字符串合并的 //功能，把合并结果存入临时对象并返回 int Lenth() {return n;} //返回字符串长度

void Print() {cout<

};

第13题答案：

Strings::Strings(Strings str) { n=str.n;

s=new char[n+1]; strcpy(s,str.s); }

14. 根据下面类中Give函数的原型和注释写出它的类外定义。 class Strings { char *s; //指向动态分配的字符串数组空间 int n; //记录字符串长度

public: Strings(char*str); //构造函数，利用str字符串长度初始化n， //利用str字符串初始化s所指的字符串空间 Strings(Strings& str); //拷贝构造函数

Strings& Give(Strings& str); //实现str赋值给*this的功能并返回*this

Strings Uion(Strings& str); //实现*this和str中的字符串合并的 //功能，把合并结果存入临时对象并返回 int Lenth() {return n;} //返回字符串长度

void Print() {cout<

25

};

第14题答案：

Strings Strings::Give(Strings str) { delete []s; n=str.n;

s=new char[n+1]; strcpy(s,str.s); return *this;

}

15. 根据下面类中Uion函数的原型和注释写出它的类外定义。 class Strings { char *s; //指向动态分配的字符串数组空间

int n; //记录字符串长度

public: Strings(char*str); //构造函数，利用str字符串长度初始化n，

//利用str字符串初始化s所指的字符串空间 Strings(Strings& str); //拷贝构造函数

Strings& Give(Strings& str); //实现str赋值给*this的功能并返回*this

Strings Uion(Strings& str); //实现*this和str中的字符串连接的功能， //把连接结果存入临时对象并返回

int Lenth() {return n;} //返回字符串长度 void Print() {cout<

};

第15题答案：

Strings Strings::Uion(Strings str) { Strings r(\r.n=n+str.n;

r.s=new char[r.n+1]; strcpy(r.s,s); strcat(r.s,str.s);

return r; }

16. 下列程序段中，A_class的成员函数Variance()可求出两数的平方差，请改写该程序段，把Variance()函数从A_class类中分离出来，用友元函数来实现该函数的功能。 class A_class { private: int x,y,t; public:

A_class(int i,int j):x(i),y(j) { if(y>x){t=x;x=y;y=t;} }

int Variance(){return x*x-y*y;} //其它函数从略 };

void main() {

26

A_class A_obj(3,5);

cout<<\ariance()<

第16题答案： class A_class { private: int x,y,t; public:

A_class(int i,int j):x(i),y(j){ if(y>x){t=x;x=y;y=t;}; }

//其它函数从略

friend int Variance (A_class ac); //参数名任意 }; int Variance (A_class ac) {

return ac.x*ac.x-ac.y*ac.y; }

void main() {

A_class A_obj(3,5);

cout<<\ariance(A_obj)<

17. 下面给出了矩阵类Matrix定义。为了求两个矩阵对象的乘积，需要定义一个Matrix的友元函数Multiply()。请按照友元函数Multiply（）的声明编写出该函数的定义。 class Matrix { public: Matrix(int row,int col); //构造一个具有row行col列的矩阵 ~Matrix() {delete []mem;} //析构函数

friend bool Multiply(Matrix &m1, Matrix &m2, Matrix &m3);

//定义Multiply()为友元函数，该函数把m1×m2的值赋给m3 //其他成员函数从略 private: int *mem; };

Matrix::Matrix(int row,int col):rows(row),cols(col) {

mem = new int[row*col]; }

bool Multiply(Matrix &m1, Matrix &m2, Matrix &m3) {

//确定矩阵是否能够进行相乘

if(m1.rows != m3.rows ||m2.cols != m3.cols || m1.cols != m2.rows) return false; //定义sum变量，用于计算乘积矩阵m3中每个元素的值

27

//动态申请矩阵空间

const int rows,cols; //矩阵的行数和列数

int sum;

//请在下面编写剩余部分 for(int i=0; i

sum=0;

for(int k=0; k

sum+=m1.mem[i*m1.cols+k]*m2.mem[k*m2.cols+j]; m3.mem[i*m3.cols+j] = sum; }

return true; }

28

第四章 派生类与继承

一、选择题

1. 从一个基类派生出的各个类的对象之间( C )。 A. 共享所有数据成员，每个对象还包含基类的所有属性 B. 共享部分数据成员，每个对象还包含基类的所有属性

C. 不共享任何数据成员，但每个对象还包含基类的所有属性 D. 共享部分数据成员和函数成员

2. 如果是类B在类A的基础上构造，那么，就称（ B ）。 A. 类A为基类或父类，类B为超类或子类

B. 类A为基类、父类或超类，类B为派生类或子类 C. 类A为派生类，类B为基类

D. 类A为派生类或子类，类B为基类、父类或超类 3. C++的继承性允许派生类继承基类的（C ）。

A. 部分特性，并允许增加新的特性或重定义基类的特性 B. 部分特性，但不允许增加新的特性或重定义基类的特性 C. 所有特性，并允许增加新的特性或重定义基类的特性 D. 所有特性，但不允许增加新的特性或重定义基类的特性 4. 派生类的成员函数可以直接访问基类的（ B ）成员。 A. 所有 B. 公有和保护 C. 保护和私有 D. 私有 5. 对于公有继承，基类的公有和保护成员在派生类中将( D )成员。 A. 全部变成公有 B. 全部变成保护

C. 全部变成私有 D. 仍然相应保持为公有和保护 6. 对于公有继承，基类中的私有成员在派生类中将 ( C )。

A. 能够直接使用成员名访问 B. 能够通过成员运算符访问

C. 仍然是基类的私有成员 D. 变为派生类的私有成员

7. 当保护继承时，基类的（ B ）在派生类中成为保护成员，在类作用域外不能够通过派生类的对象来直接访问该成员。

A. 任何成员 B.公有成员和保护成员

C. 保护成员和私有成员 D.私有成员

8. 在定义一个派生类时，若不使用保留字显式地规定采用何种继承方式，则默认为（ A）方式。 A. 私有继承 B. 非私有继承 C. 保护继承 D. 公有继承

9. 建立包含有类对象成员的派生类对象时，自动调用构造函数的执行顺序依次为（ C ）的构造函数。 A. 自己所属类、对象成员所属类、基类 B. 对象成员所属类、基类、自己所属类 C. 基类、对象成员所属类、自己所属类 D. 基类、自己所属类、对象成员所属类

10. 当派生类中有和基类一样名字的成员时，一般来说，（ B ）。 A. 将产生二义性 B. 派生类的同名成员将覆盖基类的成员 C. 是不能允许的 D. 基类的同名成员将覆盖派生类的成员 11. C++中的虚基类机制可以保证：（ D ）。 A. 限定基类只通过一条路径派生出派生类

B. 允许基类通过多条路径派生出派生类，派生类也就能多次继承该基类

C. 当一个类多次间接从基类派生以后，派生类对象能保留多份间接基类的成员

29

3. #include class Date { public: void SetDate(int y,int m,int d){ Year=y; Month=m; Day=d; }

void PrintDate(){ cout<

Date(int y,int m,int d){SetDate(y,m,d);}

protected:

int Year,Month,Day; };

class Time {

public:

void SetTime(int h,int m,int s){ Houre=h; Minutes=m; Seconds=s;} void PrintTime(){ cout<

Time(int h,int m,int s){SetTime(h,m,s);} protected:

int Houre, Minutes, Seconds; };

class Date_Time: public Date, public Time {

public:

Date_Time( ):Date(),Time(){};

Date_Time(int y,int mo,int d,int h,int mi,int s): Date(y,mo,d), Time(h,mi,s){} void PrintDate_Time(){PrintDate();PrintTime();} };

void main( )

{

Date_Time dt_a, dt_b(2002,10,1,6,0,0); dt_a.PrintDate_Time(); dt_b.SetTime(23,59,59); dt_b.PrintDate_Time(); dt_a.SetDate(2002,12,31); dt_a.PrintDate_Time(); }

第3题答案：

35

4.

#include class Date {

public:

Date(int y=2001,int m=1,int d=1){Year=y; Month=m; Day=d;} void PrintDate(){ cout<

int Year,Month,Day; }; class Time { public:

Time(int h=5,int m=30,int s=0){Houre=h; Minutes=m; Seconds=s;}

void PrintTime(){ cout<

int Houre, Minutes, Seconds; };

class Date_Time: public Date, public Time {

public:

Date_Time( ){};

Date_Time(int y,int mo,int d,int h=0,int mi=0,int s=0): Date(y,mo,d), Time(h,mi,s){} void PrintDate_Time(){PrintDate();PrintTime();} };

void main( )

{

Date_Time a, b(2002,10,1,6,20,0), c(2003,3,8,6,7); a.PrintDate_Time(); b.PrintDate_Time(); c.PrintDate_Time(); }

第4题答案：

36

四、程序设计题

1. 已知类定义如下，其中Shape为基类，Circle和Rectangle分别Shape的直接派生类，Square为Rectangle的直接派生类和Shape的间接派生类。请模仿Circle类，写出Rectangle类的所有成员函数。 /******************文件shape.h*************************/ const float PI=3.14159f; //定义圆周率常量 class Shape //几何图形抽象类 {

public:

virtual float GetPerimeter()=0; //纯虚函数，计算周长 virtual float GetAre()=0; //纯虚函数，计算面积 };

class Circle: public Shape //圆类 {

public:

Circle(float rad):rad(rad){} ~Circle(){}

float GetPerimeter() {return 2*PI*rad;} //计算圆形周长 float GetAre() {return PI*rad *rad;} //计算圆形面积

private:

float rad; //圆的半径 };

class Rectangle: public Shape //矩形类 {

public: //在下面编写每个成员函数

private:

float length, width; //矩形的长和宽 };

class Square: public Rectangle //正方形类 {

public: Square(float len): Rectangle(len,len){} ~Square(){}

};

class Rectangle: public Shape //矩形类 {

public:

Rectangle (float len,float wid):length(len),width(wid){}

~Rectangle (){}

float GetPerimeter() {return 2*(length+width);} //计算矩形周长

float GetAre() {return length*width;} //计算矩形面积 private: float length, width; //矩形的长和宽

}

37

2. 已知类定义如下，其中Shape为基类，Circle和Rectangle分别Shape的直接派生类，Square为Rectangle的直接派生类和Shape的间接派生类。请模仿Rectangle类，写出Circle类的所有成员函数。 /******************文件shape.h*************************/ const float PI=3.14159f; //定义圆周率常量

class Shape //几何图形抽象类

{

public:

virtual float GetPerimeter()=0; //纯虚函数，计算周长 virtual float GetAre()=0; //纯虚函数，计算面积 };

class Rectangle: public Shape //矩形类 {

public:

Rectangle (float len,float wid):length(len),width(wid){} ~Rectangle (){}

float GetPerimeter() {return 2*(length+width);} //计算矩形周长 float GetAre() {return length*width;} //计算矩形面积 private:

float length, width; //矩形的长和宽 };

class Circle: public Shape //圆类 {

public: //在下面编写每个成员函数

private:

float rad; //圆的半径

};

class Square: public Rectangle //正方形类 {

public: Square(float len): Rectangle(len,len){} ~Square(){}

};

class Circle: public Shape //圆类 {

public:

Circle(float rad):rad(rad){}

~Circle(){}

float GetPerimeter() {return 2*PI*rad;} //计算圆形周长 float GetAre() {return PI*rad *rad;} //计算圆形面积

private:

float rad; //圆的半径

};

38

第五章 多态性

一、选择题

1. 在重载一个运算符时，其参数表中没有任何参数，这表明该运算符是（ B ）。 A. 作为友元函数重载的1元运算符 B. 作为成员函数重载的1元运算符 C. 作为友元函数重载的2元运算符 D. 作为成员函数重载的2元运算符 2. 在成员函数中进行双目运算符重载时，其参数表中应带有（ B ）个参数。 A. 0 B. 1 C. 2 D. 3

3 双目运算符重载为普通函数时，其参数表中应带有（ C ）个参数。

A. 0 B. 1 C. 2 D. 3

4 如果表达式a+b中的“+”是作为成员函数重载的运算符，若采用运算符函数调用格式，则可表示为（ A ）。

A. a.operator+(b) B. b.operator+(a)

C. operator+(a,b) D. operator(a+b)

5 如果表达式a==b中的“==”是作为普通函数重载的运算符，若采用运算符函数调用格式，则可表示为（ C ）。 A. a.operator==(b) B. b.operator==(a) C. operator==(a,b) D. operator==(b,a)

6 如果表达式a++中的“++”是作为普通函数重载的运算符，若采用运算符函数调用格式，则可表示为（ C ）。

A. a.operator++() B. operator++(a) C. operator++(a,1) D. operator++(1,a)

7 如果表达式++a中的“++”是作为成员函数重载的运算符，若采用运算符函数调用格式，则可表示为（ D ）。

A. a.operator++(1) B. operator++(a) 8

C. operator++(a,1) D. a.operator++()

关于运算符重载，下列说法正确的是（ C ）。 A. 重载时，运算符的优先级可以改变。 B. 重载时，运算符的结合性可以改变。

C. 重载时，运算符的功能可以改变。

D. 重载时，运算符的操作数个数可以改变。

9 关于运算符重载，下列说法正确的是（ B ）。 A. 所有的运算符都可以重载。

B. 通过重载，可以使运算符应用于自定义的数据类型。 C. 通过重载，可以创造原来没有的运算符。 D. 通过重载，可以改变运算符的优先级。

10一个程序中数组a和变量k定义为“int a[5][10],k;”，且程序中包含有语句“a(2,5)=++k*3;”，则此语句中肯定属于重载操作符的是（ A ）。 A. ( ) B. = C. ++ D. * 11假定K是一个类名，并有定义“K k; int j;”，已知K中重载了操作符 ( )，且语句“j=k(3);”和“k(5)=99;”都能顺利执行，说明该操作符函数的原形只可能是（C ）。

A. K operator ( ) (int); B. int operator ( )(int&); C. int & operator ( )(int); D. K &operator( )(int);

12假定M是一个类名，且M中重载了操作符=，可以实现M对象间的连续赋值，如“m1=m2=m3;”。重载操作符=的函数原型最好是（ D ）。

39

本文来源：https://www.bwwdw.com/article/ctx5.html