文档库

最新最全的文档下载
当前位置:文档库 > C++复习题(2015)

C++复习题(2015)

C++练习题

一、选择题

1. C++语言是从早期的C语言逐渐发展演变而来的。与C语言相比,它在求解问题方法上进行的最大改进是( B )。

A.面向过程B.面向对象C.安全性D.复用性

2. C++对C语言作了很多改进,即从面向过程变成为面向对象的主要原因是( D )。

A. 增加了一些新的运算符

B. 允许函数重载,并允许设置缺省参数

C. 规定函数说明符必须用原型

D. 引进了类和对象的概念

3. 对C++语言和C语言的兼容性,描述正确的是( A )。

A.C++兼容C B.C++部分兼容C C.C++不兼容C D.C兼容C++

4. 在C++中,头文件扩展名为( B )。

A. .cpp

B. .h

C. .1ib

D. .obj

5. C++源程序文件扩展名为( A ) 。

A. .cpp

B. .h

C. .1ib

D. .obj

6. 由C++源程序文件编译而成的目标代码文件的缺省扩展名为( C )。

A. .cpp

B. .exe

C. .obj

D. .lik

7. 布尔类型标识符是( D )。

A.void

B.short

C.long

D.bool

8. 下列不是C++语言的基本数据类型的是( D )。

A.字符类型

B.整数类型

C.逻辑类型

D.枚举类型

9. 用于标识十六进制前缀或后缀是( D )。

A. 后缀L

B.后缀e

C.前缀零

D.前缀0x

10. 设x和y均为bool量,则x&&y为真的条件是( A )。

A. 它们均为真

B. 其中一个为真

C. 它们均为假

D. 其中一个为假

11. 在下列成对的表达式中,运算结果类型相同的一对是( D )。

A.7/2和7.0/2.0

B.7/2.0和7/2

C.7.0/2和7/2

D.7.0/2.0和7.0/2

12. 如果a=1,b=2,c=3,d=4,则条件表达式a

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

13.在预编译指令中,宏定义使用哪个指令(B)。

A.#include B.#define C.#if D.#else

14. 包含自定义头文件file.h的预处理指令是( D )。

A.#define

B.#include file.h

C.#define file.h

D.#include"file.h"

15. 可替换#define PI 3.1415926的语句是( B )。

A.float PI 3.1415926;

B.const float PI=3.1415926;

C.const PI(3.1415926);

D.const 3.1415926;

16. 在C++中使用流进行输入输出,其中专用于从键盘进行输入的流是( B )。

A.cerr

B.cin

C.cout

D.cfile

17.在C++中使用流进行输入输出,其中用于屏幕输出的对象是( C )。

A.cerr B.cin C.cout D.cfile

18. 下列给字符数组进行的初始化中,正确的是( A )。

A. char s1[]="abcd";

B.char s2[3]="xyz";

C. char s3[][]={'a','x','y'};

D.char s4[2][3]={"xyz","mnp"};

19. 在int b[][3]={{1},{3,2},{4,5,6},{0}}中,a[2][2]的值是( C )。

A. 0

B. 5

C.6

D.2

20.int a=3;int *p=&a;中,*p的值是( D ) 。

A.变量a的地址值

B.无意义

C.变量p的地址值

D. 3

21. 对于int *pa[5];的描述,正确的是( D )。

A. pa是一个指向数组的指针,所指向的数组是5个int型元素

B. pa是一个指向某数组中第5个元素的指针,该元素是int型变量

C. pa[5]表示某个数组中的第5个元素的值

D. pa是一个具有5个元素的指针数组,每个元素是一个int型指针

22. 已知:int a,&ra=a;关于ra的描述中正确的是( C )。

A. ra是int型变量a的地址值

B.a是int型变量ra的地址值

C. ra是int型变量a的引用

D. ra是int型变量a的指针

23. 假定变量x定义为“int x=5;”,要使rx成为x的引用(别名),rx应定义为( D )。

A. int rx=x;

B. int rx=&x;

C. int *rx=&x;

D. int &rx=x;

24. 设存在整型变量int x,则下列语句中与其它三项含义不同的是( A ) 。

A.int* p=&x;

B.int& p=x;

C.int & p=x;

D.int &p=x;

25. 设函数void swap(int&,int&)将交换两形参的值,如两整型变量int a=10;int b=15;

