《VC++程序设计基础》习题2

《Visual C++ 程序设计基础》练习题

第二部分面向对象的程序设计

一、复习并回答下列问题：

1. 什么是类，类的定义格式如何？类中成员的访问权限有哪些？

2. 类中的数据成员和成员函数有何区别？对成员函数的定义有何规定？

3. 什么是对象？对象的定义格式如何？对象成员如何表示？指向对象指针的成员如何表示？

4. 构造函数的功能和特点有哪些？析构函数的功能和特点又有哪些？默认构造函数和默认析构函数有何特点？

5. 拷贝构造函数的功能和特点是什么？默认拷贝构造函数有何用处？ 6. 成员函数具有哪些特征？

7. 静态数据成员如何定义？如何引用？它有何特点？静态成员函数有何特点？ 8. 友元函数如何定义？它有什么特点？友元类如何定义？它又有何特点？ 9. 类的作用域是什么？按生存期如何划分对象？ 10.什么局部类？

11.什么是指向对象的指针？什么是对象的引用？它们如何被定义？它们的主要功能是什么？

12.什么是对象数组？什么是对象数组指针？它们是如何定义的？ 13.this指针的含义是什么？为什么在程序中很少见到？

14.指向一维对象数组的指针是如何定义的？它的功能是什么？ 15.什么是对象指针数组？它是如何被定义的？

16.如何使用const来说明指针常量？使用const说明常量时应注意些什么？ 17.如何说明const成员函数？const成员函数有何特点？ 18.const数据成员如何初始化？

19.什么是对象成员？如何对对象成员进行初始化？

20.使用new运算符创建对象时和创建对象数组时有何不同？

21.什么是转换函数？如何定义一个转换函数？转换函数有何功能？ 22.什么是继承性？为什么说它是面向对象语言中的重要机制？

23.C++语言中继承分为哪两类？继承方式又分为哪三种？三种不同继承方式有何特点？

24.不同继承方式中，说明下列各种情况对于基类成员访问有何不同？ A) 派生类

B) 派生类的对象 C) 派生类的派生类

25.如何定义单继承的派生类？如何定义多继承的派生类？ 26.派生类与基类之间有什么关系？

27.单继承中, 派生类的构造函数如何定义？

1

28.多继承中, 派生类的构造函数如何定义？ 29.什么是子类型？它有何作用？

30.多继承中那些情况下会出现二义性？如何消除？

31.为什么要引入虚基类？带有虚基类的派生类构造函数有什么特点？ 32.什么是多态性？为什么说\多态性是继承性的补充\？ 33.什么是函数重载？定义重载函数时应注意哪些问题？ 34.什么是运算符重载？是否所有的运算符都能重载？ 35.运算符重载的定义格式如何？运算符重载有几种形式？

36.运算符被重载后与原运算符有何关系？ 37.什么是编译时多态性和运行时多态性？

38.什么是虚函数？如何说明虚函数？是否所有的成员函数都可以说明为虚函数？ 39.什么是纯虚函数？什么是抽象类？ 40.虚析构函数有何功能？

41.总结c++语言的多态性包含哪些内容？

42.在C++的输入输出操作中,如何理解\流\的概念？从流的角度说明什么是提取操作？什么是插入操作？

43.系统预定的流类对象中，cin和cout的功能是什么？

44.从键盘上输入一个字符有哪些方法？输入一个字符串有哪些方法？ 45.向屏幕上输出一个字符有哪些方法？输出一个字符串有哪些方法？ 46.如何将一个int型的数按不同进制形式输出？ 47.如何输出一个指定精度的浮点数？ 48.如何确定输出数据项的宽度？

49.打开和关闭一个磁盘文件有哪些方法？ 50.读写磁盘文件中信息有哪些方法？ 51.如何对文件进行随机存取操作？

二、填空

1. 关于类定义格式的描述中，〖D〗是错的。

A)一般类的定义格式分为说明部分和实现部分 B)一般类中包含有数据成员和函数成员

C)类中成员可设置以下访问方式之一：public,private,protected D)函数成员都应是公有的、数据成员都应是私有的 2. 下列关键字中，〖C〗不是类定义中使用的关键字。 A)class B)public C)switch D)private

