2007级计算机科学系_程序设计_B卷_百度文库
两大类热门资源免费畅读
续费一年阅读会员，立省24元！
2007级计算机科学系_程序设计_B卷
&&中山大学计算机程序设计试题及答案
阅读已结束，下载文档到电脑
想免费下载更多文档？
定制HR最喜欢的简历
下载文档到电脑，方便使用
还剩3页未读，继续阅读
定制HR最喜欢的简历
你可能喜欢扫二维码下载作业帮
拍照搜题，秒出答案，一键查看所有搜题记录
下载作业帮安装包
扫二维码下载作业帮
拍照搜题，秒出答案，一键查看所有搜题记录
这两篇英语作文有没有语法错误?如有,请改正.1、 Spring Festival isa very important festival for all chinese people.Before the festival,my family are very busy.They clean the house and go shopping for food.And my parents go to the Flowers Fairs to buy fresh flowers for decorate house.In the evening before the spring Festival,my famliy usually have a big meal.After the meal,we often watch TV.2、we had a camping holiday last summer.We cilmbed the mountains and it so interesting.And we played badminton.Then I rided the little bike in the road.I think this camping is so interesting.We were happy on camping holiday last summer.
扫二维码下载作业帮
拍照搜题，秒出答案，一键查看所有搜题记录
Spring Festival is a very important festival for all Chinese people.Before the festival,my family are very busy.They clean the house and go shopping for food.And my parents go to the Flowers Fairs to buy fresh flowers for decorate house.In the evening before the spring Festival,my family usually have a big meal.After the meal,we often watch TV.We had a camping holiday last summer.We climbed the mountains.They are so interesting.Then we played badminton.Then I ride the little bike in the road.I think this camping is so interesting.
为您推荐：
其他类似问题
扫描下载二维码房地产估价师考试备战已经开始，为了方便考生进行全面备考,小编特别对房估考生如何进行报考、备考提出了建议，并对重点预习知识、考试大纲与笔记画重点。房地产估价师职业前景可是大好，做好考试准备，事半功倍。
在此可输入您对该资料的评论~
(window.slotbydup = window.slotbydup || []).push({
id: '4540180',
container: s,
size: '250,200',
display: 'inlay-fix'
热门资料排行
添加成功至
资料评价：
所需积分：1面向对象程序设计语言重点难点复习题 模拟自测题及答案(源自网络)-共享资料网
面向对象程序设计语言重点难点复习题 模拟自测题及答案(源自网络)
提示：1、本练习题、试题集全部来自网上共享资源，包括 C++面向过程和面向对象的相关内容， 今下载整理仅为便于复习、练习，请有选择地阅读； 2、请同学们做练习题时先独立思考，再参考答案；附后有几套模拟试题，全部来自网上其 他院校的期末试卷，供同学们模拟自测。 3、试题量大，难免会有错误，请慎重选用、思考。1、数据共享与保护一、选择题：1、在下面存储类中， ( C A. 外部类 B. 2、在下面存储类中，（ A A. 外部静态类 B. ) 对象的可见性与生存期不一致。 自动类 C. 内部静态类 D. 寄存器类 ）的对象不是局部变量。 自动类 C. 函数形参 D. 寄存器类3、关于局部变量，下面说法正确的是( C )。 A. 定义该变量的程序文件中的函数都可以访问 B. 定义该变量的函数中的定义处以下的任何语句都可以访问 C. 定义该变量的复合语句中的定义处以下的任何语句都可以访问 D. 定义该变量的函数中的定义处以上的任何语句都可以访问4、一个类的静态数据成员所表示属性 ( C A. 是类的或对象的属性 C. 只是类的属性 5、类的静态成员的访问控制（ D ）。A. B. C. D.)。 B. 只是对象的属性 D. 类和友元的属性只允许被定义为 private 只允许被定义为 private 或 protected 只允许被定义为 public 可允许被定义为 private、protected 或 public6、静态成员函数对类的数据成员访问（ B ）。 A. 是不允许的 B. 只允许是静态数据成员 C. 只允许是非静态数据成员 D. 可允许是静态数据成员或非静 态数据成员 7、被非静态成员函数访问的类的数据成员( A )。 A. 可以是非静态数据成员或静态数据成员 B. 不可能是类的静态 数据成员 C. 只能是类的非静态数据成员 D. 只能是类的静态数 据成员 8、静态数据成员的初始化是在（ D ）中进行的。A. 构造函数 B. 任何成员函数 C. 所属类 D. 全局区 9、 当将一个类 A 或函数 f()说明为另一个类 B 的友元后，类 A 或函数 f()能够直 接访问类 B 的（ D ）。 A. 只能是公有成员 B. 只能是保护成员 C. 只能是除私有成员之外的任何成员 D. 具有任何权限的成员 10、引入友元的主要目的是为了（ C ）。 A. 增强数据安全性 B. 提高程序的可靠性 C. 提高程序的效率和灵活性 D. 保证类的封装性 11、 一个类的成员函数也可以成为另一个类的友元函数，这时的友元说明 （ A ）。 A. 需加上类域的限定 B. 不需加上类域的限定 C. 类域的限定可加可不加 D. 不需要任何限定二、判断题1、类的静态数据成员需要在定义每个类的对象时进行初始化。F 2、当将一个类 S 定义为另一个类 A 的友元类时，类 S 的所有成员函数都可以直 接访问类 A 的所有成员。T3、静态数据成员必须在类外定义和初始化。T 4、静态成员函数可以引用属于该类的任何函数成员 F。 5、友元函数是在类声明中由关键字 friend 修饰说明的类的成员函数。F 6、友元函数访问对象中的成员可以不通过对象名 F三、填空题：1、若“double x=100;”是文件 F1.CPP 中的一个全局变量定义语句，若文 件 F2.CPP 中的某个函数需要访问此 x , 则应在文件 F2.CPP 中添加对 x 的声明 语句为 E 2、 如果一个函数定义中使用了 static 修饰，则该函数不允许被其它文件中的函 数调用。 3、定义外部变量时，不用存储类说明符 Extern，而声明外部变量时用它。 4、调用系统函数时，要先使用#include 命令包含该系统函数的原型语句所 在的头文件。 5、C++程序运行时的内存空间可以分成全局数据区，堆区，栈区和代码区。 6、局部变量具有局部生存期，存放在内存的栈区中。 7、对类中对象成员的初始化是通过在构造函数中给出的初始化表来实现的。 8、对类中常量成员的初始化是通过在构造函数中给出的初始化表来实现的。 9、对类中引用成员的初始化只能通过在构造函数中给出的初始化表来实现。 10、对类中一般数据成员的初始化既可以通过在构造函数中给出的初始化表 来实现，也可以通过构造函数中的函数体来实现。 11、假定要把 aa 定义为 AB 类中的一个常量整数型数据成员，则定义语句 const int aa。12、假定要把 aa 定义为 AB 类中的一个引用整数型数据成员，则定义语句为 int &aa。 13、假定 AB 类中只包含一个整型数据成员 a，并且它是一个常量成员，若利 用参数 aa 对其进行初始化，则该类的构造函数的定义为 AB (int aa){a=aa；}。 14、假定 AB 类中只包含一个整型数据成员 a，并且它是一个引用成员，若利 用 引 用 参 数 aa 对 其 进 行 初 始 化 ， 则 该 类 的 构 造 函 数 的 定 义 为 AB(int &aa){a=aa；}。 15、静态成员函数能够直接访问类的静态数据成员，只能通过对象名访问类 的非静态数据成员。 16、静态数据成员必须在所有函数的定义体外进行初始化。 17、 一个类的成员函数也可以成为另一个类的友元函数，这时的友元说明必须 在函数名前加上类域的限定。四、修改程序题：下列程序段中，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() { A_class A_obj(3,5); cout&&&Result:&&&A_obj.Variance()&&} 修改后的源程序：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(); //其它函数从略 }; int variance (){ return x*x-y*y;} void main() { A_class A_obj(3,5); cout&&&Result:&&&A_obj.Variance()&&2、数组、指针与字符串一、选择题：1、在下面的一维数组定义中，哪一个有语法错误。（ C ） A. int a[]={1,2,3}; B. int a[10]={0}; C. int a[]; D. int a[5]; 2、在下面的字符数组定义中，哪一个有语法错误。（ D ）。 A. char a[20]=”abcdefg”; B. char a[]=”x+y=55.”; C. char a[15]; D. char a[10]=’5’; 3、在下面的二维数组定义中，正确的是( C )。 A. int a[5][]; B. int a[][5]; C. int a[][3]={{1,3,5},{2}}; D. int a[](10); 4、假定一个二维数组的定义语句为“int a[3][4]={{3,4},{2,8,6}};”，则元 素 a[1][2]的值为（ C ）。 A. 2 B. 4 C. 6 D. 8 5、假定一个二维数组的定义语句为“int a[3][4]={{3,4},{2,8,6}};”，则元 素 a[2][1]的值为（ A ）。 A. 0 B. 4 C. 8 D. 6 6、 若定义了函数 double *function(), 则函数 function 的返回值为 （ B ） 。 A. 实数型 B.实数的地址 C.指向函数的指针 D.函数的地址 7、以下函数的返回结果是（ A ）。 int function(char *x) { char *p=x; while(*p++); return(p-x-1); } A. 求字符串的长度 B.将字符串 x 连接到字符串 p 后面 C. 将字符串 x 复制到字符串 p 中 D.将字符串 x 反向存放 8、设有如下函数定义 int f(char *s) { char *p=s; while(*p!=’\0’) p++; return(p-s); } 在主函数中用 cout&&f(“good”)调用上述函数, 则输出结果为（ B ）。A. 3 B. 4 C. 5 D. 6 9、假定变量 m 定义为“int m=7;”，则定义变量 p 的正确语句为（ B ）。 A. int p=&m; B. int *p=&m; C. int &p=*m; D. int *p=m; 10、变量 s 的定义为“char *s=”Hello world!”;”，要使变量 p 指向 s 所指 向的同一个字符串，则应选取（ A ）。 A. char *p=s; B. char *p=&s; C. char *p;p=*s; D. char *p; p=&s 11、关于 void 指针，下列说法正确的是（ C ）。 A. void 指针就是未指向任何数据的指针 B. void 指针就是已定义而未初始化的指针 C. 指向任何类型数据的指针可直接赋值给一个 void 指针 D. void 指针值可直接赋给一个非 void 指针 12、假定一条定义语句为“int a[10], x, *pa=a;”，若要把数组 a 中下标为 3 的元素值赋给 x，则不正确的语句为（ D ）。 A. x=pa[3]; B. x=*(a+3); C. x=a[3]; D. x=*pa+3; 13、假定有定义“int b[10]; int *”，则不正确的赋值语句为（ D ）。 A. pb=b; B. pb=&b[0]; C. *pb= D. pb=b[5]; 14、假定 p 是具有 double 类型的指针变量，则表达式++p 使 p 的值（以字节为 单位）增加（ C ）。 A. 1 B. 4 C. sizeof(double) D. sizeof(p) 15、假定 p 指向的字符串为”string”，则 cout&&p+3 的输出结果为（ C ）。 A. string B. ring C. ing D. i 16、假定 p 指向的字符串为”string”，若要输出这个字符串的地址值，则使用 （ D ）。 A. cout&&*s; B. cout&&s; C. cout&&&s; D. cout&&(void *)s; 17、定义 p 并使 p 指向动态空间中的包含 30 个整数的数组所使用的定义语句为 （ A ）。 A. int *p=new int[30]; B. int *p=new int(30); C. int *p=new [30]; D. *p=new int[30]; 18、假定 p 是具有 int**类型的指针变量，则给 p 赋值的正确语句为（ B ）。 A. p= B. p=new int*; C. p=new int**; D. p=new int[10]; 19、 要使语句 “p=new int[10][20];” 能够正常执行， 应被事先定义为 p （ D ） 。 A. int *p; B. int **p; C. int *p[20]; D. int(*p)[20]; 20、假定变量 a 和 pa 定义为“double a[10], *pa=a;”，要将 12.35 赋值给 a 中的下标为 5 的元素，不正确的语句是（ D ）。 A. pa[5]=12.35; B. a[5]=12.35; C. *(pa+5)=12.35; D. *(a[0]+5)=12.35; 21、假定变量 b 和 pb 定义为“int b[10], *pb=b;”，要将 24 赋值给 b[1]元素 中，不正确的语句是（ C ）。 A. *(pb+1)=24; B. *(b+1)=24; C. *++b=24; D. *++pb=24;22、假定指针变量 p 定义为“int *p=new int(100);”，要释放 p 所指向的动态 内存，应使用语句（ A ）。 A. B. delete *p; C. delete &p; D. delete []p; 23、假定指针变量 p 定义为“int *p=new int[30];”，要释放 p 所指向的动态 内存，应使用语句（ D ）。 A. B. delete *p; C. delete &p; D. delete []p; 24、 当类中一个字符指针成员指向具有 n 个字节的存储空间时，它所能存储字符 串的最大长度为( C )。 A. n B. n+1 C. n-1 D. n-2 25、在一个用链表实现的队列类中，假定每个结点包含的值域用 elem 表示，包 含的指针域用 next 表示，链队的队首指针用 elemHead 表示，队尾指针用 elemTail 表示，若链队非空，则进行插入时必须把新结点的地址赋给( D )。 A. elemHead B. elemTail C. elemHead-&next 和 elemHead D. elemTail-&next 和 elemTail 26、在一个用链表实现的队列类中，假定每个结点包含的值域用 elem 表示，包 含的指针域用 next 表示，链队的队首指针用 elemHead 表示，队尾指针用 elemTail 表示，若链队为空，则进行插入时必须把新结点的地址赋给( C )。 A. elemHead B. elemTail C. elemHead 和 elemTail D. elemHead 或 elemTail 27、当类中的一个整型指针成员指向一块具有 n*sizeof(int)大小的存储空间 时，它最多能够存储( A )个整数。 A. n B. n+1 C. n-1 D. 1 28、假定 AB 为一个类，则执行 “AB *px=new AB[n];”语句时将( A )。 A. 动态分配一个数组 B. 动态分配一个对象 C. 静态分配一个数组 D. 静态分配一个对象 29、设 px 是指向一个类对象的指针变量，则执行 “”语句时，将自 动调用该类的( C )。 A. 无参构造函数 B. 带参构造函数 C. 析构函数 D. 拷贝 构造函数 30、当一个类对象离开它的作用域时，系统自动调用该类的( D )。 A. 无参构造函数 B. 带参构造函数 C. 拷贝构造函数 D. 析 构函数 31、假定一个类对象数组为 A[n]，当离开它定义的作用域时，系统自动调用该 类析构函数的次数为( C )。 A. 0 B. 1 C. n D. n-1 32、假定 AB 为一个类，则执行 “AB a[10];”语句时调用该类无参构造函数的 次数为( D )。 A. 0 B. 1 C. 9 D. 10 33、假定 AB 为一个类，则执行 “AB *px=new AB[n];”语句时调用该类无参构 造函数的次数为( A )。 A. n B. n-1 C. 1 D. 034、假定 AB 为一个类，则执行 “AB a, b(3), *p;”语句时共调用该类构造函 数的次数为( A )。 A. 2 B. 3 C. 4 D. 5 35、假定 AB 为一个类，则执行 “AB a(2), b[3], *p[4];”语句时共调用该类 构造函数的次数为( B )。 A. 3 B. 4 C. 5 D. 9 36、假定 AB 为一个类，则执行“AB a, b(2), c[3], *p=&a;”语句时共调用该 类无参构造函数的次数为( D ) A. 5 B. 6 C. 3 D. 4 37、假定 AB 为一个类，则执行“AB *p=new AB(1,2);”语句时共调用该类构造 函数的次数为( B )。 A. 0 B. 1 C. 2 D. 3 38、假定 AB 为一个类，px 为指向该类的一个含有 n 个对象的动态数组的指针， 则执行“delete []”语句时共调用该类析构函数的次数为( C )。 A. 0 B. 1 C. n D. n+1二、填空题：1、用于存储一个长度为 n 的字符串的字符数组的长度至少为_n+1_______。 2、若 a 是一个字符数组，则从键盘上向该数组输入一个字符串的表达式为 _getline(cin,a);_________。 3、若 a 是一个字符数组，则向屏幕输出 a 中所存字符串的表达式为 _cout&&a_______。 4、 一个二维字符数组 a[10][20]能够存储__10______个字符串，每个字符串 的长度至多为__19______。 5、对一个二维字符数组 a 进行初始化的数据为{”123”,”456”,”789”}， 则 a[1]元素对应的字符串为__”456”________。 6、 strlen(” apple” )的值为__5______， strcmp(” ,” )的值为_1_______。 a” A” 7、假定对数组 a[]进行初始化的数据为{2,7,9,6,5,7,10}，则 a[2]和 a[5] 分别被初始化为__9______和___7_____。 8、假定对二维数组 a[3][4]进行初始化的数据为{{3,5,6},{2,8},{7}}，则 a[1][1]和 a[2][3]分别被初始化为___8____和___0_____。 9、若二维数组 a 有 m 列，设 a[0][0]位于数组的第一个位置上，则计算任一 元素 a[i][j]在数组中位置序号的公式为_i*m+j+1__________。 10、 若有定义“double a[3][5];”，则 a 数组中行下标和列下标的最大值分别 为___2_____和___4_____。 11、一个指针类型的对象占用内存的___4_____个字节的存储空间。 12、 一个指针指向一个数据对象，它保存着该数据对象的_地址_______，若 数据对象为 DataType 类型，则相应的指针类型为___Datatype*_______。 13、 若要把一个整型指针 p 转换为字符指针，则采用的强制转换表达式为 _(char*)p_______。 14、假定一个数据对象为 int*类型，则指向该对象的指针类型为 _int**______。 15、假定 p 是一个指向整数对象的指针，则用__*P______表示该整数对象， 用_____P___表示指针变量 p 的地址。 16、假定 p 是一个指针， 则*p++运算首先访问__*p____， 然后使 p_的值增 1。 17、假定 p 是一个指针，则(*p)++运算首先访问_*p__，然后使__*p______ 的值增 1。 18、 假定 p 所指对象的值为 25，p+1 所指对象的值为 42，则*p++的值为 __25______。 19、假定 p 所指对象的值为 25，p+1 所指对象的值为 42，则*++p 的值为 _42_______。 20、假定 p 所指对象的值为 25，p+1 所指对象的值为 42，则执行(*p)++运算 后，p 所指对象的值为___26_____。 21、 假定 p 所指对象的值为 25， 所指对象的值为 42， p+1 则执行*(p++)或*p++ 运算后，p 所指对象的值为___42_____。 22、 假定 a 是一个一维指针数组， a+i 所指对象的地址比 a 大__4*i______ 则 字节。 23、 假定 a 是一个一维数组，则 a[i]的指针访问方式为__*（a+i）______。 24、假定 a 是一个一维数组，则 a[i]对应的存储地址（以字节为单位）为 __a+i*sizeof(a[i])__________。 25、 一个数组的数组名实际上是指向该数组____首____元素的指针，并且在 任何时候都不允许_ ___修改____它。 26、假定指向一维数组 b[10]中元素 b[4]的指针为 p，则 p+3 所指向的元素 为__b[7]_____，p-2 所指向的元素为_b[2]_______。 27 、 若 要 定 义 整 型 指 针 p 并 初 始 指 向 x ， 则 所 使 用 的 定 义 语 句 为 _int*p=&x_______。 28、 若 p 指向 x，则___*p_____与 x 的表示是等价的。 29、在一个二维数组 int a[m][n]中，包含的一维元素 a[i]的类型为__ int[n]______，访问 a[i]时返回值的类型为__ int*______。 30、 假定一个二维数组为 c[5][8]， c[3]的值为二维元素 c[3][0]________ 则 的地址，c[3]+2 的值为二维元素_c[3][2]_______的地址。 31、假定 p 为指向二维数组 int d[4][6]的指针，则 p 的类型为_int (*） [6]______。 32、假定 a 是一个二维数组，则 a[i][j]的指针访问方式为__*（*（a+i）+j） __________。 33、 执行 int p=new int 操作得到的一个动态分配的整型对象为__*p______。 34、执行 int *p=new int[10]操作，使 p 指向动态分配的数组中下标为 0 的 元素，该元素可表示为_*p______或__p[0]______。 35、 执行 char *p=new char(’a’)操作后，p 所指向的数据对象的值为 __a______。 36、 执行 new char[m][n]操作时的返回值的类型为__char(*)[n]______。 37、执行_delete_p______操作将释放由 p 所指向的动态分配的数据空间。 38、执行_delete[]p_______操作将释放由 p 所指向的动态分配的数组空间。 39、 NULL 是一个符号常量，通常作为空指针值，它的具体值为___0_____。 40、变量 v 定义为“double v=23.4;”，要使指针 pv 指向 v，则定义 pv 的语句为___double *pv=&v___________。 41、 已知语句“cout&&p;”的输出是“Hello!”，则语句“cout&&*p;”输 出的是__H________。 42、. 已知语句“cout&&s;”的输出是“apple”，则执行语句“cout&&s+2;” 的输出结果为__ple________。 43、指针变量 pv 和 pc 定义为 “void *pv =” Hello, word!” char *” ; ， 要 将 pv 值 赋 给 pc ， 则 正 确 的 赋 值 语 句 是 _ strcpy （ pc ， pv ） ； pc=char(*)pv______________。 44、 数组 b 定义为“int b[20][100];”，要使 p[j][k] 与 b[j][k] 等效， 则指针 p 应定义为__int (*p)[100]=b ______________。 45 、 与 结 构 成 员 访 问 表 达 式 p-&name 等 价 的 表 达 式 是 __(*p).name__________。 46 、 与 结 构 成 员 访 问 表 达 式 (*fp).score 等 价 的 表 达 式 是 __fp-&score__________。 47、已知有定义“int x, a[]={5,7,9}, *pa=a;”，在执行“x=++*”语 句后，x 的值是____6____。 48、已知有定义“int x, a[]={6,10,12}, *pa=a;”，在执行“x=*++” 语句后，*pa 的值是_10_______。 49、已知有定义“int x, a[]={15,17,19}, *pa=a;”，在执行“x=*pa++;” 后，*pa 的值是__17______。 50、若采用 p-&abc(y)表达式调用一个成员函数，在成员函数中使用的 __this_就代表了类外的 p 指针。 51、在一个用数组实现的队列类中，包含有两个数据成员，一个指明队首元 素位置，另一个指明___队列长度_________。 52、在一个用数组实现的队列类中，包含有两个数据成员，一个指明队列长 度，另一个指明___队首_______元素的位置。 53、在一个用数组实现的队列类中，假定数组长度为 MS，队首元素位置为 first ， 队 列 长 度 为 length ， 则 插 入 一 个 新 元 素 的 位 置 为 ___(first+length)MS_______。 54、 在一个用数组实现的队列类中， 假定数组长度为 MS， 队首元素位置为 first， 队列长度为 length， 则删除一个元素后队首的位置为__ （first+1） ________。 MS 55、定义类动态对象数组时，其元素只能靠自动调用该类的__无参构造函数 __________来进行初始化。 56、为了释放类对象中指针成员所指向的动态存储空间，则需要为该类定义 ____析构函数________。 57、假定 AB 为一个类，则执行“AB a[10];”语句时，系统自动调用该类构 造函数的次数为__10______。 58、假定一个类对象数组为 A[N]，当离开它的作用域时，系统自动调用该类 析构函数的次数为_N_______。 60、假定指针 p 指向一个动态分配的类对象，则当执行“”语句 时，在释放 p 所指向的动态存储空间之前将自动调用该类的 ___析构函数 _________。 61、假定 AB 为一个类，该类中含有一个指向动态数组空间的指针成员 pa， 则在该类的析构函数中应该包含有一条__delete[]____________语句。三、程序填空题：1、采用指针访问方式从键盘给数组 a[N]输入数据，然后对元素值重新按逆序存 放并输出。 #include &iostream.h& const int N=8; void main() { int a[N],*p,*q; for(p=a; p&a+N; p++) cin&&*p; p=a;q=a+N-1; while(p&q) { int r=*p; *p=*q; *q=r; p++; q++; } for(p=a;p&a+N; p++) cout&&*p&&' '; cout&& } 1、 (1) cin&&*p (2) p++ (或++p) (3) q-- (或--q) 2、 假定有定义为 “struct NODE{ NODE*};” 下面算法根据 table ， 数组中的 n 个元素建立一个表头指针为 L 的链表， 链表中结点值的顺序与数组元 素值的顺序正好相反。 void f6(NODE*& L, int table[], int n) {L=NULL; if(n&=0) int i=0; NODE* while(__ (1)___) { p=new NODE; p-&data=__ _(2)___; p-&next=L; ___(3)___; i++; } }2、(1) i&n(2) table[i](3) L=p3、 已知一维数组类 ARRAY 的定义如下， 构造函数的作用是把参数 n 的值赋给 s，给 v 动态分配长度为 n 的数组空间， 接着利用数组参数 a 初始化 v 所指向的数组。 class ARRAY{ int *v; //指向存放数组数据的空间 //数组大小 public: ARRAY(int a[], int n); ~ ARRAY(){delete []v;} int size(){} int& operator[](int n); }; ___(1)___ ARRAY(int a[], int n) { if(n&=0) {v=NULL;s=0;} s=n; v=__ (2)___; for(int i=0; i&n; i++) _ _(3)___; } 3、 (1) ARRAY:: (2) new int[n] (3) v[i]=a[i]4、下面是一维数组类 ARRAY 的定义，ARRAY 与普通一维数组区别是：(a)用()而 不是[]进行下标访问，(2)下标从 1 而不是从 0 开始， (c)要对下标是否越界进行 检查。 class { int *v; //指向存放数组数据的空间 //数组大小 public: ARRAY(int a[], int n); ~ ARRAY(){delete []v;} int size(){} int& operator()(int n); }; ___(1)___ operator()(int n) { // ()的运算符函数定义 if(___(2)___) {cerr&&&下标越界！&; exit(1);} return ___(3)___; } 4、(1) int& ARRAY:: (2) n&1 || n&s 5、已知一个类的定义如下： #include&iostream.h& class AA { int a[10]; (3) v[n-1] (或*(v+n-1))
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 个元素 }; 该类中 MaxA()函数的实现如下，请在标号位置补充适当的内容。 int _ __(1)_____ { int x=a[0]; for(int i=1; i&n; i++) if(a[i]&x) _ _(2)___; ___(3) ___; } 5、(1) AA::MaxA() (2) x=a[i] (3) return x6、已知一个类的定义如下： #include&iostream.h& class AA { int a[10]; 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 个元素 }; void AA::SortA() { int i,j; for(i=0; _ __(1)___; i++) { int x=a[i], k=i;for(j=i+1; j&n; j++) if(a[j]&x) __ _(2)___ a[k]=a[i]; ___(3)___; } } 6、(1) i&n-1 (或 i&=n-2) (b) {x=a[j]; k=j;} (c) a[i]=x 7、已知一个类的定义如下： #include&iostream.h& class AA { int a[10]; 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 个元素 }; void ___(1)___ { int i,j; for(i=1; i&n; i++) { int x=a[i]; for(j=i-1; j&=0; j--) if(x&a[j]) __(2)___; else ___(3)___; a[j+1]=x; } } 7、(1) AA::InsertA() (2) a[j+1]=a[j] (3) break8、已知一个类的定义如下： #include&iostream.h& class AA { int a[10]; 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 个元素 //最后输出一个换行 }; 使用该类的主函数如下： void main() { int a[10]={23,78,46,55,62,76,90,25,38,42}; AA _ __(1)___; int m=___(2)___; ___(3)___; cout&&m&& } 该程序运行结果为: 23 78 46 55 62 76 78 8、(1) x.SetA(a,6) (2) x.MaxA() (3) x.PrintA() 9、已知一个类的定义如下： #include&iostream.h& class AA {`` int a[10]; public: void SetA(int aa[], int nn); //用数组 aa 初始化数据成员 a， //用 nn 初始化数据成员 n int MaxA(); //从数组 a 中前 n 个元素中查找最大值 void SortA(); //采用选择排序的方法对数组 a 中前 n 个元素 //进行从小到大排序 void PrintA(); //依次输出数组 a 中的前 n 个元素， //最后输出一个换行 }; 使用该类的主函数如下： void main() { int a[10]={23,78,46,55,62,76,90,25,38,42};__ _(1)___; x.SetA(a,8); int ___(2)___; ___(3)___; x.PrintA(); cout&&m&& } 该程序运行结果为: 23 25 46 55 62 76 78 90 90 9、(1) AA x (2) m=x.MaxA() (3) x.SortA()10、class A { public: A() {a=0;} ___(1)___{} //定义构造函数，用参数 aa 初始化数据成员 a }; main() { ___(2)___; //定义类 A 的指针对象 p ___(3)__; //用 p 指向动态对象并初始化为整数 5 } 10、 答案：(1) A(int aa):a(aa) (2) A *p 11、class A { char *a; public: ___(1)___ //定义无参构造函数，使 a 的值为空 A(char *aa) { a=___(2)___; strcpy(a,aa); //用 aa 所指字符串初始化 a 所指向的动态存储空间 } __ _(3)___ //定义析构函数，删除 a 所指向的动态存储空间 }; (3) p=new A(5) 11、 答案：(1) A() {a=0;} 或 A():a(0){} (2) new char[strlen(aa)+1] (3) ~A() {delete []a;} 12、class A { int a,b;注：数据 0 可用 NULL 代替public: A(int aa=0, int bb=0) ___(1)___ {} //分别用 aa 和 bb 对应初始化 a 和b }; main() { ___(2)___ ; 始化 ___(3)___ ; } 12、//定义类 A 的对象 x 并用 5 初始化，同时定义 y 并用 x 初 //定义 p 指针，使之指向对象 x答案：(1) :a(aa),b(bb) (2) A x(5),y(x) 注：x(5)与 x=5 等效，y(x) 与 y=x 等效 (3) A *p=&x 13、class A { int a,b; public: ___(1)___ //定义构造函数，使参数 aa 和 bb 的默认值为 0， //在函数体中用 aa 初始化 a，用 bb 初始化 b }; main() { A *p1, *p2; ___(2)___ ; //调用无参构造函数生成由 p1 指向的动态对象 ___(3)___ ; //调用带参构造函数生成由 p2 指向的动态对象， //使 a 和 b 成员分别被初始化为 4 和 5 } 13、 答案：(1) A(int aa=0, int bb=0){a= b=} (2) p1=new A (3) p2= new A(4,5) 14、 一种类定义如下: class Goods { private: char gd_name[20]; //商品名称 //商品重量 st //同类商品总重量 public: Goods (char*str,int w){ //构造函数 strcpy(gd_name,str); weight=w; totalweight+= } ~ Goods (){totalweight -=}char* GetN(){___(1)___;} //返回商品名称 int GetW(){} __(2)___ GetTotal_Weight() { //定义静态成员函数返回总重量 ___(3)___; } } 14、(1) return gd_name (2) static int (3) return totalweight四、阅读程序题：1、 #include&iostream.h& #include&string.h& void main() {char a[5][10]={&student&,&worker&,&soldier&,&cadre&,&peasant&}; char s1[10], s2[10]; strcpy(s1,a[0]); strcpy(s2,a[0]); for(int i=1;i&5;i++) { if(strcmp(a[i], s1)&0) strcpy(s1,a[i]); if(strcmp(a[i], s2)&0) strcpy(s2,a[i]); } cout&&s1&&’ ’&&s2&& }2、 #include&iostream.h& #include&string.h& class CD { char* public: void Init(char* aa, int bb) { a=new char[strlen(aa)+1]; strcpy(a,aa); b= } char* Geta() {} int Getb() {} void Output() {cout&&a&&' '&&b&&} } void main(){ CD dx.Init(&abcdef&,30); dy.Init(&shenyafen&,3*dx.Getb()+5); dx.Output(); dy.Output(); } abcdef 30 shenyafen 953、#include&iostream.h& #include&string.h& class CD { char* public: void Init(char* aa, int bb) { a=new char[strlen(aa)+1]; strcpy(a,aa); b= } char* Geta() {} int Getb() {} void Output() {cout&&a&&' '&&b&&} }; void main() { CD dx, char a[20]; dx.Init(&abcdef&,30); strcpy(a,dx.Geta()); strcat(a,&xyz&); dy.Init(a,dx.Getb()+20); dx.Output(); dy.Output(); } abcdef 30 abcdefxyz 50 4、 #include&iostream.h&#include&string.h& class A { char *a; public: A(char *s) { a=new char[strlen(s)+1]; strcpy(a,s); cout&&a&& } ~A() { delete []a; cout&&&Destructor!&&& } }; void main() { A x(&xuxiaokai&); A *y=new A(&weirong&); } xuxiaokai weirong Destructor! Destructor!5、 #include&iostream.h& class A { public: A(int aa=0): a(aa) {cout&&a&&' ';} ~A() {cout&&&Xxk&;} }; void main() { A *p; A x[3]={1,2,3},y=4; cout&& p=new A[3]; cout&& delete []p; cout&&} 1 2 3 4 0 0 0 XxkXxkXxk XxkXxkXxkXxk五、程序改错1. 在下面的定义中，NODE 是链表结点的结构，appendToList 则是一函数，其功能是： 在 list 所指向的链表的末尾添加一个新的值为 x 的结点，并返回表头指针。函数中有两处错 误，指出错误所在行的行号并提出改正意见。 struct NODE{ NODE * };NODE* appendToList(NODE *list, int x){ NODE *p= p-&data=x; p-&next=NULL; if(list==NULL) NODE *p1= while(p1-&next!=NULL) p1=p1-& 表尾 p1=p; 向新添加的结点 } }//1 行 //2 行 //3 行 //4 行 //5 行 //6 行 //7 行，链表非空先找到 //8 行，让原表尾指针指错误行的行号为__2____和___8_____。 分别改正为 NODE *p=new NODE;和_strcpy(p1,p)__ p1-&next=p; ___________。 2、 假定要求下面程序输出结果为“d=800,f=60” ，在第 4-23 行中存在着三条语 句错误，请指出错误语句的行号并改正。 #include&iostream.h& class A { //1 行 int a[10]; //2 行 public: //3 行 A(int aa[], int nn): n(nn) { //4 行 for(int i=0; i&n; i++) aa[i]=a[i]; //5 行 } //6 行 int Get(int i) {return a[i];} //7 行int SumA(int n); }; int A::SumA(int n) { int s=0; for(int j=0; j&n; j++) s+=a[j]; } void main() { int a[]={2,5,8,10,15,20}; A x(a,6); int d=1; for(int i=0; i&4; i++) d*=x.a[i]; int f=SumA(6); cout&&&d=&&&d&&’,’; cout&&&f=&&&f&& }//8 行 //9 行 //10 行 //11 行 //12 行 //13 行 //14 行 //15 行 //16 行 //17 行 //18 行 //19 行 //20 行 //21 行 //22 行 //23 行错误行的行号为___5___、___19_____和__20______。 分别改正为_a[i]=aa[i]___________________、___ d*=x.Get(i);____________ 和___ int f=x.SumA(6)________________。六、程序设计1、根据下面类中 Count 函数成员的原型和注释写出它的类外定义。 class AA { int* int MS; public:void InitAA(int aa[], int nn, int ms) { if(nn&ms) {cout&&&Error!&&& exit(1);} MS= n= a=new int[MS]; for(int i=0; i&MS; i++) a[i]=aa[i]; } int Count(int x); //从数组 a 的前 n 个元素中统计出其 //值等于 x 的个数并返回。 }; int AA::count( int x){ int sum=0; for(int i=0; i&MS; i++){If(a[i]==x) Sum++;} } 1、 int AA::Count(int x) { int i,c=0; for(i=0; i&n;i++) if(a[i]==x) c++; }2、根据下面类中 Search 函数成员的原型和注释写出它的类外定义。 class AA { int* int MS; public: void InitAA(int aa[], int nn, int ms) { if(nn&ms) {cout&&&Error!&&& exit(1);} MS= n= a=new int[MS]; for(int i=0; i&MS; i++) a[i]=aa[i]; } int Search(int x); //从数组 a 的前 n 个元素中顺序查找值为 x 的元素， //若查找成功则返回元素的下标，否则返回-1。 }; int AA:: Search ( int x){ for(int i=0; i&MS; i++){ If(a[i]==x) } if(i&=MS) return -1； } 2、 int AA::Search(int x){ for(i=0; i&n;i++) if(a[i]==x) return -1; } 3、 根据下面类中 MaxMin 函数成员的原型和注释写出它的类外定义。 class AA { int* int MS; public: void InitAA(int aa[], int nn, int ms) { if(nn&ms) {cout&&&Error!&&& exit(1);} MS= n= a=new int[MS]; for(int i=0; i&MS; i++) a[i]=aa[i]; } int MaxMin(int& x, int& y); //从数组 a 的前 n 个元素中求出 //最大值和最小值，并分别由引用参数 x 和 y 带回， //同时若 n 大于 0 则返回 1，否则返回 0。 }; void MaxMin(int &x,int &y) { int x=a[0],y=a[0]; for(int i=1; i&n; i++){ if(a[i]&x) x=a[i]; if(a[i]&y) y=a[i]; } if(n&0) return 1; return 0; } 3、 int AA::Compare(AA b) { if(n!=b.n) return 0;for(int i=0; i&n; i++) if(a[i]!=b.a[i]) return 0; return 1; }4、根据下面类中 Compare 函数成员的原型和注释写出它的类外定义。 class AA { int* int MS; public: void InitAA(int aa[], int nn, int ms) { if(nn&ms) {cout&&&Error!&&& exit(1);} MS= n= a=new int[MS]; for(int i=0; i&MS; i++) a[i]=aa[i]; } int Compare(AA b); //比较*this 与 b 的大小，若两者中 //的 n 值相同，并且数组中前 n 个元素值对应 //相同，则认为两者相等返回 1，否则返回 0。 }; int AA::Compare(AA b){ int count=0; for(int i=0;i&n;i++){ if(this-&a[i]= =b.a[i]) count++; } if((this-&n= =b.n)&&(count==n)) return 1; else return 0; } 4、 int AA::CompareBig(AA b) { if(n&b.n) k=b.n; else k=n; for(int i=0; i&k; i++) if(a[i]&b.a[i]) return 1; else if(a[i]&b.a[i]) return -1;if(k==n && k==b.n) return 0; else if(k&n) return 1; else return -1; }5、根据下面类中 CompareBig 函数成员的原型和注释写出它的类外定义。 class AA { int* int MS; public: void InitAA(int aa[], int nn, int ms) { if(nn&ms) {cout&&&Error!&&& exit(1);} MS= n= a=new int[MS]; for(int i=0; i&MS; i++) a[i]=aa[i]; } int CompareBig(AA b); //比较*this 与 b 的大小，从前向后按两数组 //中的对应元素比较，若*this 中元素值大则返回 1，若 b 中 //元素值大则返回-1，若相等则继续比较下一个元素，直到 //一个数组中无元素比较，此时若两者的 n 值相同则返回 0， //否则若*this 中的 n 值大则返回 1，若 b 中的 n 值大则返回-1。 }; int AA::CompareBig(AA b){ for(i=0;i&MS;i++){ if(this-&a[i]&b.a[i]) return 1; else if(this-&a[i]&b.a[i]) return -1; } if(i=MS) return 0; }5、 AA* AA::Reverse() {int i,x; for(i=0; i&n/2; i++) { x=a[i]; a[i]=a[n-1-i]; a[n-1-i]=x; } }6、 根据下面类中 Reverse 函数成员的原型和注释写出它的类外定义。 class AA { int* int MS; public: void InitAA(int aa[], int nn, int ms) { if(nn&ms) {cout&&&Error!&&& exit(1);} MS= n= a=new int[MS]; for(int i=0; i&MS; i++) a[i]=aa[i]; }AA* Reverse(); //对于调用该函数的对象，将其 a 数组中前 n 个 //元素值按相反的次序排列，返回指向该对象的指针。 }; int AA::* Reverse(){ for(int i=0;i&MS/2;i++) *this.a[i]=*this.[MS-1-i]; } 6、 AA* AA::Reverse1() { AA *px=new AA; px-&n=n; px-&MS=MS; px-&a=new int[MS]; for(int i=0; i&n; i++) { px-&a[n-1-i]=a[i]; } }7、根据下面类中 Reverse1 函数成员的原型和注释写出它的类外定义。 class AA { int* int MS; public: void InitAA(int aa[], int nn, int ms) { if(nn&ms) {cout&&&Error!&&& exit(1);} MS= n= a=new int[MS]; for(int i=0; i&MS; i++) a[i]=aa[i]; } AA* Reverse1(); //通过动态存储分配得到一个对象，并动态分配 //a[MS]数组空间,要求该对象中的 n 和 MS 的值与*this 中的 //对应成员的值相同，数组元素的值是按照*this 中数组元 //素的相反次序排列得到的，要求该函数返回动态对象的地址。 }; int AA::* Reverse(){ AA c.n=*this.n; c.MS=*this.MS; *a=new int [MS]; for(int i=0;i&MS/2;i++) c.a[i]=*this.[MS-1-i]; return &c; } 7、 Array::Array(int aa[], int nn) { n= a=new int[n]; for(int i=0; i&n; i++) a[i]=aa[i]; }8、根据下面类中构造函数的原型和注释写出它的类外定义。 class Array { int *a; //指向动态分配的整型数组空间 //记录数组长度 public:Array(int aa[], int nn); //构造函数，利用 aa 数组长度 nn 初始化 n， //利用 aa 数组初始化 a 所指向的数组空间 Array(Array& aa); //拷贝构造函数 Array& Give(Array& aa); //实现 aa 赋值给*this 的功能并返回*this Array Uion(Array& aa); //实现*this 和 aa 中的数组合并的 //功能，把合并结果存入临时对象并返回 int Lenth() {} //返回数组长度 void Print() { //输出数组 for(int i=0; i&n; i++) cout&&a[i]&&' '; cout&& } }; Array::Array(int aa[], int nn):n(nn),a(aa){} 8、 Array::Array(Array& aa) { n=aa.n; a=new int[n]; for(int i=0; i&n; i++) a[i]=aa.a[i]; }9、根据下面类中拷贝构造函数的原型写出它的类外定义。 class Array { int *a; //指向动态分配的整型数组空间 //记录数组长度 public: Array(int aa[], int nn); //构造函数，利用 aa 数组长度 nn 初始化 n， //利用 aa 数组初始化 a 所指向的数组空间 Array(Array& aa); //拷贝构造函数 Array& Give(Array& aa); //实现 aa 赋值给*this 的功能并返回*this Array Uion(Array& aa); //实现*this 和 aa 中的数组合并的 //功能，把合并结果存入临时对象并返回 int Lenth() {} //返回数组长度 void Print() { //输出数组 for(int i=0; i&n; i++) cout&&a[i]&&' '; cout&& } }; Array& Array:Give(Array &aa){ *this(aa); return *} 9、 Array& Array::Give(Array& aa) { delete []a; n=aa.n; a=new int[n]; for(int i=0; i&n; i++) a[i]=aa.a[i]; return * }10、根据下面类中 Give 函数的原型和注释写出它的类外定义。 class Array { int *a; //指向动态分配的整型数组空间 //记录数组长度 public: Array(int aa[], int nn); //构造函数，利用 aa 数组长度 nn 初始化 n， //利用 aa 数组初始化 a 所指向的数组空间 Array(Array& aa); //拷贝构造函数 Array& Give(Array& aa); //实现 aa 赋值给*this 的功能并返回*this Array Uion(Array& aa); //实现*this 和 aa 中的数组合并的 //功能，把合并结果存入临时对象并返回 int Lenth() {} //返回数组长度 void Print() { //输出数组 for(int i=0; i&n; i++) cout&&a[i]&&' '; cout&& } }; Array& Array:Give(Array &aa){ *this(aa); return * } 10、 Array Array::Uion(Array& aa) { int k=n+aa.n; int* w=new int[k]; for(i=0; i&n; i++) w[i]=a[i];for(i=0; i&aa.n; i++) w[i+n]=aa.a[i]; Array r(w,k); }11、根据下面类中 Uion 函数的原型和注释写出它的类外定义。 class Array { int *a; //指向动态分配的整型数组空间 //记录数组长度 public: Array(int aa[], int nn); //构造函数，利用 aa 数组长度 nn 初始化 n， //利用 aa 数组初始化 a 所指向的数组空间 Array(Array& aa); //拷贝构造函数 Array& Give(Array& aa); //实现 aa 赋值给*this 的功能并返回*this Array Uion(Array& aa); //实现*this 和 aa 中的数组合并的功能，把合并 //结果(其长度为两数组长度之和)存入临时对象并返回 int Lenth() {} //返回数组长度 void Print() { //输出数组 for(int i=0; i&n; i++) cout&&a[i]&&' '; cout&& } }; Array Array::Uion(Array &aa){ A int i,j; for(i=0;i&aa .MS;i++) bb.a[i]=aa.a[i]; for(j=i;j&*this.MS;j++) bb.a[j]=*this.a[i]; } 11、 Strings::Strings(char*str) { n=strlen(str); s=new char[n+1]; strcpy(s,str); }12、根据下面类中构造函数的原型和注释写出它的类外定义。 class Strings { char *s; //指向动态分配的字符串数组空间 //记录字符串长度 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() {} //返回字符串长度 void Print() {cout&&s&&} //输出字符串 }; Strings::Strings(char *str){ n=sizeof(str); strcpy(s,str); } 12、 Strings::Strings(Strings& str) { n=str.n; s=new char[n+1]; strcpy(s,str.s); }13、根据下面类中拷贝构造函数的原型写出它的类外定义。 class Strings { char *s; //指向动态分配的字符串数组空间 //记录字符串长度 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() {} //返回字符串长度 void Print() {cout&&s&&} //输出字符串 }; Strings::Strings(Strings &str){ s=str.s; n=str.n;} 13、 Strings& Strings::Give(Strings& str) { delete []s; n=str.n; s=new char[n+1]; strcpy(s,str.s); return * }14、根据下面类中 Give 函数的原型和注释写出它的类外定义。 class Strings { char *s; //指向动态分配的字符串数组空间 //记录字符串长度 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() {} //返回字符串长度 void Print() {cout&&s&&} //输出字符串 }; Strings& Strings::Give(Strings &str){ *this= } 14、 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); } 15、根据下面类中 Uion 函数的原型和注释写出它的类外定义。 class Strings { char *s; //指向动态分配的字符串数组空间 //记录字符串长度 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() {} //返回字符串长度 void Print() {cout&&s&&} //输出字符串 }; Strings Strings::Give(String &str){ S string.s=*this.s+str.s; }3、继承与派生一、选择题1．在 c++中，类之间的继承关系具有( c )。 (a) 自反性 (b) 对称性 (c) 传递性 (d) 反对称性 2．下列关于类的继承描述中，( d )是正确的。 (a) 派生类公有继承基类时，可以访问基类的所有数据成员，调用所有成 员函数。 (b) 派生类也是基类，所以它们是等价的。 (c) 派生类对象不会建立基类的私有数据成员，所以不能访问基类的私有 数据成员。 (d) 一个基类可以有多个派生类，一个派生类可以有多个基类。 3．当一个派生类公有继承一个基类时，基类中的所有公有成员成为派生类 的( a )。 (a) public 成员 (b) private 成员 (c) protected 成员 (d) 友员 4．当一个派生类私有继承一个基类时，基类中的所有公有成员和保护成员 成为派生类的( b )。 (a) public 成员 (b) private 成员 (c) protected 成员 (d) 友员 5．当一个派生类保护继承一个基类时，基类中的所有公有成员和保护成员 成为派生类的( c )。 (a) public 成员 (b) private 成员 (c) protected 成员 (d)友员 6．不论派生类以何种方式继承基类，都不能直接使用基类的( b )。 (a) public 成员 (b) private 成员 (c) protected 成员 (d) 所有成员7．下面描述中，错误的是( d )。 (a) 在基类定义的 public 成员在公有继承的派生类中可见，也能在类外被 访问。 (b) 在基类定义的 protected 成员在私有继承的派生类中可见。 (c) 在基类定义的公有静态成员在私有继承的派生类中可见。 (d) 访问声明可以在公有继承派生类中把基类的 public 成员声明为 private 成员。 8．在 c++中，可以被派生类继承的函数是( a )。 (a) 成员函数 (b)构造函数 (c) 析构函数 (d)友员函数 9．在创建派生类对象时，构造函数的执行顺序是( d )。 (a) 对象成员构造函数―基类构造函数―派生类本身的构造函数 (b) 派生类本身的构造函数―基类构造函数―对象成员构造函数 (c) 基类构造函数―派生类本身的构造函数―对象成员构造函数 (d) 基类构造函数―对象成员构造函数―派生类本身的构造函数 10．当不同的类具有相同的间接基类时，( c )。 (a) 各派生类无法按继承路线产生自己的基类版本 (b) 为了建立惟一的间接基类版本，应该声明间接基类为虚基类 (c) 为了建立惟一的间接基类版本，应该声明派生类虚继承基类 (d) 一旦声明虚继承，基类的性质就改变了，不能再定义新的派生类二、阅读下列程序，写出执行结果1． #include&iostream& class Base { public : void get( int i,int j,int k,int l ) { a = b = x = y = } void print() { cout && &a = &&& a && '\t' && &b = & && b && '\t' && &x = & && x && '\t' && &y = & && y && } int a, protected : int x, }; class A : public Base { public : void get( int i, int j, int k, int l ) { Base obj3; obj3.get( 50, 60, 70, 80 ); obj3.print();a = b = x = y = u = a + b + obj3. v = y - x + obj3.b; } void print() { cout && &a = & && a && '\t' && &b = & && b && '\t' && &x = & && x && '\t' && &y = & && y && cout && &u = & && u && '\t' && &v = & && v && } private: int u, }; int main() { Base obj1; A obj2; obj1.get( 10, 20, 30, 40 ); obj2.get( 30, 40, 50, 60 ); obj1.print(); obj2.print(); } 【解答】 a = 50 b = 60 x = 70 y = 80 a = 10 b = 20 x = 30 y = 40 a = 30 b = 40 x = 50 y = 60 u = 120 v = 70 2． #include&iostream& class Base1 { public : Base1( int i ) { cout && &调用基类Base1的构造函数:& && i && } }; class Base2 { public: Base2( int j ) { cout && &调用基类Base2的构造函数:& && j && } }; class A : public Base1, public Base2 { public : A( int a, int b, int c, int d ) : Base2(b), Base1(c), b2(a), b1(d) { cout && &调用派生类A的构造函数:& && a+b+c+d && } private : Base1 b1 ; Base2 b2 ;}; int main() { A obj( 1, 2, 3, 4 ); } 【解答】 调用基类 BASE1 的构造函数:3 调用基类 BASE2 的构造函数:2 调用基类 BASE1 的构造函数:4 调用基类 BASE2 构造函数:1 调用派生类 A 的构造函数:10 3． #include&iostream&
class A { public : A( int i, int j ) { a=i; b=} void Add( int x, int y ) { a+=x; b+=y; } void show() { cout&&&(&&&a&&&)\t(&&&b&&&)\n&; } private : int a, }; class B : public A { public : B(int i, int j, int m, int n) : A( i, j ),x( m ), y( n ) {} void show() { cout && &(& && x && &)\t(& && y && &)\n& ; } void fun() { Add( 3, 5 ) ; } void ff() { A::show() ; } private : int x, }; int main() { A a( 1, 2 ) ; a.show() ; B b( 3, 4, 5, 6 ) ; b.fun(); b.A::show(); b.show(); b.ff(); } 【解答】 (1) (2) (6) (9) (5) (6) (6) (9) 4．#include&iostream&
class A { public : A(const char *s) { cout && s && } ~A(){} }; class B : virtual public A { public : B(const char *s1, const char *s2) : A( s1 ) { cout && s2 && } }; class C : virtual public A { public : C(const char *s1, const char *s2):A(s1) { cout && s2 && } }; class D : public B, public C { public : D( const char *s1, const char *s2, const char *s3, const char *s4 ) : B( s1, s2 ), C( s1, s3 ), A( s1 ) { cout && s4 && } }; int main() { D *ptr = new D( &class A&, &class B&, &class C&, &class D& ) ; } 【解答】 class A class B class C class D三、分析题：2．请按照类成员的访问特性、类层次的继承特点，做出一张表格，总结各 种类成员在基类、派生类中的可见性和作用域。 【解答】 public protected private 基类成员 派生类继承 public 在 派 生 类 中 访 问 特 在派生类中访问特 基 类 私 有 成 性不变。派生类和类 性不变。类体系中 员，仅在基类外 均 可 见 ， 有 作 用 可见。 中可见。 域。 protected 成为派生类保护段成员。 在整个类体系中 可见。 private 成为派生类私有成员。 仅在派生类和基类 中可见。 派生类不论以何种方式继承基类， 基类所有成员在整个类 体系有作用域。 3． 若有以下说明语句： class A { private : int a1; public : int a2; /*…*/ }; class B : private A { private : int b1; public int b2; /*…*/ }; Bb; 对象 b 将会生成哪些数据成员？与继承关系、访问特性、名字有关吗？ 【解答】 对象 b 生成的数据成员有 a1 a2 A::x b1 b2 B::x，共六个数据成员。数据成员 的建立和继承关系、访问特性、名字无关。 4．若有以下说明语句： class A { /*…*/ public : void sameFun(); }; class B : public A { /*…*/ public : void sameFun(); }; void comFun() {Aa; Bb; /*…*/ } (1) 若在 B::sameFun 中要调用 A::sameFun， 语句形式如何？它将在什么对象 上操作？ (2) 在 comFun 中可以用什么方式调用 A::sameFun 和 B::sameFun？语句形式 如何？它们将可以在什么对象上操作？ 【解答】 （1）若要在 B::sameFun 中调用 A::sameFun，语句形式应为： A::samefun(); //域作用符说明调用基类函数 调用的 A::samefun 将在 B 类对象上进行操作。 （2）在 comFun 中调用 B::sameFun 和 A::sameFun 的方式有： a.A::sameFun(); //通过 A 类对象调用 A::sameFun，在 a 类对象上操作。 b.sameFun(); //通过 B 类对象调用 B::sameFun， b 类对象上操作。 在b.A::sameFun(); //通过 B 类对象调用 A::sameFun //在 b 类对象上（对由基类继承下来的数据成员）操作。 5．有人定义一个教师类派生一个学生类。他认为“姓名”和“性别”是教 师、学生共有的属性，声明为 public， “职称”和“工资”是教师特有的，声明 为 private。在学生类中定义特有的属性“班级”和“成绩” 。所以有 class teacher { public : char name[20]; //?? Private : char title[20]; }; class student : public teacher { //?? private : char grade[20] ; }; 你认为这样定义合适吗？请做出你认为合理的类结构定义。 【解答】 不合适， 这样导致数据冗余。合理的结构是提取它们共有的数据和操作定义 一个基类，然后分别定义 teacher 和 student 作为派生类。 class person { protected: char name[20]; //?? }; class teacher : public teache { //?? private: char title[20]; }; class student : public teacher { //?? private : char grade[20] ; }; 6.“虚基类”是通过什么方式定义的？如果类 A 有派生类 B、C，类 A 是 类 B 虚基类，那它也一定是类 C 的虚基类吗？为什么？ 【解答】 虚基类是在声明派生类时，指定继承方式时声明的，声明虚基类的一般形式 为： class 派生类名 ： virtual 继承方式 基类名 若类 A 是类 B 和类 C 的虚基类，但不一定是类 D 的虚基类，原因在于“虚 基类”中的“虚”不是基类本身的性质。而是派生类在继承过程中的特性。关键字 virtual 只是说明该派生类把基类当作虚基类继承，不能说明基类其他派生类 继承基类的方式。 7． 在具有虚继承的类体系中， 建立派生类对象时以什么顺序调用构造函数？ 请用简单程序验证你的分析。 【解答】 在具有虚继承的类体系中，建立派生类对象时先调用间接基类构造函数，再 按照派生类定义时各个直接基类继承的顺序调用直接基类的构造函数， 最后再对 派生类对象自身构造函数。 另外，C++为了保证虚基类构造函数只被建立对象的类执行一次，规定在创 建对象的派生类构造函数中只调用虚基类的构造函数和进行(执行)自身的初始 化。 参数表中的其他调用被忽略， 即直接基类的构造函数只调用系统自带的版本， 或调用自定义版本但不对虚基类数据成员初始化。 程序略。四、编程题1．定义一个 Rectangle 类，它包含两个数据成员 length 和 width；以及包含 用于求长方形面积的成员函数。再定义 Rectangle 的派生类 Rectangular，它包含 一个新数据成员 height 和用来求长方体体积的成员函数。在 main 函数中，使用 两个类，求某个长方形的面积和某个长方体的体积。 【解答】 #include &iostream& class rectangle { public: rectangle( double l,double w ) { length =width = } double area() { return( length*width ); } double getlength() { } double getwidth() { } private: }; class rectangular:public rectangle { public: rectangular( double l,double w,double h ) : rectangle( l,w ) { height = } double getheight() { }double volume() { return area() * } private: }; int main() { rectangle obj1( 2,8 ); rectangular obj2( 3,4,5 ); cout&&&length=&&&obj1.getlength()&&'\t'&&&width=&&&obj1.getwidth()&& cout&&&rectanglearea=&&&obj1.area()&& cout&&&length=&&&obj2.getlength()&&'\t'&&&width=&&&obj2.getwidth(); cout&&'\t'&&&height=&&&obj2.getheight()&& cout&&&rectangularvolume=&&&obj2.volume()&& } 2．假设某销售公司有销售经理和销售员工，月工资的计算办法是：销售经 理的固定月薪为 8000 元并提取销售额的 5/1000 作为工资；销售员工只提取销售 额的 5/1000 作为工资。编一程序，定义一个基类 Employee，它包含三个数据成 员 number、name 和 salary，以及用于输入编号和姓名的构造函数。由 Employee 类派生 Salesman 类，再由 Salesman 类派生 Salesmanager 类。Salesman 类包含两 个新数据成员 commrate 和 sales， 还包含用于输入销售额并计算销售员工工资的 成员函数 pay 和用于输出的成员函数 print。Salesmanager 类包含新数据成员 monthlypay，以及用于输入销售额并计算销售经理工资的成员函数 pay、用于输 出的成员函数 print()。在 main 函数中，测试你的类结构，求若干个不同员工的 工资。 【解答】 #include &iostream& class employee { public: employee() { cout && &编号：&; cin && cout &&&姓名：&; cin && salary = 0; } protected: char number[5]; char name[10]; }; class salesman: public employee { public: salesman(){ commrate = 0.005; } void pay() { cout&&name&&&本月销售额：& ; cin &&salary = sales* } void print() { cout&&&销售员 ：&&&name&&&编号：&&&number&&&本月工资： &&&salary&& } protected: }; class salesmanager: public salesman { public: salesmanager() { monthlypay = 8000; commrate = 0.005; } void pay() { cout&&name&&&本月部门销售额：& ; cin && salary = monthlypay + sales* } void print() { cout&&&销售经理 ： &&&name&&&编号： &&&number&&&本月工资： &&&salary&& } private: }; int main() { salesman obj1; obj1.pay(); obj1.print(); salesmanager obj2; obj2.pay(); obj2.print(); }4、多态性一、选择题1．在下列运算符中，不能重载的是( b )。 (a) ! (b) sizeof (c) new(d) delete2．下列关于运算符重载的描述中，( d )是正确的。 (a) 可以改变参与运算的操作数个数 (b) 可以改变运算符原来的优先级 (c) 可以改变运算符原来的结合性 (d) 不能改变原运算符的语义 3． 下面关于类型转换的描述中，错误的是( a )。 (a) 任何形式的构造函数都可以实现数据类型转换。 (b) 带非默认参数的构造函数可以把基本类型数据转换成类类型对象。 (c) 类型转换函数可以把类类型对象转换为其他指定类型对象。 (d) 类型转换函数只能定义为一个类的成员函数，不能定义为类的友员函 数。 4．下列函数中，不能说明为虚函数的是( c )。 (a) 私有成员函数 (b) 公有成员函数 (c) 构造函数 (d) 析构函数 5．在派生类中，重载一个虚函数时，要求函数名、参数的个数、参数的类 型、参数的顺序和函数的返回值( a )。 (a) 相同 (b) 不同 (c) 相容 (d) 部分相同 6．虚析构函数的作用是（ c ） 。 (a) 虚基类必须定义虚析构函数 (b) 类对象作用域结束时释放资源 (c) delete 动态对象时释放资源 (d) 无意义 7．下面函数原型中，( b )声明了 fun 为纯虚函数。 (a) void fun()=0; (b) virtual void fun()=0; (c) virtual void fun(); (d) virtual void fun(){ }; 8．若一个类中含有纯虚函数，则该类称为( c )。 (a) 基类 (b) 纯基类 (c) 抽象类 (d) 派生类 9．假设 Aclass 为抽象类，下列正确的说明语句是( b )。 (a) Aclass fun( int ) ; (b) Aclass * (c) int fun( Aclass ) ; (d) Aclass O 10．下面描述中，正确的是( d )。 (a) 虚函数是没有实现的函数 (b) 纯虚函数是返回值等于 0 的函 数 (c) 抽象类是只有纯虚函数的类 (d) 抽象类指针可以指向不同的派 生类二、阅读下列程序，写出执行结果1． #include &iostream& class T { public : T() { a = 0; b = 0; c = 0; } T( int i, int j, int k ) { a = b =j; c = } void get( int &i, int &j, int &k ) { i = j = k = }T operator* ( T obj ); private: int a , b , }; T T::operator* ( T obj ) { T tempobj.a = a * obj.a; tempobj.b = b * obj.b; tempobj.c = c * obj.c; } int main() { T obj1( 1,2,3 ), obj2( 5,5,5 ), obj3; int a , b , obj3 = obj1 * obj2; obj3.get( a, b, c ); cout&&&( obj1*obj2 ): & &&&a = &&&a&&'\t'&&&b = &&&b&&'\t'&&&c = &&&c&&'\t'&& (obj2*obj3).get( a, b, c ); cout&&&( obj2*obj3 ): & &&&a = &&&a&&'\t'&&&b = &&&b&&'\t'&&&c = &&&c&&'\t'&& } 【解答】 ( obj1 * obj2 ): a = 5 b = 10 c = 15 ( obj2 * obj3 ): a = 25 b = 50 c = 75 2． #include &iostream& class Vector { public: Vector(){ } Vector(int i,int j) { x = y = } friend Vector operator+ ( Vector v1, Vector v2 ) { Vector tempV tempVector.x = v1.x + v2. tempVector.y = v1.y + v2. return tempV } void display(){ cout && &( & && x && &, & && y && &) &&& } private: int x , }; int main() { Vector v1( 1, 2 ), v2( 3, 4 ), v3 ; cout && &v1 = & ; v1.display() ; cout && &v2 = & ; v2.display() ; v3 = v1 + v2 ; cout && &v3 = v1 + v2 = & ; v3.display() ; } 【解答】 v1 = ( 1, 2 ) v2 = ( 3, 4 ) v3 = v1 + v2 = ( 4, 6 ) 3． #include &iostream& class Bclass { public: Bclass( int i, int j ) { x = y = } virtual int fun() { return 0 ; } protected: int x, }; class Iclass:public Bclass { public : Iclass(int i, int j, int k):Bclass(i, j) { z = } int fun() { return ( x + y + z ) / 3; } private : }; int main() { Iclass obj( 2, 4, 10 ); Bclass p1 = cout && p1.fun() && Bclass &p2 = cout && p2.fun() && cout && p2.Bclass :: fun() && Bclass *p3 = & cout && p3 -& fun() &&} 【解答】 0 5 0 5 4． #include &iostream& class Base { public: virtual void getxy( int i,int j = 0 ) { x = y = } virtual void fun() = 0 ; protected: int x , } ; class A : public Base { public: void fun() { cout&&&x = &&&x&&'\t'&&&y = x * x = &&&x*x&& } }; class B : public Base { public: void fun() { cout && &x = & && x && '\t' && &y = & && y && cout && &y = x / y = & && x / y && } } ; int main() { Base * A obj1; B obj2; pb = &obj1; pb -& getxy( 10 ); pb -& fun(); pb = &obj2; pb -& getxy( 100, 20 ); pb -& fun(); } 【解答】 x = 10 y = x*x = 100 x = 100 y = 20 y = x / y = 5三、 ：判断题1、构造函数可以声明为虚函数。 （F ） 2、 ．在析构函数中调用虚函数时，采用动态束定。 （F ） 3、 ．在一个成员函数内调用一个虚函数时，对该虚函数的调用进行动态束定。 （T ） 4、公有继承可以实现子类型。 （T ） 5、构造函数可以声明为纯虚函数。 （F ） 6、.如果派生类的成员函数的原型与基类中被定义为虚函数的成员函数原型相 同，那么，这个函数自动继承基类中虚函数的特性。对 7、虚函数不能是类的静态成员。对 8、重定义虚函数的派生类必须是公有继承的。对 9、对于从基类继承的虚函数，派生类也可以不进行重定义。对 10、纯虚函数与函数体为空的虚函数等价。错 11、多态类提供了一种动态多分支派送机制。对 12、作为虚函数隐含参数的 this 指针，决定了虚函数调用时执行的代码。对四、 ：问答题1．在 C++中，使用类体系依靠什么机制实现程序运行时的多态？ 【解答】 在 C++中，基类指针可以指向派生类对象，以及基类中拥有虚函数，是支持 多态性的前提。 程序通过用同一个基类指针访问不同派生类的虚函数重载版本实 现程序运行时的多态。C++的虚特性负责自动地在程序运行时把基类指针的关联 类型转换成当前指向对象的派生类类型。 另外， 抽象类机制提供了软件抽象和可扩展性的手段， 实现运行时的多态性。 2．虚函数和纯虚函数的区别是什么？ 【解答】 虚函数定义时冠以关键字 virtual,本身有实现代码，作用是引导基类指针根据 指向对象调用类体系中不同重载版本函数。 纯虚函数是指在说明时代码“为 0”的虚函数，即纯虚函数本身并没有实现 代码，必须通过它的派生类定义实现版本。五、编程题1．分别使用成员函数和友员函数编写程序重载运算符“+” ，使该运算符能 实现两个字符串的连接。 【解答】 （1） 使用成员函数 #include &iostream&#include&cstring& class s { public: s(){ *str = '\0'; } s( char *pstr ) { strcpy( str,pstr ); } char *gets() { } s operator+( s obj ); private: char str[10]; }; s s::operator+( s obj ) { strcat( str,obj.str ); //或 return *this } int main() { s obj1( &Visual& ),obj2( & C++& ),obj3; obj3 = obj1 + obj2; cout && obj3.gets() && } （2）使用友员函数 #include &iostream& #include&cstring& class s { public: s(){ *str= '\0'; } s( char *pstr ) { strcpy( str,pstr ); } char *gets() { } friend s operator+( s obj1,s obj2 ); private: char str[100]; }; s operator+( s obj1,s obj2 ) { strcat( tempobj.str,obj1.str );strcat( tempobj.str,obj2.str ); } int main() { s obj1( &Visual& ),obj2( & C++& ),obj3; obj3 = obj1 + obj2; cout && obj3.gets() && } 2．使用虚函数编写程序求球体和圆柱体的体积及表面积。由于球体和圆柱 体都可以看做由圆继承而来，所以可以把圆类 Circle 作为基类。在 Circle 类中定 义一个数据成员 radius 和两个虚函数 area 和 volume。由 Circle 类派生 Sphere 类 和 Column 类。在派生类中对虚函数 area 和 volume 重新定义，分别求球体和圆 柱体的体积及表面积。 【解答】 #include &iostream& const double PI=3.; class circle { public: circle(double r) { radius = } virtual double area() { return 0.0; } virtual double volume() { return 0.0; } protected: }; class sphere:public circle { public: sphere( double r ):circle( r ){ } double area() { return 4.0 * PI * radius * } double volume() { return 4.0 * PI * radius * radius * radius / 3.0; } }; class column:public circle { public: column( double r,double h ):circle( r ) { height = } double area() { return 2.0 * PI * radius * ( height + radius ); } double volume() { return PI * radius * radius * } private: };int main() { circle *p; sphere sobj(2); p = & cout && &球体:& && cout && &体积 = & && p-&volume() && cout && &表面积 = & && p-&area() && column cobj( 3,5 ); p = & cout && &圆柱体:& && cout && &体积 = & && p-&volume() && cout && &表面积 = & && p-&area() && } 3．某学校对教师每月工资的计算规定如下：固定工资+课时补贴。教授的固 定工资为 5000 元，每个课时补贴 50 元。副教授的固定工资为 3000 元，每个课 时补贴 30 元。讲师的固定工资为 2000 元，每个课时补贴 20 元。定义教师抽象 类，派生不同职称的教师类，编写程序求若干个教师的月工资。 【解答】 #include &iostream& class teacher{ public: teacher( char tname[],int time ) { strcpy( name,tname ); coursetime = } virtual int pay() = 0; virtual void print() = 0; char *getname() { } int getcoursetime() { } protected: char name[30]; }; class professor:public teacher { public: professor( char pname[],int time ):teacher( pname,time ){ } int pay() { return 5000+coursetime*50; } void print() { cout&&&教授：&&&getname(); } };class associateprofessor:public teacher { public: associateprofessor( char pname[],int time ):teacher( pname,time ){ } int pay() { return 3000 + coursetime * 30; } void print() { cout && &副教授：& && getname(); } }; class lecturer:public teacher { public: lecturer( char pname[],int time ):teacher( pname,time ){ } int pay() { return 2000 + coursetime * 20; } void print() { cout && &讲师：& && getname();} }; int main() { professor pobj( &李小平&,32 ); pobj.print(); cout && '\t' && &工资：& && pobj.pay() && associateprofessor apobj( &王芳芳&,56 ); apobj.print(); cout && '\t' && &工资：& && apobj.pay() && lecturer lobj( &何大建&,72 ); lobj.print(); cout && '\t' && &工资：& && lobj.pay() && }5、模板一、选择题1．关于函数模板，描述错误的是( a )。 (a) 函数模板必须由程序员实例化为可执行的函数模板 (b) 函数模板的实例化由编译器实现 (c) 一个类定义中，只要有一个函数模板，则这个类是类模板 (d) 类模板的成员函数都是函数模板，类模板实例化后，成员函数也随 之实例化 2．下列的模板说明中，正确的是( c )。 (a) template & typename T1, T2 &(b) template & class T1, T2 & (c) template & typename T1, typename T2 & (d) template ( typedef T1, typedef T2 ) 3．假设有函数模板定义如下： template &typename T& Max( T a, T b ,T &c) {c =a+b;} 下列选项正确的是( b )。 (a) int x, (b) double x, y, Max( x, y, z ) ; Max( x, y, z ) ; (c) int x, (d) double y, Max( x, y, z ); Max( x, y, z ) ; 4．关于类模板，描述错误的是( a )。 (a) 一个普通基类不能派生类模板 (b) 类模板可以从普通类派生，也可以从类模板派生 (c) 根据建立对象时的实际数据类型，编译器把类模板实例化为模板类 (d) 函数的类模板参数需生成模板类并通过构造函数实例化 5． 建立类模板对象的实例化过程为( c )。 (a) 基类 ? 派生类 (b) 构造函数 ? 对象 (c) 模板类 ? 对象 (d) 模板类 ? 模板函数 6．在 C++中，容器是一种( d )。 (a) 标准类 (b) 标准对象 (c) 标准函数 (d) 标 准 类 模 板二、阅读下列程序，写出执行结果1． #include &iostream& template &typename T& void fun( T &x, T &y ) { T temp = x = y = } int main() { int i , i = 10; j = 20; fun( i, j ); cout && &i = & && i && '\t' && &j = & && j && double a , a = 1.1; b = 2.2; fun( a, b ); cout && &a = & && a && '\t' && &b = & && b &&} 【解答】 i=20 j=10 a=2.2 b=1.1 2． #include &iostream& template &typename T& class Base { public: Base( T i , T j ) { x = T sum() { return x + } private: T x , } ; int main() { Base&double& obj2(3.3,5.5); cout && obj2.sum() && Base&int& obj1(3,5); cout && obj1.sum() && } 【解答】 8.8 8y = }三、思考题1．抽象类和类模板都是提供抽象的机制，请分析它们的区别和应用场合。 【解答】 抽象类至少包含一个纯虚函数， 纯虚函数抽象了类体系中一些类似操作的公 共界面，它不依赖于数据，也没有操作定义。派生类必须定义实现版本。抽象类 用于程序开发时对功能的统一策划， 利用程序运行的多态性自动匹配实行不同版 本的函数。 类模板抽象了数据类型，称为类属参数。成员函数描述了类型不同，逻辑操 作相同的功能集。 编译器用建立对象的数据类型参数实例化为模板类，生成可运 行的实体。类模板用于抽象数据对象类型不同，逻辑操作完全相同类定义。这种 数据类型的推导必须在语言功能的范畴之内的。 3．类模板能够声明什么形式的友员？当类模板的友员是函数模板时，它们 可以定义不同形式的类属参数吗？请你写个验证程序试一试。 【解答】 类模板可以声明的友员形式有：普通函数、函数模板、普通类成员函数、类 模板成员函数以及普通类、类模板。 当类模板的友员是函数模板时，它们可以定义不同形式的类属参数。程序略。 4．类模板的静态数据成员可以是抽象类型吗？它们的存储空间是什么时候 建立的？请你用验证程序试一试。 【解答】 类模板的静态数据成员可以是抽象类型。它们的存储空间在生成具体模板类 的时候建立， 即每生成一个模板类同时建立静态储存空间并做一次文件范围的初 始化。 程序略。 10.4 编程题 1．使用函数模板实现对不同类型数组求平均值的功能，并在 main 函数中分 别求一个整型数组和一个单精度浮点型数组的平均值。 【解答】 #include &iostream& template &typename T& double average( T *array,int size ) { T sum = 0; for( int i=0; i& i++ ) sum += array[i]; return sum / } int main() { int a[] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 }; double b[] = { 1.1, 2.2, 3.3, 4.4, 5.5, 6.6, 7.7, 8.8, 9.9, 10 }; cout && &Average of array a :& && average( a,10 ) && cout && &Average of array b :& && average( b,10 ) && }C++模拟试题集1、C++模拟试题一一、单项选择题（本大题共 10 小题，每小题 2 分，共 20 分）在每小题列出的四个备选项 中，只有一个是符合题目要求的，请将其代码填写在题后的括号内。错选、多选或未选均 无分。 1．说明虚函数的关键字是（ ） 。 A. inline B. virtual C. define D. static 2．在每个 C++程序中都必须包含有这样一个函数，该函数的函数名为（ ） 。 A. main B. MAIN C. name D. function 3．cout 是某个类的标准对象的引用，该类是（ A ） 。 A. ostream B. istream C. stdout D. stdin 4．如果在类外有函数调用 CPoint::func()；则函数 func()是类 CPoint 的（ ） 。 A. 私有静态成员函数 B. 公有非静态成员函数 C. 公有静态成员函数 B. 友元函数 5. 如果 class 类中的所有成员在定义时都没有使用关键字 public、private 或 protected，则所 有成员缺省定义为（ ） 。 A. public B. protected C. private D．static 6．一个类的所有对象共享的是（ ） 。 A. 私有数据成员 B. 公有数据成员 C. 保护数据成员 D. 静态数据成员 7．动态联编所支持的多态性称为（ ） 。 A. 虚函数 B. 继承 C. 编译时多态性 D. 运行时多态性 8．定义类模板时要使用关键字（ ） 。 A. const B. new C. delete D. template 9．对虚基类的定义（ ） 。 A. 不需要使用虚函数 B. 必须使用虚函数 C. 必须使用 private D. 必须使用 public 10．类型转换函数（ ） 。 A. 不能带有参数 B. 只能带一个参数C. 只能带 2 个参数D. 只能带 3 个参数二、判断正误题（本大题共 6 小题，每小题 2 分，共 12 分）判断正误，在题后的括号内， 正确的划上“√”错误的划上“×” 。1．虚函数在基类和派生类之间定义，且要求函数原型完全一致。 （ Y ） 2．抽象类可以用来直接创建对象。 （ ） 3．内联函数中可以出现递归语句。 4．模板类与类模板的意义完全相同。 5．常对象只能调用常成员函数。 6．重载函数要求函数有相同的函数名，但具有不同的参数序列。 （ ）（ （ （） ） ）三、填空题（本大题共 6 小题，每小题 2 分，共 12 分）不写解答过程，将正确的答案写在 每小题的空格内。错填或不填均无分1．在用 C++进行程序设计时，最好用（ ）代替 malloc。 2．函数模板中紧随 template 之后尖括号内的类型参数都要寇以保留字（ 3．编译时多态性可以用（ ）函数实现。 4．拷贝构造函数用它所在类的（ ）作为参数。 5．用关键字 static 修饰的类的成员称为( )成员。 6．重载运算符“+”的函数名为（ ） 。） 。四、程序分析题（本大题共 4 小题，每小题 5 分，共 20 分）给出下面各程序的输出结果。 1．阅读下面程序，写出输出结果。 #include &iostream& class CArray { public: CArray(int iArray[], int iSize):m_pArray(iArray), m_iSize(iSize) { } int GetSize() { return m_iS } int &operator[](int iIndex) { return m_pArray[iIndex - 1];} private: int *m_pA int m_iS };// 指向一个数组空间 // 数组元素个数int main() { int s[]={3, 7, 2, 1, 5}; CArray oArray(s, 5); oArray[1] = 9; for (int i = 1; i &= 5; i++) { cout && oArray[i] && & &; } cout && return 0; } 上面程序的输出结果为：9 7 2 1 52．阅读下面程序，写出输出结果。 #include &iostream& template &class Type& void Print(Type a[], int n) { for (int i = 0; i & i++) { cout && a[i] && & &; } }int main() { int a[] = { 5, 6, 8}; double b[] = {6.8, 9.6};Print(a, sizeof(a) / sizeof(int)); Print(b, 2); cout && return 0; } 上面程序的输出结果为：3．阅读下面程序，写出输出结果。 #include &iostream& class CTest { public: CTest(int iVar):m_iVar(iVar) { m_iCount++; } ~CTest() { } void Print() static int GetCount() { return m_iC } private: int m_iV static int m_iC }; int CTest::m_iCount = 0; void CTest::Print() const {cout && this-&m_iVar && & & && this-&m_iCount && & &; } int main() { CTest oTest1(6); oTest1.Print(); CTest oTest2(8); oTest2.Print(); cout && CTest::GetCount(); cout && return 0; } 上面程序的输出结果为：4．阅读下面程序，写出输出结果。 #include &iostream& class CTest { public: CTest(int iX = 0, int iY = 0, int iZ = 0):m_iZ(iZ) { m_iX = iX; m_iY = iY; } void Print() { cout && m_iX && cout && m_iY && } void Print() const { cout && m_iZ && }private: int m_iX, m_iY; const int m_iZ; };int main() { CTest oTest1; oTest1.Print(); CTest oTest2(1, 6, 8); oTest2.Print(); const CTest oTest3(6, 0, 18); oTest3.Print(); cout && return 0; } 上面程序的输出结果为：五、程序改错题（本大题共 4 小题，每小题 5 分，共 20 分）指出下面程序中的错误，说明 错误原因，并加以改正。 1．下面程序中类的定义中有一处错误，请指出出错的行，说明错误原因，并加以改正。 #include &iostream& //1 //2 //3 class CTest //4 { //5 public: //6 CTest(int iVar = 0):m_iArr(iVar) //7 { //8 cout && &构造函数:& && m_iArr && //9 } //10 //11 void ~CTest() //12 { //13 cout && &析造函数:& && m_iArr && //14 } //15private: int m_iA };int main() { CTest oTest1, oTest2(8); cout && return 0; }//16 //17 //18 //19 //20 //21 //22 //23 //24 //25 //26 //27 //282．下面程序中类的定义中有一处错误，请指出出错的行，说明错误原因，并加以改正。 #include &iostream& //1 //2 //3 class CTest //4 { //5 public: //6 CTest(int iA = 0, int iB):m_iA(iA), m_iB(iB) //7 { //8 } //9 //10 void Show() //11 { //12 cout && m_iA && &,& && m_iB && //13 } //14 //15 private: //16 int m_iA, m_iB; //17 }; //18 //19 //20 int main() //21 { //22 CTest oTest(12, 16); //23 oTest.Show(); //24 cout && //25 //26 return 0; //27}//283．下面程序中类的定义中有一处错误，请指出出错的行，说明错误原因，并加以改正。 #include &iostream& //1 //2 //3 class CTest //4 { //5 public: //6 CTest(int iVar = 0) //7 { //8 m_iVar = iVar CTest(int iVar = 0):m_iVar(iVar) //9 } //10 //11 void Print() const //12 { //13 cout && m_iVar&& //14 } //15 //16 private: //17 const int m_iV //18 }; //19 //20 //21 int main() //22 { //23 const CTest oTest(16); //24 oTest.Print(); //25 cout && //26 //27 return 0; //28 } //294．下面程序中有一处错误，请指出出错的行，说明错误原因，并加以改正。 #include &iostream& class CBase//1 //2 //3 //4{ public: CBase(int iBase = 0):m_iBase(iBase) { } virtual void Show() = 0; int Get() const { return m_iB } private: int m_iB }; class CDerive:public CBase { public: CDerive(int iBase = 0, int iDerive = 0):CBase(iBase) { m_iDerive = iD } void Show() { cout && CBase::Get() && &,& && m_iDerive && } private: int m_iD }; int main() { CBase obj(10); //42 //40//5 //6 //7 //8 //10 //11 //12 //13 //14 //15 //16 //17 //18 //19 //20 //21 //22 //23 //24 //25 //26 //27 //28 //29 //30 //31 //32 //33 //34 //35 //36 //37 //38 //39 //41CDerive obj(10);？//42 obj.Show(); ret