则执行swap(a,b)后,a、b值分别为( C ) 。

A.10,10

B.10,15

C.15,10

D.15,15

26. 设存在函数int min(int,int)返回两参数中较小值,若求15,26,47三者中最小值,下列表达式中错误的是( B ) 。

A.int m=min(min(15,26),min(15,47));

B.int m=min(15,26,47);

C.int m=min(15,min(47,26));

D.int m =min(min(47,26),16);

27.设存在函数int max(int,int)返回两参数中较大值,若求22,59,70三者中最大值,下列表达式不正确的是( C )。

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));

28. 以下正确的函数原型语句是( C )。

A. double fun(int x,int y)

B. double fun(int x;int y)

C. double fun(int,int);

D. double fun(int x,y);

29. 在函数声明中,下面哪项不是必要的( D )。

A.函数参数的类型和参数名

B.函数名

C.函数的类型

D.函数体

30. 使用值传递方式将实参传给形参,下列说法正确的是( A )。

A.形参是实参的备份B.实参是形参的备份

C.形参和实参是同一对象D.形参和实参无联系

31. 在每个C++程序中都必须包含有这样一个函数,该函数的函数名为( A )

A. main

B. MAIN

C. name

D. function

32. 包含哪种语句的函数不能声明为内联函数( A )。

A.循环

B.变量自增自减

C.if...else…

D.变量声明

33. 在(C )情况下适宜采用inline定义内联函数。

A.函数体含有循环语句

B.函数体含有递归语句

C.函数代码少、频繁调用

D.函数代码多、不常调用量

34.一个函数功能不太复杂,但要求被频繁调用,选用( A)。

A.内联函数

B.重载函数

C.递归函数

D.嵌套函数

35. 在C++中,关于下列设置参数默认值的描述中,正确的是( C )。

A.不允许设置参数的默认值

B.设置参数默认值只能在定义函数时设置

C.设置参数默认值时,应该是先设置右边的再设置左边的

D.设置参数默认值时,应该全部参数都设置

36. 函数默认参数在函数原型中说明,默认参数必须放在参数序列的( C )。

A.前部

B.中部

C.后部

D.两端

37. 下列哪种默认参数的声明是不正确的( C )。

A. int max(int a,int b,int c,int d=0);

B. int max(int a,int b,int c=0,int d=0);

C. int max(int a=0,int b,int c=0,int d=0);

D. int max(int a,int b=0,int c=0,int d=0);

38.下列函数不能和函数void print(char)构成重载的是( C ) 。

A.int print(int);

B.void print(char,char);

C.int print(char);

D.void print(int,int);

39.int Func(int,int);不可与下列哪个函数构成重载( B )。

A.int Func(int,int,int);B.double Func(int,int);

C.double Func(double,double);D.double Func(int,double);

40. 定义函数模板中使用的参数类型标识符需使用下列哪组符号括起来( A )。

A.<>

B.“”

C.()

D.{}

41. 设有函数T Sum(T x,T y){return x+y;},其中T为模板类型,则下列语句中对该函数错误的使用是( D ) 。

A.Sum(1,2);

B.Sum(3.0,2.2);

C.Sum(…A?,…C?);

D. Sum("A","C");

42. 对于结构中定义的成员,其隐含访问权限为( C )。

A. public

B. protected

C. private

D. static

43. C++允许在结构中定义函数,这些函数称为( D )。

A.静态函数

B.构造函数

C.析构函数

D.成员函数

44.对使用关键字new所开辟的动态存储空间,释放时必须使用( C )。

A.free B.create C.delete D.realse

45. 假定指针变量p定义为“int *p=new int[30];”,要释放p所指向的动态内存,应使用语句(D )。

A. delete p;

B. delete *p;

C. delete &p;

D. delete []p;

46. 要使语句“p=new int[10][20];”能够正常执行,p应被事先定义为( D )。

A. int *p;

B. int **p;

C. int *p[20];

D. int(*p)[20];

47. 使用delete[]删除对象数组时,描述正确的是( A )。

A.数组中各元素都调用析构函数

B.数组中各元素都调用构造函数

C.不调用析构函数

D.只有首元素调用析构函数

48. 有关类的说法不正确的是( D )。

A.类是一种用户自定义的数据类型

B. 类中的成员函数可以存取类中的私有数据

C. 在类中,如果不作特别说明,所有的数据均为私有类型