3.下列叙述中，不正确的是〖B〗。

A)类的构造函数可以重载 B)类的析构函数可以重载 C)一个类可以不定义构造函数 D)一个类可以不定义析构函数

2

4. 关于类中成员函数的描述中，〖B〗是错的。 A)类中可以说明一个或多个成员函数 B)类中的成员函数只能定义在类体外

C)定义在类体外的成员函数前加inline可以成为内联函数 D)在类体外定义成员函数时，在函数名前除了加类型说明符外，还需用作用域运算符限定该成员函数所属的类

5. 关于对象的描述中，〖A〗是错的。

A)同一个类创建的若干个对象的数据结构和其内容都是不相同的 B)对象的成员表示与C语言中结构变量的成员表示相同 C)一个类可以定义多个对象、指向对象的指针和对象数组 D)一个对象在定义时就被初始化

6. 下列是构造函数的特点，〖C〗是错的。

A)构造函数是一种成员函数，它具有一般成员函数的特点 B)构造函数的名称与其类名相同 C)构造函数必须指明其类型

D)一个类中可定义1个或多个构造函数

7. 下列是析构函数的特点，〖A〗是错的。

A)析构函数的名字不能与类名相同，否则将与构造函数无法区别 B)析构函数中不可以有参数 C)析构函数定义时不必指出类型 D)析构函数也是一种成员函数

8. 拷贝构造函数具有的下列特点中，〖C〗是错的。

A)如果一个类中没有定义拷贝构造函数时，系统将自动生成一个默认的 B)拷贝构造函数只有一个参数，并且是该类对象的引用 C)拷贝构造函数的名字不能用类名 D)拷贝构造函数是一种成员函数

9. 下列关于类成员函数的特性中，〖B〗是错的。 A)除析构函数外，成员函数都可以重载 B)成员函数都是内联的

C)除析构函数外，成员函数都可以设置默认参数 D)成员函数可以是公有的，也可以是私有的 10.关于静态成员的描述中，〖B〗是错的。

A)静态成员可以分为静态数据成员和静态函数成员 B)静态数据成员定义后必须在类体内进行初始化 C)静态数据成员初始化不使用其构造函数 D)静态函数成员中不能直接引用非静态成员 11.关于友元的描述中，〖A〗是错的。

A)友元函数是成员函数，它被说明在类体内 B)友元函数可直接访问类中的私有成员

3

C)友元函数破坏类的封装性，使用时应少用 D)友元类中的所有成员函数都是友元函数

12.已知：类A中的一个成员函数说明为void Set(A&a);其中,A&a的含义是〖B〗。 A)变量A与变量a按位与作为函数Set()的实参 B)类A的对象引用a作为函数 Set()的参数 C)指向类A的指针a作函数Set()的参数 D)将类A的对象a的地址值赋给变量Set 13.下列关于对象数组的描述中，〖A〗是错误的。 A)对于对象数组只能赋初值而不能赋值 B)对象数组的下标是从0开始的

C)对象数组的每个元素都是相同类的对象 D)对象数组的数组名是一个常量指针

14.下列关于指向类的一维对象数组的指针p的定义中，〖B〗是正确的。 A)A p[5] B)A (*p)[5] C)(A*)p[5] D)A*p[] 15.已知：const char*ptr;那么ptr应该是〖A〗。

A)指向字符串常量的指针 B)指向字符串的常量指针 C)指向字符的常量的指针 D)指向字符常量的指针

16.已知：Print()函数是一个类的const成员函数，它无返回值,也无参数。下列关于Print()函数的各种说明中，〖A〗是正确的。 A)void Print() const; B)void const Print(); C)const void Print(); D)void Print(const);

17.下列关于对象成员的描述中，〖D〗是错误的。

A)对象成员是类的一种数据成员，它是另一个类的对象 B)对象成员不可以是自身类的对象

C)对对象成员的初始化要包含在该类的构造函数中 D)一个类中只能含有一个对象成员作其成员 18.对new运算符的下列描述中，〖B〗是错误的。 A)它可以动态创建对象和对象数组 B)用它创建对象数组时必须指定初始值 C)用它创建对象时要调用构造函数