D. 在类中,如果不作特别说明,所有的成员函数均为公有类型

49. 在下列关键字中,用以说明类中公有成员的是( A )。

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

50. 下列哪个不是面向对象的关键要素( B )。

A.抽象性

B.结构性

C.封装性

D.多态性

51.下列可以不是类的成员函数的是( C )。

A.构造函数

B.析构函数

C.友元函数

D.复制构造函数

52. print()函数是一个类的常成员函数,它无返回值,下列表示中,正确的是( A )。

A.void print() const B.const void print()

C.void const print() D.void print(const)

53. 在定义类成员时,为产生封装性,则需使用哪个关键字( D ) 。

A.public

B.publish

C.protected

D.private

54. 如没有使用private关键字定义类的数据成员,则默认为( A )。

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

55. 类的私有成员可在何处被访问( A ) 。

A.本类的成员函数中

B.本类及子类的成员函数中

C.通过对象名在任何位置

D.不可访问

56.this指针存在的目的是( B )。

A.保证基类公有成员在子类中可以被访问

B.保证每个对象拥有自己的数据成员,但共享处理这些数据成员的代码

C.保证基类保护成员在子类中可以被访问

D.保证基类私有成员在子类中可以被访问

57. 有关构造函数的说法不正确的是( D )。

A.构造函数名字和类的名字一样

B.构造函数在定义对象时自动执行

C.构造函数无任何函数类型

D.构造函数有且只有一个

58. 为对象进行初始化的是( C )。

A.析构函数B.数据成员C.构造函数D.静态成员函数

59. 类的构造函数在以下什么情况下会被自动调用( B ) 。

A.定义成员函数时

B.定义对象时

C.定义数据成员时

D.定义友元函数时

60.构造函数不具备的特征的是( D )。

A.构造函数的函数名与类名相同

B.构造函数可以重载

C.构造函数可以设置默认参数

D.构造函数必须指定类型说明

61. 一个类拥有多个构造函数,则这些构造函数间为( A )。

A.重载关系

B.重复关系

C.拷贝关系

D.无关系

62.如果没有为一个类定义任何构造函数的情况下,下列描述正确的是( A )。

A.编译器总是自动创建一个不带参数的构造函数

B.这个类没有构造函数C.这个类不需要构造函数D.该类不能通过编译

63. 对于拷贝构造函数point::point(point& p),下列说明正确的是( C )。

A.该函数只能访问P的私有成员

B.该函数不能访问P的公有成员

C.该函数可以访问P的私有和公有成员

D.该函数不能访问P的成员

64.通常,拷贝构造函数的参数是( C )。

A.某个对象名

B.某个对象的成员名

C.某个对象的引用名

D.某个对象的指针名

65. 假定AB为一个类,则执行“AB a(4) , b[3] , * p[2] ;”语句时,自动调用该类构造函数的次数为( B ) 。

A. 3

B. 4

C. 6

D. 9

66. 下列关于析构函数描述正确的是( D ) 。

A.可以重载

B.函数体中必须有delete语句

C.返回类型必须是void类型

D.不能指定返回类型

67. 类的析构函数是在( C )调用的。

A.类创建时

B.创建对象时

C.删除对象时

D.不自动调用

68. 类的析构函数的作用是( D )。

A.一般成员函数

B.类的初始化

C.对象的初始化

D.撤消对象时做清理工作

69. 下述静态数据成员的特性中,错误的是( D )。

A.说明静态数据成员时前边要加修饰符static

B.静态数据成员要在类体外进行初始化

C.引用静态数据成员时,要在静态数据成员前加〈类名〉和作用域运算符

D.静态数据成员不是所有对象所共有的

70.设类Test中存在成员static int x,则下列哪种初始化方式是正确的( C )。

A.Test::int x=25;

B.int x=25;

C.int Test::x=25;

D.int Test x=25;

71.下列关于友元的描述错误的是( A )。

A.成员函数不可作友元

B.类可以作友元

C.普通函数可以作友元

D.静态函数可以作友元

72.对于友元描述正确的是( B )。

A.友元是本类的成员函数B.友元不是本类的成员函数

C.友元不是函数D.友元不能访问本类私有成员

73. 如果类A被说明成类B的友元,则( D )。

A. 类A的成员即类B的成员

B. 类B的成员即类A的成员

C. 类A的成员函数不得访问类B的成员

D. 类B不一定是类A的友元

74. 下列运算符中,在C++中不能重载运算符是( A )。

A.?: B.+ C.- D.=

75. 假定要对类AB定义“+”号操作符重载成员函数,实现两个AB类对象的加法,并返回相加结果,则该成员函数的声明语句为( B )。

A. AB operator+(AB&a,AB&b)

B. AB operator+(AB& a)

C. operator+(AB a)

D. AB & operator+( )

76. 继承的机制是( C )。

A.信息隐藏

B.数据封装

C.定义新类

D.数据抽象

77. 关于私有继承,下列说法错误的是( B )。

A. 基类的公有成员和保护成员被继承后作为派生类的私有成员,派生类的其他成员可以直接访问他们。

B. 基类的公有成员和保护成员被继承后作为派生类的私有成员,派生类的其他成员不能直接访问他们。

C. 派生类的成员和派生类的对象都无法访问基类的私有成员。

D. 派生类的对象无法访问基类的所有成员。

78. 在公有继承中,基类中的保护成员作为派生类的(C )。

A. 公有成员

B. 私有成员

C. 保护成员

D. 私有成员函数

79. C++类体系中,不能被派生类继承的有( A )。

A.构造函数

B. 虚函数

C. 静态成员函数

D. 赋值操作函数

80. C++类体系中,能被派生类继承的是( B )。

A. 构造函数

B. 虚函数

C. 析构函数

D. 友元函数

81. 基类中的( C )不允许外界访问,但允许派生类的成员访问,这样既有一定的隐藏能力,又提供了开放的接口。

A. 公有成员

B. 私有成员

C. 保护成员

D. 私有成员函数

82.设类A将其它类对象作为成员,则建立A类对象时,下列描述正确的是( B )。

A.A类构造函数先执行B.成员构造函数先执行

C.两者并行执行D.不能确定

83.在哪种派生方式中,派生类可以访问基类中的protected成员( B )。

A.public和private B.public和protected

C.protected和private D.仅protecte d

84. 派生类的对象可以访问以下那种情况继承的基类成员( D )。

A.私有继承的私有成员

B.公有继承的私有成员

C.私有继承的保护成员

D.公有继承的公有成员

85. 在继承中,派生类拥有的基类个数为( D )。

A.0个

B.1个

C.多个

D.至少1个

86. 基类中的protected成员,通过public派生,其在派生类中的可见性为( C )。

A.不可访问

B.private

C.protected

D.public

87.下面关于C++中类的继承与派生的说法错误的是:( C )。

A.基类的protected成员在公有派生类的成员函数中可以直接使用

B.基类的protected成员在私有派生类的成员函数中可以直接使用

C.私有派生时,基类的所有成员访问权限在派生类中保持不变

D.继承可以分为单一继承与多重继承

88. 下列关于继承的描述中,正确的是( D )。

A.继承不是类之间的一种关系

B.C++语言仅支持单一继承

C.继承会增加程序的冗余性

D.继承是面向对象方法中一个很重要的特性

89. 下列关于派生类构造函数的描述中,错误的是( A )。

A.派生类构造函数应包含直接基类和所有间接基类的构造函数

B.派生类构造函数仅包含直接基类构造函数和其他(如子对象)类构造函数等

C.派生类构造函数通常带有成员初始化表

D.派生类默认构造函数中隐含包括直接基类的默认构造函数

90. 如果一个类至少有一个纯虚函数,那么就称该类为( A )。

A.抽象类B.虚基类C.派生类D.以上都不对

二、填空题

1. 在C++中,声明布尔类型变量所用的关键字是( BOOL) 。

2. 执行下列代码

int b=100;

cout<<"Hex:"<

程序的输出结果是( Hex:64 )。

3. 执行下列代码

cout <<″Hex:″<< hex << 255;

程序的输出结果为( Hex:ff) 。

4. 执行“cout <

5. C++语言中可以实现输出一个换行符并刷新流功能的操控符是( endl )。

6. cout实际上是C++系统定义的对象名,称为(输出流对象)。

7. 若使用标准输出流把整型变量a的值输出到屏幕上,实现此操作的C++语句是