D)用它创建的对象可以使用运算符delete来释放

19.对delete运算符的下列描述中，〖D〗是错误的。

A)用它可以释放用new运算符创建的对象和对象数组 B)用它释放一个对象时，它作用于一个new所返回的指针

C)用它释放一个对象数组时,它作用的指针名前须加下标运算符([]) D)它不适用于空指针

20.下列对类型转换函数的描述中，〖D〗是错误的。 A)类型转换函数是一种非静态的成员函数

4

Q(int a=0,int b=0){ x=a;y=b; }

void P(){ cout<

~Q()

{ cout<<\调用析构函数！\\n\ };

void main() { Q q(50); q.P();

cout<<\退出主函数！\\n\ }

53.以下程序的运行结果为〖B〗

#include class A{ int x; public: A(int a)

{ x=a; cout<<\ A( ) { cout << \ … };

class B:public A{ int y; public:

B(int a,int b)

{ y=a; cout<<\ … };

void main() { B b1(2,3);}

A)call A(int) B)call A( ) C)call B(int,int) call B(int,int) call B(int,int) 54.以下程序的运行结果为〖B〗 #include class A{ int x; public:

A(int a=0) { x=a;cout<

class B{ int y; public:

B(int a=0) { y=a;cout<

10

D)call A(int)

};

class C:public A,public B{ int z; public:

C(int a=0,int b=0):B(a+20),A(a) { z=b;cout<

void main() { C c(100,200); }

A)120,100,200 B)100,120,200 C)200,100,120 D)200,120,100 55.以下程序的运行结果为〖B〗

#include class A{ int x; public:

A(int a=0) {x=a;cout<

class B{ int y; public:

B(int a=0) {y=a;cout<

class C: public B,virtual public A{ int z; public:

C(int a=0,int b=0):B(a+20),A(a) {z=b; cout<

void main()

{ C c(100,200); }

A)120,100,200 B)100,120,200 C)200,100,120 D)200,120,100

三、判断下列各种描述是否正确，对者划√，错者划×。

×(1)一个类中可以只有公有成员，也可以只有私有成员，也可以公有、私有成员都有。

×(2)用class定义的类中，默认的访问权限是公有的。

√(3)指向对象的指针的成员表示与对象的成员表示所使用的运算符不同。

×(4)构造函数是用来初始化所定义的对象，如果一个类中没有定义任何构造函数，

则该类的对象便无法初始化。

√(5)定义一个对象时系统只存储其数据成员，而不存储对象的成员函数，成员函数

是同类对象所共享的。

11

×(6)析构函数是一个函数体为空的成员函数。

×(7)构造函数和析构函数都可以重载，因为它们都是成员函数。

√(8)如果一个成员函数只存取一个类的静态数据成员，可将该成员函数说明静态成

员函数。

×(9)在类的构造函数中可对其静态数据成员进行初始化。

√(10)友元类中的所有成员函数可以对该类中的私有成员进行存取操作。

√(11)指向对象的指针和对象都可以作为函数参数，但是使用前者比使用后者好些。 ×(12)对象引用作函数参数不如使用对象指针方便。 √(13)对象数组的元素必须是同一个类的对象。

√(14)一维对象指针数组的每一个元素应该是某个类的对象的地址。 √(15)运算符new可以创建变量或对象，也可以创建数组。

√(16)const类型说明符可以用来说明各种不同类型的常量，也可以说明const成员函数。

×(17)对象成员的初始化可以不在该类的构造函数中。

√(18)转换函数是类的成员函数，它是用来进行强制类型转换的。 √(19)C++语言中,允许单继承，也允许多继承。 ×(20)派生类不能再派生新的类。

×(21)在公有继承中，派生类可以访问基类中的私有成员。

√(22)在公有继承中，派生类的对象不可以访问基类中的保护成员。 √(23)在私有继承中，派生类的对象不可以访问基类中的公有成员。 √(24)在保护继承中，派生类可以访问基类中的保护成员。 ×(25)基类的析构函数可以被派生类继承。

×(26)在多继承情况下，派生类构造函数对基类构造函数的执行顺序取决于它的成员初始化表中说明的基类顺序。

√(27)虚基类是用来解决多继承中公共基类在派生类中只产生一个拷贝的问题。 √(28)函数参数个数和类型都相同,只是返回值类型不同,这不是重载函数 ×(29)重载函数不能带有缺省参数,因为可能出现二义性

√(30)个别运算符不能重载，运算符重载是通过对它重新定义函数来实现的 √(31)运算符重载有两种形式：成员函数和友元函数 √(32)运算符重载后,不改变原来的优先级和结合性 √(33)虚函数是一种用virtual说明的成员函数 ×(34)抽象类中只能有一个纯虚函数

×(35)构造函数和析构函数都不能说明为虚函数

√(36)动态联编是在运行时选择操作函数的

√(37)程序中可以说明抽象类的指针或引用,但是不能说明抽象类的对象 √(38)使用提取符(>>)可以输入各种变量的值，但不能输入地址值。 ×(39)使用插入符(<<)可以输出各种变量的值，但不能输出地址值。 √(40)预定义的提取符和插入符都是可以重载的。

×(41)函数write()是用来将一个字符串送到一种输出流中，但是它只能将一个字符串

12

中全部字符送到输出流中。

√(42)控制当前格式化状态的标志字中，每一位标志一种格式。这种格式既可以被设

置也可以被清除。

√(43)控制符本身可以是一种对象，它可以直接被提取符或插入符操作。

√(44)使用打开文件函数前应先定义一个流对象，然后使用open()函数来操作该对

象。

√(45)read()和write()函数可以读写文本文件，也可以读写二进制文件。 √(46)以app方式打开文件时，当前的读指针和写指针都定位于文件尾。 √(47)C++的I/O流库中所提供的读写函数对标准流和一般流都是相同的。

四、分析下列程序的输出结果。

(1)#include

class A { int a1,a2; public: A() { 1=a2=0; cout<<\} A(int i,int j) { a1=i; a2=j; cout<<\ } void print() { cout<<\ } };

void main() { A x,y(3,9); x.print(); y.print(); } 参考答案：

Default constructor called. Constructor called. a1=0,a2=0 a1=3,a2=9

(2)#include

class B { int b1,b2; public: B() { } B(int i,int j) { b1=i; b2=j; } void printB( ) { cout<<\ };

class A { int a; B c; public: A() { }

13

A(int i,int j,int k):c(i,j),a(k) { } void printA() { c.printB(); cout<<\ } };

void main() { A x(12,65,100); x.printA(); } 参考答案： b1=12,b2=65 a=100

(3)#include

class C { static int c; public: C() { cout<<++c<

int C::c=0; void main()

{ C c1,c2,c3,c4,c5;

cout<

参考答案： 1 2 3 4 5 5 5 4 3 2 1

(4)#include

class M { int m1,m2; public: M(int i,int j) { m1=i; m2=j; } void Sum(M a,M b) { m1=a.m1+b.m1; m2=a.m2+b.m2; } void print() { cout<<\ }

14

c1.Print(); c2.Print(); c1=complex(0.8,0.5); c2=55; c3=complex(); c1.Print(); c2.Print(); }

参考答案：

c3.Print();

c3.Print();

Default constructor called. Constructor:real=6.9,imag=0 Constructor:real=12.2,imag=25.8 0+0i 6.9+0i 12.2+25.8i

Constructor:real=0.8,imag=0.5 Constructor:real=55,imag=0 Default constructor called. 0.8+0.5i 55+0i 0+0i

(11)分析下列程序，并回答下列问题 #include #include class String {

int Length; char *Buffer; public:

String() { Length=0; Buffer=0; } String(const char *str);

~String() { delete []Buffer; }

void Setc(int index,char newchar); char Getc(int index) const;

int GetLength() const { return Length; } void Print() const

{ if(Buffer==0) cout<<\ else cout<

void Append(const char *Tail); };

String::String(const char*str) { Length=strlen(str);

Buffer=new char[Length+1]; strcpy(Buffer,str);

20

}

void String::Setc(int index,char newchar)

{ if(index>0 && index<=Length) Buffer[index-1]=newchar; } char String::Getc(int index) const

{ if(index>0 && index<=Length) return Buffer[index-1]; else return 0; } void String::Append(const char *Tail) { char *tmp;

Length+=strlen(Tail); tmp=new char[Length+1]; strcpy(tmp,Buffer); strcat(tmp,Tail); delete []Buffer; Buffer=tmp; }

void main()

{ String s0,s1(\ s0.Print(); s1.Print();

cout<

cout<

s2.Append(\ s2.Print(); }

回答下列问题：

1)该程序中调用包含在string.h文件中的哪些函数？

2)该程序的String类中是否用了函数重载的方法？那些函数是重载的？ 3)简述Setc()函数有何功能？ 4)简述Getc()函数有何功能？ 5)简述Append()函数有何功能？

6)该程序中的成员函数Print()中不用if语句，只写成如下一条语句，行否？ cout<

7)该程序中有几处使用了new运算符？ 8)写出该程序执行后的输出结果。 参考答案：