( cout<

8. C++将数据从一个对象流向另一个对象的流动抽象为“流”,从流中获取数据的操作称为

(提取) 操作。

9. 使用cin和cout进行输入输出操作的程序必须包含头文件(iostream或iostream.h),其指令格式为(#include )。

10. 若要使用C++标准类库,需要指定相应的命名空间,所用的语句是( using namespace std; )。10. C++的注释行以(//)开头。

11. 一般编译系统给出的出错信息分为两种:一种是(错误或error );

一种是(警告或warning )。

12. 转义字符?\t?在内存中占(1)个字节。

13. 将一个字符常量存放到内存单元时,实际上并不是把该字符本身放到内存单元中去,而是将该字符相应的(ASCII )代码放到存储单元中。

14. 变量必须先(定义),后(使用)。

15. 在定义变量时,如果加上关键字( const ),则变量的值在程序运行期间不能改变,这种变量称为(常)变量。

16. 数学式子00&&x<5 )。

17. 循环结构中,要提前结束本次循环的语句是(continue)。

18. 如果被调用的函数的定义出现在主调函数之后,需要对被调用的函数进行(声明)。

19. 定义内联函数所用的关键字是(inline ),定义友元所用的关键字为(friend)。

20. 重载函数的参数(个数)、参数(类型)或参数(参数顺序)三者中必须至少有一种不同。

21. 字符串的结束标志是(‘\0’)。

22. C++提供了一种用于处理字符串的数据类型,叫(字符串类型或string类型)。

23. C++语言的函数参数传递方式有传值和(传地址)两种方式。

24. C++语言中的,每条复合语句以(} )作为结束符。

25. 变量分为全局和局部两种,(局部)变量没有赋初值时,其值是不确定的。

26. C++程序必须有且只有一个主函数,其函数名为(main )。

27. 若有函数定义为:

int add(int ml=0,int m2=2,int m3=4)

{return ml+m2+m3;}

在主函数中有int s=add(1)+add(0,1)+add(0,1,2);

则执行此语句后s的值为(15)。

28. 在源程序中有宏定义:#define PI 3.14,则若不想使该宏定义影响到程序的其它地方,可以使用删除该宏定义。(#undef PI)

29. 设在程序中使用如下语句建立了一个对象数组:

Point * ptr = new Point[2];

则在需要释放ptr指向的动态数组对象时,所使用的语句是( delete[]ptr; ) 。

30. 声明一个名为a的整型引用变量所使用的语句是(int &a ; )。

31. C++支持面向对象程序设计的四个要素是:封装性、(抽象)、继承和派生和

(多态性)。

32. 在用class定义一个类时,数据成员和成员函数的默认访问权限是 ( 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. 使用( 对象引用)作为函数参数,实参对象和形参对象代表同一对象,改变形参对象的值就是改变实参对象的值。

35. C++类的构造函数名与( 类)同名,且没有返回值。

36. C++规定,当一个成员函数被调用时,系统自动向它传递一个隐含的参数,该参数是一个指向调用该函数的对象的指针,该指针被称为(this )指针。

37. 声明一个常成员函数Fun,其返回类型为char,第一个参数类型为int,第二个参数类型为double,函数Fun的声明原型是(char Fun(int ,double) const ; )。

38. 当一个成员函数被调用时,该成员函数的( this指针)指向调用它的对象。

39. 在C++中,可以在定义对象时加关键字const,指定对象为(常)对象。

40. const成员函数可以访问常对象中的数据成员,但不能(修改) 数据成员的值。

41. 一个const对象只能访问(const )成员函数。

42. 假定AB为一个类,则执行“AB a[10];”语句时,系统自动调用该类的构造函数的次数为( 10 )。

43. 类和其它数据类型不同的是,组成这种类型的不仅可以有数据,还可以有对数据进行操作的( 成员函数)。

44. 对于类Point而言,其析构函数的定义原型为(~Point() )。

45. 调用构造函数和析构函数的顺序是:先构造的(后)析构,后构造的(先)析构。

46. 拷贝构造函数使用( 引用)作为参数初始化创建中的对象。

47.运算符[ ]只能用( 成员) 函数来重载,不能用友元函数来重载。

48. C++中用于动态创建对象,并返回该对象的指针的关键字是(new )。

49. 重载赋值操作符时,运算符重载函数应声明为(成员)函数。

50. 重载的运算符仍保留原有的优先级、(结合性)和语法结构。

51. C++重载“=”运算符的函数名是(operator= )。

52. 从一个或多个以前定义的类产生新类的过程称为(派生)。

53.类的继承是指子类继承基类的( 数据成员) 和成员函数。

54. 派生类的构造函数的一般形式中,通常应包含(基类)构造函数和(派生类)构造函数。

55. 在公有继承的情况下,基类的(公用)成员和(保护)成员在派生类中的访问权限不变。

65. 派生类对基类继承方式有三种(公用的)、(保护的)、(私有的)。

57. 派生类继承的基类成员的初始化,需要由派生类的构造函数调用基类的(构造函数)来完成。

58.在保护派生中,基类权限为private的成员在派生类中( 不可访问) 。

59. 在C++类中,有一种不能定义对象的类,这样的类只能被继承,称之为( 抽象类) ,定义该类至少具有一个( 纯虚)函数。

60. 用(class virtual )声明的基类称为虚基类。

61. 用(virtual )声明的函数称为虚函数。

62.定义虚函数所用的关键字是( virtual ) 。

63. 带有纯虚函数的类称为抽象类,它只能作为(基类)来使用。

64.不同对象可以调用相同名称的函数,但可导致完全不同的行为的现象称为( 多态性) 。

65. C++语言支持两种多态性,分别是(静态多态性)和(动态多态性)。

66. 静态关联所支持的多态性称为(编译时)的多态性。

67. 动态关联要满足两个条件,它们是( 用指针或引用调用的成员函数)、( 成员函数为虚函数) 。

68. 动态关联是程序运行到需要的语句处才动态确定的,这称为(运行时)多态性。

69. 用来标识变量、符号常量、函数、数组、类型等实体名字的有效字符序列称为(标识符)。70.任何一个对象都应当具有两个要素:即(属性)和(行为)。

71.可以对一个对象进行(封装)处理,把它的一部分属性和功能对外界屏蔽,也就是说从外界是看不到的、甚至是不可知的。

72.类是对象的(抽象),而对象则是类的(具体化)。

73.一个对象所占有的存储空间大小只取决于该对象中(数据成员)所占的空间。74.C++专门设立了一个名为(this)的指针,用来指向不同的对象。

75.访问对象中的成员可以有3种方法:通过对象名和成员运算符访问、通过指向对象的指针访问、通过对象的(引用)访问。

76.通过成员函数对数据成员进行操作称为类的功能的(实现)。

77.类中被操作的数据是私有的,类的功能的实现细节对用户是隐蔽的,这种实现称为(私有实现)。78.类的(公用接口)和私有实现的分离形成了信息隐蔽。

79.运算符重载的方法是定义一个重载运算符的(函数)。

80.一个派生类只从一个基类派生,这称为(单)继承。

三、写出以下程序运行结果

1.

#include "iostream"

using namespace std;

class test

{

private:

int num;

float f1;

public:

test();

int getint(){return num;}

float getfloat(){return f1;}

~test();

};

test::test()

{ cout<<"Initalizing default."<

num=0;f1=0.0;

}

test::~test()

{ cout<<"Destructor is active."<

}

void main()

{ test array[2];

cout<

}

答:Initalizing default.

Initalizing default.

0 0

Destructor is active.

Destructor is active.

Press any key to continue

2.

#include

#include

using namespace std;

class Person

{

public:

Person(char* pN);

Person(Person& p);

~Person();

protected:

char* pName;

};

Person::Person(char* pN)

{

cout <<"Constructing " <

pName=new char[strlen(pN)+1];

if(pName!=0)

strcpy(pName, pN);

}

Person::Person(Person & p)

{

cout <<"Copying " <

if(pName!=0)

strcpy(pName, p. pName);

}

Person::~Person()

{

cout <<"Destructing " <

pName[0]='\0';

delete pName;

}

void main()

{

Person p1("Randy");

Person p2=p1; //即Person p2(p1);

}

答:Constructing Randy

Copying Randy into its own block

Destructing Randy

Destructing Randy

Press any key to continue

3.

#include

int a=5;

void main() {

int b=a+20;

int a=10;

cout<

{ int a=0,b=0;

for(int i=1; i<6; i++) {

a+=i; b+=a;

}

cout<

}

cout<

}

答:10 25

15 35

10 25

Press any key to continue

4.

#include

class Base

{

public:

virtual void fn()

{ cout <<"In Base class\n"; }

};

class SubClass :public Base

{

public:

virtual void fn()

{ cout <<"In SubClass\n"; }

};

void test(Base& b)

{ b.fn(); }

void main()

{ Base bc;

SubClass sc;

cout <<"Calling test(bc)\n";

test(bc);

cout <<"Calling test(sc)\n";

test(sc);

}

答:Calling test(bc)

In Base class

Calling test(sc)

In SubClass

Press any key to continue

5.

#include

using namespace std;

void main()

{

int num=300;

int &ref=num;

cout<

ref=ref-100;

cout<<" "<

num=num-50;

cout<<" "<

}

答:300 200 150

Press any key to continue

6.

#include < iostream.h >

class Class

{

public:

static int var;

Class()

{var++; }

};

int Class::var = 0;

void main()

{

cout <<"Class::var ="<< Class::var << endl; Class cl;

cout <<"cl. var="<

Class c2, c3 ;

cout <<"c2. var =" << c2. var <

}

答:Class::var =0

cl. var=1

c2. var =3

Press any key to continue

7.

#include

class A

{

public:

A();

void Show();

~A();

private:

static int c;

};

int A::c=0;

A::A()

{ cout << "constructor." << endl; c+=10;}

void A::Show()

{cout<<"c=" <

A::~A()

{cout <<"destructor. "<< endl;}

void main()

{ A a,b;

a.Show();

b.Show();

}

答:constructor.

constructor.

c=20

c=20

destructor.

destructor.

Press any key to continue

一、另外,熟悉以下教材内容:

1、例题

第1章:1.4包含类(Student)的C++程序(写程序运行结果)

第4章:4.9(max函数的重载)(写程序运行结果)

4.11(max函数带默认参数) (写程序运行结果)

4.12(静态局部变量)(写程序运行结果)

第5章:5.11(写程序运行结果)

第6章:6.18 交换两变量的值,引用作形参(写程序运行结果)

第8章:8.3 Time类(编程题)

第9章:9.3构造函数重载(无参和有参)(写程序运行结果)

9.4(默认参数的构造函数) (写程序运行结果)

第10章:10.2 (编程题)10.3 (编程题)10.5(写程序运算结果)

10.7 (编程题)10.8(编程题)10.10(编程题)

第11章11.5 (写程序运算结果)11.6 (写程序运算结果)

11.7(写程序运算结果)11.9(写程序运算结果)

第12章12.2 display()为非虚函数和虚函数的情况(写程序运行结果)

12.4 虚函数和抽象基类的应用(写程序运行结果)

2、课后习题

第1章:5 6 7 10 (写程序运行结果)

第6章:11 (10个字符串排序,用string数组方法做)。(写程序运行结果)第8章:6 求长方体体积。(编程题)

第9章:6(写程序运行结果)

8 对象引用作形参(编程题, 写程序运行结果)

第10章:2(编程题)3(编程题)

第11章7(写程序运算结果)8(写程序运算结果)

第12章4虚函数和抽象基类的应用(编程题) 5 虚函数和抽象基类的应用(编程题)

二、布置的任务

1设计一个三角形类,类名Triangle,数据成员:三条边a、b、c,数据类型为double。成员函数:(1)带有默认参数的构造函数,默认值分别为3、4、5;(2)计算三角形面积函数area;(3)输出函数output,输出面积。在主函数中定义2个三角形对象,利用构造函数进行初始化,一个的边长分别为3、4、5,另一个边长分别为12、18、19。输出这2个三角形的面积。

#include

#include

using namespace std;

class Triangle

{public:

Triangle (double a1=3,double b1=4,double c1=5):a(a1),b(b1),c(c1){}

void output();

double area();

private:

double a;

double b;

double c;

};

int main()

{

Triangle t1,t2(12,18,19);

t1.area();

t1.output();

t2.area();

t2.output();

return 0;

}

void Triangle::output()

{

cout<<"边长分别为:"<

}

double Triangle::area()

{

double s,result;

s=(a+b+c)/2;

result=sqrt(s*(s-a)*(s-b)*(s-c));

return result;

}

提示:三角形面积的计算公式area=sqrt(s*(s-a)*(s-b)*(s-c)),其中s为半周长,a、

b、c为边长,sqrt( )为开平方函数。

2 设计一个矩形类,类名Rectangle,数据成员:长(length)和宽(width),数据类型为float,成员函数:(1)带有默认参数的构造函数,默认值分别为8、8;(2)计算面积函数area;(3)输出函数output,输出长、宽和面积。在主函数中输出三个矩形的长、宽和面积,长和宽自己设定。

#include

using namespace std;

class Rectangle

{private:

float length;

float width;

public:

Rectangle(float l=8,float w=8):length(l),width(w){}

void output();

float area();

};

void Rectangle::output()

{

cout<<"长为:"<

}

float Rectangle::area()

{float area=length*width;

return area ;

}

int main()

{ Rectangle r1,r2(9,9);

r1.area();

r1.output();

r2.area();

r2.output();

return 0;

}

3 设计一个圆类,类名Circle,数据成员:半径r,数据类型为float,成员函数:(1)带有默认参数的构造函数,默认值为8;(2)计算面积函数area,圆周率取3.14;(3)输出函数output,输出半径和面积。在主函数中输出2个圆的半径和面积,半径分别为8和98.9。

#include

using namespace std;

class Circle

{private:

float r;

public:

Circle::Circle (float r1=8):r(r1){}

void output();

float area();

};

void Circle::output()

{

cout<<"半径为:"<

}

float Circle::area()

{float area=3.14*r*r;

return area ;

}

int main()

{ Circle c1,c2(98.9);

c1.area();

c1.output();

c2.area();

c2.output();

return 0;

}

4 设计一个销售类,类名Sale,计算某种型号笔记本电脑某天的总销售额,数据成员:(1)销售件数n,数据类型为int;(2)单价price,数据类型float;(3)总销售额sum,数据类型float。成员函数:(1)输入函数input,用于输入某天销售件数和单价,并计算某天总销售额;(2) 输出函数output,用于某天总销售额的输出。在主函数中定义1个销售对象,实现销售件数和单价的输入,并输出总销售额。

#include

using namespace std;

class Sale

{private:

int n;

float price;

float sum;

public:

void input();

void output();

};

void Sale::input()

{cout<<"请输入今天的销售件数和单价的输入(分别用空格隔开)"<

cin>>n;

cin>>price;

sum=price*n;

}

void Sale::output()

{

cout<<"今天的销售件数为:"<

}

int main()

{ Sale s1;

s1.input();

s1.output();

return 0;

}

5 设计一个工资类,类名Salary,计算某位职工的月实发工资。数据成员:(1) 工号id,数据类型为int;(2) 基本工资base、绩效工资perf、水电费cost、实发工资realgive,数据类型都为float。成员函数:(1)输入函数input,用于输入工号、基本工资、绩效工

资和水电费,并计算实发工资,实发工资为基本工资和绩效工资之和减去水电费;(2) 输出函数output,用于实发工资的输出。在主函数中定义2个工资对象,实现工号、基本工资、绩效工资和水电费的输入,并输出实发工资。

#include

using namespace std;

class Salary

{ private:

int id;

float base;

float perf;

float cost;

float realgive;

public:

void input();

void output();

};

int main()

{ Salary S1,S2;

S1.input();

S1.output();

S2.input();

S2.output();

return 0;

};

void Salary::input(){

cout<<"请输入该员工的工号基本工资绩效工资水电费"<

cin>>id>>base>>perf>>cost;

};

void Salary::output(){

realgive=base+perf-cost;

cout<<"工号为:"<

};

6 设计一个学生类,类名Student,计算某位学生某学期所有课程的平均分。数据成员:(1) 学号num,数据类型为int;(2) 数学成绩math、英语成绩english、计算机应用基础成绩computer、总分total、平均成绩ave,数据类型都是float。成员函数:(1)

输入函数input,用于输入学号、数学成绩、英语成绩、计算机应用基础成绩;(2)计算平均分的函数cave,在这个函数里面计算数据成员ave的值;(3) 输出函数output,用于平均分的输出。在主函数中定义2个学生对象,实现学号、数学成绩、英语成绩、计算机应用基础成绩的输入,并输出平均成绩。

#include

using namespace std;

class Student

{ private:

long num;

float math;

float english;

float computer;

float total;

float ave;

public:

void input();

void output();

void cave();

};

int main()

{ Student S1,S2;

S1.input();

S1.cave();

S1.output();

S2.input();

S2.cave();

S2.output();

return 0;

};

void Student::input(){

cout<<"请输入该学生的学号数学成绩英语成绩计算机应用基础成绩(分别用空格隔开) "<

cin>>num>>math>>english>>computer;

};

void Student::output(){

cout<<"学号为:"<