1)strlen(),strcpy(),strcat()

2)String类中的构造函数用了函数重载的方法 3)设置指定位置上的字符 4)得到指定位置上的字符 5)字符串连接

21

6)不行 7)两处 8)empty. a string. 9

a stping. i

this a string. (12)#include

class A { int a,b; public: A(int i,int j) { a=i; b=j; } void Move(int x,int y) { a+=x; b+=y; } void Show() { cout<<'('<

class B:private A { int x,y; public: B(int i,int j,int k,int l):A(i,j) { x=k; y=l; } void Show() { cout<

void main() { A a(1,2); a.Show(); B b(3,4,5,6); b.fun(); b.Show(); b.f1(); }

参考答案： (1,2) 5,6 (10,12)

(13)#include class A { int a,b; public:

22

A(int i,int j) { a=i; b=j; } void Move(int x,int y) { a+=x; b+=y; } void Show() { cout<<'('<

class B:public A { int x,y; public: B(int i,int j ,int k,int l):A(i,j),x(k),y(l) { } void Show() { cout<

void main() { A a(1,2); a.Show(); B b(3,4,5,6); b.fun(); b.A::Show(); b.B::Show(); b.f1(); }

参考答案： (1,2) (6,9) 5,6 (6,9)

(14)#include

class L { int X,Y; public: void InitL(int x,int y) { X=x; Y=y; } void Move(int x,int y) { X+=x; Y+=y; } int GetX() { return X; } int GetY() { return Y; } };

class R:public L { int W,H; public: void InitR(int x,int y,int w,int h) { InitL(x,y); W=w; H=h; } int GetW() { return W; } int GetH() { return H; }

23

};

class V:public R { public: void fun() { Move(3,2); } };

void main() { V v; v.InitR(10,20,30,40); v.fun(); cout<<'('<

参考答案： (13,22,30,40) (15)#include

class P { int pri1,pri2; public: P(int p1,int p2) { pri1=p1; pri2=p2; } int inc1() { return ++pri1; } int inc2() { return ++pri2; } void display() { cout<<\ };

class D1:private P { int pri3; public: D1(int p1,int p2,int p3):P(p1,p2) { pri3=p3; } int inc3() { return ++pri3; } void display() { P::display(); cout<<\ };

class D2:public P { int pri4; public: D2(int p1,int p2,int p4):P(p1,p2) { pri4=p4; } int inc4() { return ++pri4; } void display() { P::display(); cout<<\ };

class D12:private D1,public D2 { int pri12; public: D12(int p11,int p12,int p13,int p21,int p22,int p23,int p)

24

:D1(p11,p12,p13),D2(p21,p22,p23) { pri12=p; } int inc5() { return ++pri12; } void display() { cout<<\ D2::display(); cout<<\ } };

void main ()

{ D12 d(1,2,3,4,5,6,7); d.display(); cout<

参考答案： D2::display() pri1=4,pri2=5 pri4=6 Pri12=7

D2::display() pri1=4,pri2=5 pri4=7 Pri12=8

(16)#include

class P { int pri1,pri2; public: P(int p1,int p2) { pri1=p1; pri2=p2; } int incl() { return ++pri1; } void display() { cout<<\ };

class D1:virtual private P { int pri3; public: D1(int p1,int p2,int p3):P(p1,p2) { pri3=p3; } int inc3() { return ++pri3; } void display() { P::display(); cout<<\ };

class D2:virtual public P {

25

int pri4; public: D2(int p1, int p2, int p4):P(p1,p2) { pri4=p4; } int inc4() { return ++pri4; } void display() { P::display(); cout<<\ };

class D12:private D1,public D2{ int pri12; public: D12(int p11,int p12,int p13,int p21,int p22,int p23,int p) :D1(p11,p12,p13),D2(p21,p22,p23),P(p11,p21){ pri12=p; } int inc5() { return ++pri12; } void display() { cout<<\ D2::display(); cout<<\ } };

void main()

{ D12 d(1,2,3,4,5,6,7); d.display(); cout<

参考答案： D2::display() pri1=1,pri2=4 pri4=6 Pri12=7

D2::display() pri1=3,pri2=4 pri4=7 Pri12=8

(17)#include class B { int b; public: B(){ }

26

B(int i) { b=i+50; show(); } void show() { cout<<\ };

class D:private B { int d; public: D(int i):B(i) { d=i+100; show(); } void show() { cout<<\ };

void main() { D d1(105); } 参考答案： B::show() called.155 D::show().205 (18)#include

class B { int b; public: B(){ } B(int i) { b=i; } virtual void virfun() { cout<<\ };

class D:public B { int d; void virfun() { cout<<\ public: D(){} D(int i,int j):B(i) { d=j; } };

void fun(B*obj) { obj->virfun (); } void main() { B*pb=new B; fun(pb); D *pd=new D; fun(pd); }

参考答案： B::virfun() called. D::virfun() called. (19)#include

27

class A {

protected: char ver; public: A() { ver='A'; } virtual void print() { cout<<\ };

class D1:public A { int info; public: D1(int number) { info=number; ver='1'; } void print() { cout<<\ };

class D2:public A { int info; public: D2(int number) { info=number; } void print() { cout<<\ };

class D3:public D1 { int info; public: D3(int number):D1(number) { info=number;ver='3'; } void print() { cout<<\ };

void print_info(A*p) { p->print (); } void main()

{ A a; D1 d1(4); D2 d2(100); D3 d3(-25); print_info(&a); print_info(&d1); print_info(&d2); print_info(&d3); }

参考答案：

The A version A

The D1 info:4 version 1 The D2 info:100 version A The D3 info:-25 version 3 (20)#include

class Shape {

protected: double x,y; public: Shape(double a,double b):x(a),y(b) { } virtual double Area() const { return 0.0; } };

28

class Circle:public Shape { double r; public: Circle(double a,double b,double c):Shape(a,b),r(c) { } double Area() const { return 3.1415*r*r; } };

class Rectangle:public Shape { double h,w; public: Rectangle(double a,double b,double c,double d):Shape(a,b) { h=c; w=d; } double Area() const { return h*w; } };

void fun(Shape &s) { cout<

{ Circle c(2.5,15.0,4.8); fun(c); Rectangle r(22.0,50,10.6,2.0); fun(r); }

参考答案： 72.38016 21.2

(21)#include #include #include void main() { fstream infile,outfile; outfile.open(\ if(!outfile) { cout<<\ outfile<<\ outfile<<\ outfile<<\ outfile.close(); infile.open(\ if(!infile) { cout<<\ abort(); } char textline[80]; while(!infile.eof()) { infile.getline(textline,sizeof(textline)); cout<

29

mmmnnnpppqqq ok!

(22)#include #include #include void main() { fstream file1;

file1.open(\ if(!file1) { cout<<\ abort(); } char textline[]=\ for(int i=0;i void main()

{ ostrstream s; }

s<<\ s<<'\\0'; char *buf=s.str(); cout<

▲

参考答案：Hi,good morning!\

30

mmmnnnpppqqq ok!

(22)#include #include #include void main() { fstream file1;

file1.open(\ if(!file1) { cout<<\ abort(); } char textline[]=\ for(int i=0;i void main()

{ ostrstream s; }

s<<\ s<<'\\0'; char *buf=s.str(); cout<

▲

参考答案：Hi,good morning!\

30

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