《面向对象程序设计C》

《《面向对象程序设计C》》由会员上传分享，免费在线阅读，更多相关内容在行业资料-天天文库。

《面向对象程序设计》综合复习题集ー、单选题1.C++源程序文件的缺省扩展名为（A）〇A.cppB.exeC.objD.lik2.由C++源程序文件编译而成的目标文件的缺省扩展名为（C）〇A.cppB.exeC.objD.lik3.由C++目标文件连接而成的可执行文件的缺省扩展名为（B）。A.cppB.exeC.objD.lik

12.编写C++程序一般需经过的几个步骤依次是（）。A.编译、编辑、连接、调试B.编辑、编译、连接、调试C.编译、调试、编辑、连接D.编辑、调试、编辑、连接3.以下标识符中不全是保留字的是（）。A.caseforintB.defaultthenwhileC.boolclasslongD.gotoreturnchar4.能作为C++程序的基本单位是（）。A,字符B.语句C.函数D.源程序文件5.程序中主函数的名字为（）。A.mainB.MAINC.MainD,任意标识符6.C++程序的基本模块为（）〇A,表达式B.标识符C.语句D.函数7.可用作C++语言用户标识符的ー组标识符是（）»A.voiddefine+W0RDB.a3_b3_123YNC.for-abcCaseD.2aDOsizeof8.存储以下数据,占用存储字节最多的是（）。A.0B.’〇’C."0"D.0.09.程序运行中需要从键盘上输入多于ー个数据时,各数据之间应使用（）符号作为分隔符。A,空格或逗号B.逗号或回车C,逗号或分号D,空格或回车10.设“inta=12;”，则执行完语句"a+=a*a;"后,a的值是（）.A.12B.144C.156D.28811.假设在程序中a、b、c均被定义成整型,所赋的值都大于1,则下列能正确表示代数式1/abc的表达式是（）〇A.1.0/a*b*cB.l/（a*b*c）C.1/a/b/（float）cD.1.0/a/b/c12.设“inta=15,b=26;",则"cout«（a,b）;"的输出结果是（）〇A.15B.26,15C.15,26D.2613.设x是ー个bool型的逻辑量，y的值为10,则表达式x&&y的值为（）。A.1B.0C.与x值相同D.与x值相反14.x>0&&x<=10的相反表达式为（）。A.x<=0|x>10B.x<=0&&x>10C.x<=0x<=10D.x>0&&x>1015.x>0IIy==5的相反表达式为（）。A.x<=0y!=5B.x<=0&&y!=5C.x>0y!=5D.x>0&&y==5

22.设x和y均为bool量,则x&&y为真的条件是（）»A,它们均为真B.其中一个为真C,它们均为假D.其中一个为假3.设x和y均为bool量,则x||y为假的条件是（）»A,它们均为真B.其中一个为真C,它们均为假D.其中一个为假4.字符串"a+b=12

3”的长度为（）。A.6B.7C.8D.95.假定下列x和y均为int型变量,则不正确的赋值为（）。A.x+=y++B.x++=y++C.x=++yD.++x=++y22,下列的符号常量定义中,错误的定义是（）。A.constM=10;C.constcharch;B.constintM=20;D.constboolmark=true;23.循环语句afor（inti=0;in/2）break;A.n/2B.n/2+1C.n/2-lD.n-l25.在下面循环语句中内层循环体S语句的执行总次数为（）。for（inti二〇;i

4C.inta[][3]={{l,3,5},{2}};D.inta[]（10）;33.假定一个二维数组的定义语句为“inta[3][4]={{3,4},{2,8,6}）:",则元素a[l][2]的值为（）«A.2B.4C.6D.834.假定一个二维数组的定义语句为“inta[3][4]={{3,4},{2,8,6}}:",则元素a[2][l]的值为（）〇A.0B.4C.8D.635.若定义了函数double*function（）,则函数function的返回值为（）。A.实数型B.实数的地址C.指向函数的指针D.函数的地址36.以下说法中正确的是（）。A.C++程序总是从第一个定义的函数开始执行B.C++程序总是从main函数开始执行C.C++函数必须有返回值,否则不能使用函数D.C++程序中有调用关系的所有函数必须放在同一个程序文件中37.以下叙述中不正确的是（）。A.在ー个函数中，可以有多条return语句B.函数的定义不能嵌套，但函数的调用可以嵌套C.函数必须有返回值D.不同的函数中可以使用相同名字的变量38.函数重载是指（）。A.两个或两个以上的函数取相同的函数名，但形参的个数或类型不同B.两个以上的函数取相同的名字和具有相同的参数个数,但形参的类型可以不同C.两个以上的函数名字不同，但形参的个数或类型相同D.两个以上的函数取相同的函数名,并且函数的返回类型相同39.以下关于函数模板叙述正确的是（）。A,函数模板也是ー个具体类型的函数B.函数模板的类型参数与函数的参数是同一个概念C,通过使用不同的类型参数,函数模板可以生成不同类型的函数D.用函数模板定义的函数没有类型40.下列（）的调用方式是引用调用。A.形参和实参都是变量B.形参是指针，实参是地址值C.形参是引用,实参是变量D.形参是变量，实参是地址值41.为了提高程序的运行速度,可将不太复杂的功能用函数实现，此函数应选择（）。A.内联函数B.重载函数C.递归函数D.函数模板42.函数原型语句正确的是（）。A.intFunction（voida）;B.voidFunction（int）;C.intFunction（a）;D.voidint（doublea）;43.C++中函数返回值的类型是山（）决定的。A.return语句中表达式的类型B.该函数定义时的类型C.调用函数时的调用语句D・系统根据结果44.以下函数的返回结果是（）。intfunction（char*x）{char*p=x;while（*p++）;return（p-x-l）;}A,求字符串的长度B.将字符串x连接到字符串p后面

5C.将字符串x复制到字符串p中D.将字符串x反向存放33.函数调用func（（expl,exp2）,（exp3,exp4,exp5））中所含实参的个数为（）个。A.1B.2C.4D.534.设有如下函数定义intf（char*s）{char*p=s;while（*p!=,、〇’）p++;return（p-s）;）在主函数中用cout＜〈f（"good”）调用上述函数,则输出结果为（）。A.3B.4C.5D.649,以下正确的函数原型语句是（）»A.doublefun（intx,inty）B.doublefun（intx;inty）C.doublefun（int,int）;D.doublefun（intx,y）;50.以下正确的说法是（）。A,用户调用标准库函数前,必须重新定义B.用户可以重新定义标准库函数,若如此,该函数将失去原有含义C.系统不允许用户重新定义标准库函数D.用户调用标准库函数前，不必使用预编译命令将该函数所在文件包括到用户源文件中51.函数调用不可以（）。A,出现在ー个表达式中B.出现在执行语句中C.作为ー个函数的实参D.作为ー个函数的形参52,以下正确的描述是（）。A,函数的定义可以嵌套，函数的调用不可以嵌套B.函数的定义不可以嵌套，函数的调用可以嵌套C,函数的定义和函数的调用均可以嵌套D.函数的定义和函数的调用均不可以嵌套53.若用数组名作为函数调用的实参，传递给形参的是（）。A.数组的首地址B.数组中第一个元素的值C,数组全部元素的值D.数组元素的个数54.以下错误的描述是（）。A.被调用函数中可以不用return语句B,被调用函数中可以用多个return语句C.被调用函数中，如果有返回值，就一定要有return语句D,被调用函数中，ー个return语句可返回多个值给调用函数55,以下正确的描述是（）。A,不允许设置参数的默认值B.设置参数的默认值只能在定义函数时设置C.设置参数的默认值时，应该设置右边的参数D.设置参数的默认值时,应该全部参数都设置

656.采用重载函数的目的是（）。A.实现共享B1减少空间C.提高速度D,使用方便，提高可读性57.将两个字符串连接起来组成一个字符串时,选用（）函数。A.strlen（）B.strcap（）C.strcat（）D.strcmp（）58.以下叙述中正确的是（）〇A.使用#define可以为常量定义ー个名字,该名字在程序中可以再赋另外的值B.使用const定义的常量名有类型之分,其值在程序运行时是不可改变的C,在程序中使用内联函数使程序的可读性变差D.在定义函数时可以在形参表的任何位置给出缺省形参值59.下面的标识符中,（）是文件级作用域。A.函数形参B.语句标号C.外部静态类标识符D.自动类标识符60.以下叙述不正确的是（）.A,宏替换不占用运行时间B.宏名无类型C.宏替换只是字符替换D,宏名必须用大写字母表示61.C++语言的编译系统对宏命令的处理是（）。A,在程序运行时进行B.在程序连接时进行C,和C++程序的其它语句同时进行编译D.在对源程序中其它成分正式编译之前进行62.当#include后面的文件名用双引号括起来时,寻找被包含文件的方式是（）.A.直接按系统设定的标准方式搜索目录B.先在源程序所在H录搜索,再按系统设定的标准方式搜索目录C.仅仅搜索源程序所在目录D，搜索当前逻辑盘ヒ的所有目录63.当#include后面的文件名用尖括号括起来时，寻找被包含文件的方式是（）.A,直接按系统设定的标准方式搜索目录B.先在源程序所在目录搜索，再按系统设定的标准方式搜索目录C.仅仅搜索源程序所在目录D.搜索当前逻辑盘上的所有目录64.在下面存储类中,（）对象的可见性与生存期不一致。A,外部类B.自动类C.内部静态类D.寄存器类65.在下面存储类中，（）的对象不是局部变量。A,外部静态类B,自动类C.函数形参D.寄存器类66.关于局部变量，下面说法正确的是（）.A,定义该变量的程序文件中的函数都可以访问B.定义该变量的函数中的定义处以下的任何语句都可以访问C.定义该变量的复合语句中的定义处以下的任何语句都可以访问D.定义该变量的函数中的定义处以上的任何语句都可以访问67.文件包含命令中被包含的文件的扩展名（）。A.必须是.hB.不能是.hC.可以是.h或.cppD.必须是.cpp68.预处理命令在程序中都是以（）符号开头的。A.*B.#C.&D.@69.设array为一个数组,则表达式sizeof（array）/sizeof（array[〇]）的结果为A.array数组首地址B.array数组中元素个数

7A.array数组中每个元素所占的字节数B.array数组占的总字节数68.用new运算符创建一个含10个元素的一维整型数组的正确语句是（）。A.int*p=newa[10];B.int*p=newfloat[10];C.int*p=newint[10]：D.int*p=newint[10]={l,2,3,4,5}71.下列给字符数组赋初值时，正确的是（）〇D.charsi[]="abcdef”;B.chars2[4]="abed";C.chars3⑵[3]={"abc","xyz”}：D.chars4[4]ロ={'a','x','s','t'};72.设有定义“staticintdata[5][6];”,设该数组在静态存储区中的起始地址为十进制的100,若每个int型数占4个字节,则数组元素data[2][3]的地址为（A.115B.124C.130D.16073.假定变量m定义为“intm=7;",则定义变量p的正确语句为（）。A.intp=&m;B.int*p=&m;C.int&p=*m;D.int*p=m;74.假定k是ー个double类型的变量,则关于变量p的正确定义语句为（）。A.doublep=&k;B.int*p=&k;C.double&p=*k;D.char*p="Thankyou!";75.变量s的定义为“char*s="Helloworld!",要使变量p指向s所指向的同ー个字符串,则应选取（）。A.char*p=s;B.char*p=&s;C.char*p;p=*s;D.char*p;p=&s;76.关于void指针，下列说法正确的是（）。A.void指针就是未指向任何数据的指针B.void指针就是已定义而未初始化的指针C,指向任何类型数据的指针可直接赋值给ー个void指针D.void指针值可直接赋给ー个非void指针77.假定一条定义语句为“inta[10],x,*pa=a;",若要把数组a中下标为3的元素值赋给x,则不正确的语句为（）。A.x=pa[3];B.x=*（a+3）;C.x=a[3];D.x=*pa+3;78.假定有定义“intb[10];int*pb;"，则不正确的赋值语句为（）。A.pb=b;B.pb=&b[0];C.*pb=newint;D.pb=b[5];79.假定p是具有double类型的指针变量,则表达式++p使p的值（以字节为单位）增加（）。A.1B.4C.sizeof（double）D.sizeof（p）80.假定p指向的字符串为”string",则coutくくp+3的输出结果为（）。A.stringB.ringC.ingD.i81.假定p指向的字符串为”string",若要输出这个字符串的地址值,则使用（）»A.coutく<・s;B.cout«s;C.cout«&s;D.cout«（void*）s;82.定义p并使p指向动态空间中的包含30个整数的数组所使用的定义语句为（）。A.int*p=newint[30];B.int*p=newint（30）;C.int*p=new[30];D.*p=newint[30];83.假定p是具有int**类型的指针变量，则给p赋值的正确语句为（）。A.p=newint;B.p=newint*;C.p=newint**;D.p=newint[10];84.要使语句“p=newint[10][20];"能够正常执行,p应被事先定义为（）。A.int*p;B.int**p;C.int*p[20];D.int（*p）[20];85.假定有,4structBOOK（chartitle[40];floatprice;};BOOK*book=newBOOK;",则正确的语句为（）。A.strcpy（book->title,"WangTao"）;B.strcpy（book,title,"WangTao"）;C.strcpy（*book.title,"WangTao"）;D.strcpy（（*book）->title,"WangTao"）;

877.假定有“structBOOK{chartitle[40];floatprice;};BOOK*book;",则不正确的语句为（）。A.BOOK*x=newbook;B.BOOKx={"C++Programming"",27.0};C.BOOK*x=newBOOK;D.BOOK*x=book;78.假定有“structBOOK{chartitle[40];floatprice;}book;",则正确的语句为（）〇A.BOOK&x=&book;B.BOOK&x二book;C.BOOK&x=newBOOK;D.BOOK&x二BOOK;79.下列对引用的陈述中不正确的是（）。A,每ー个引用都是其所引用对象的别名,因此必须初始化B.形式上针对引用的操作实际上作用于它所引用的对象C.一旦定义了引用,一切针对其所引用对象的操作只能通过该引用间接进行D.不需要单独为引用分配存储空间80.假定变量a和pa定义为“doublea[10],*pa=a;",要将12.35赋值给a中的下标为5的元素,不正确的语句是（）。A.pa[5]=12.35；B.a[5]=12.35;C.*（pa+5）=12.35;D.*（a[0]+5）=12.35;81.假定变量b和pb定义为“intb[10],*pb=b;"，要将24赋值给b口]元素中，不正确的语句是（）。A.*（pb+l）=24;B.*（b+l）=24;C.*++b=24;D.*++pb=24;82.假定指针变量p定义为"int*p=newint（lOO）;w,要释放p所指向的动态内存，应使用语句（）。A.deletep;B.delete*p;C.delete&p;D.delete[]p;83.假定指针变量p定义为"int*p=newint[30];",要释放p所指向的动态内存,应使用语句（）。A.deletep;B.delete*p;C.delete&p;D.delete[]p;84.假定变量x定义为“intx=5;",要使rx成为x的引用（别名），rx应定义为（）〇A.intrx=x;B.intrx=&x;C.int*rx=&x;D.int&rx=x;85.关于消息，下列说法中不正确的是（）。A.发送消息的对象请求服务，接受消息的对象提供服务B,消息的发送者必须了解消息的接收者如何相应消息C.在C++中，消息的发送具体体现为对接收消息的对象的某个函数的调用D.每个对象只能接收某些特定格式的消息86.关于封装，下列说法中不正确的是（）。A.通过封装，对象的全部属性和操作结合在一起，形成一个整体B.通过封装，ー个对象的实现细节被尽可能地隐藏起来（不可见）C.通过封装，每个对象都成为相对独立的实体D.通过封装，对象的属性都是不可见的87.面向对象方法的多态性是指（）。A.ー个类可以派生出多个特殊类B.ー个对象在不同的运行环境中可以有不同的变体C.针对ー消息，不同的对象可以以适合自身的方式加以响应D,ー个对象可以是山多个其他对象组合而成的97.软件产品在需求发生变化、运行环境发生变化或发现软件产品本身的错误或不足时进行相应的软件更新的难易程度叫做软件的（）。A.可维护性B.可复用性C.兼容性D.正确性98.软件产品可被全部或部分地再用于新的应用的能力叫做软件的（）。A.可维护性B.可复用性C.兼容性D.正确性

997.软件产品与其他软件产品组合成一个整体的难易程度叫做软件的（）。A.可维护性B.可复用性C.兼容性D.正确性98.软件产品准确执行软件需求规格说明书中所规定的任务的能力叫做软件的（）。A.可维护性B.可复用性C.兼容性D.正确性99.面向对象软件开发中使用的00A表示（）。A.面向对象分析B.面向对象设计C,面向対象语言D,面向对象方法100.面向对象软件开发中使用的00D表示（）。A,面向对象分析B.面向对象设计C.面向对象语言D.面向对象方法101.关于面向对象系统分析,下列说法中不正确的是（）。A,术语“面向对象分析”可以用缩写OOA表示B.面向対象分析阶段对问题域的描述比实现阶段更详细C.面向対象分析包括问题域分析和应用分析两个步骤D.面向対象分析需要识别対象的内部和外部特征102.在ー个类的定义中,包含有（）成员的定义。A.数据B,函数C.数据和函数D.数据或函数103.在类作用域中能够通过直接使用该类的（）成员名进行访问。A,私有B,公用C.保护D,任何104.在关键字public后面定义的成员为类的（）成员。A,私有B,公用C.保护D1任何105.在关键字private后面定义的成员为类的（）成员。A,私有B,公用C.保护D.任何106.假定AA为ー个类,a为该类公有的数据成员，x为该类的ー个対象,则访问x対象中数据成员a的格式为（）。A.x（a）B.x[a]C.x->aD.x.a107.假定AA为一个类，a（）为该类公有的函数成员，x为该类的ー个対象，则访问x対象中函数成员a（）的格式为（）。A.x.aB.x.a（）C.x->aD.x->a（）108.假定AA为ー个类，a为该类公有的数据成员，px为指向该类対象的一个指针，则访问px所指対象中数据成员a的格式为（）。A.px（a）B.px[a]C.px->aD.px.a109.假定AA为ー个类,a为该类私有的数据成员,GetValueO为该类公有函数成员,它返回a的值,x为该类的ー个対象,则访问x対象中数据成员a的格式为（）。A.x.aB.x.a（）C.x->GetValue（）D.x.GetValueO110.假定AA为ー个类,inta（）为该类的一个成员函数,若该成员函数在类定义体外定义，则函数头为（）。A.intAA::a（）B.intAA:aOC.AA::a（）D.AA::inta0111.假定AA为ー个类,a为该类公有的数据成员,若要在该类的一个成员函数中访问它,则书写格式为（）。A.aB.AA::aC.a（）D.AA::a（）112.若需要把ー个类外定义的成员函数指明为内联函数,则必须把关键字（）放在函数原型或函数头的前面。A.inB.inlineC.inLineD.InLiner113.在多文件结构的程序中，通常把类的定义单独存放于（）中。

10A,主文件B.实现文件C.库文件D.头文件97.在多文件结构的程序中，通常把类中所有非内联函数的定义单独存放于（）中。A,主文件B.实现文件C.库文件D.头文件98.在多文件结构的程序中,通常把含有main。函数的文件称为（）.A.主文件B.实现文件C.程序文件D.头文件99.一个C++程序文件的扩展名为（）。A..hB..cC..cppD..cp119.在C++程序中使用的cin标识符是系统类库中定义的（）类中的ー个对象。A.istreamB.ostreamC.iostreamD.fstream120.在C++程序中使用的cout标识符是系统类库中定义的（）类中的ー个对象。A.istreamB.ostreamC.iostreamD.fstream121.假定AA是ー个类,abc是该类的ー个成员函数,则参数表中隐含的第一个参数的类型为（）。A.intB.charC.AAD.AA*122.假定AA是ー个类,abc是该类的ー个成员函数,则参数表中隐含的第一个参数为（）。A.abcB.*thisC.thisD.this&123.假定AA是ー个类，“AA&abc（）;”是该类中一个成员函数的原型，若该函数存在对・this赋值的语句,当用x.abc（）调用该成员函数后，x的值（）。A,已经被改变B.可能被改变C.不变D.不受函数调用的影响124.假定AA是ー个类,"AA*abcOconst;”是该类中一个成员函数的原型,若该函数返回this值,当用x.abc（）调用该成员函数后,x的值（）。A,已经被改变B.可能被改变C.不变D.受到函数调用的影响125.类中定义的成员默认为（）访问属性。A.publicB.privateC.protectedD.friend126.结构中定义的成员默认为（）访问属性。A.publicB.privateC.protectedD.friend127.当类中一个字符指针成员指向具有n个字节的存储空间时,它所能存储字符串的最大长度为（）。A.nB.n+1C.n-1D.n-2128.在ー个用数组实现的队列类中,假定数组长度为MS,队首元素位置为first,队列长度为!ength,则队尾（即最后ー个）元素的位置为（）。A.length+1B.first+lengthC.（first+length-l）%MSD.（first+length）%MS129,在ー个用数组实现的队列类中,假定数组长度为MS,队首元素位置为first,队列长度为length,则队尾的后一个位置为（）。D.length+1B.first+lengthE.（first+length-l）%MSD.（first+length）%MS130,在ー个用数组实现的队列类中,假定数组长度为MS,队首元素位置为first,队列长度为length,则队首的后一个位置为（）.F.first+1B.（first+l）%MSG.（first-l）%MSD.（first+length）%MS131.在一个用链表实现的队列类中,假定每个结点包含的值域用elem表示,包含的指针域用next表示，链队的队首指针用elemHead表示,队尾指针用elemTail表示,若链队非空,则进行插入时必须把新结点的地址赋给（）.A.elemlleadB.elemTail

11C.elemHead->next和elemHeadD.elemTail->next和elemTail131.在ー个用链表实现的队列类中,假定每个结点包含的值域用elem表示,包含的指针域用next表示,链队的队首指针用elemHead表示,队尾指针用elemTail表示,若链队为空,则进行插入时必须把新结点的地址赋给（）〇A.elemHeadB.elemTailC.elemHead和elemTailD.elemHead或elemTail132.队列具有（）的操作特性。A.先进先出B.先进后出C.进出无序D1进出任意133.栈具有()的操作特性。A,先进先出B.先进后岀C.进岀无序D,进岀任意134.对于ー个类的构造函数,其函数名与类名()»A,完全相同B.基本相同C,不相同D.无关系135.对于ー个类的析构函数,其函数名与类名()〇A,完全相同B.完全不同C.只相差ー个字符D.无关系136.类的构造函数是在定义该类的一个()时被自动调用执行的。A.成员函数B.数据成员C.对象D,友元函数137.类的析构函数是一个对象被()时自动调用的。A,建立B.撤消C.赋值D.引用138.ー个类的构造函数通常被定义为该类的()成员。A,公用B.保护C.私有D.友元139.ー个类的析构函数通常被定义为该类的()成员。A.私有B.保护C.公用D.友元140.假定AB为一个类，则执行“ABx;”语句时将自动调用该类的()。A.带参构造函数B.无参构造函数C.拷贝构造函数D.赋值重载函数141.假定AB为ー个类，则执行“ABx(a,5);”语句时将自动调用该类的()。A.带参构造函数B.无参构造函数C.拷贝构造函数D.赋值重载函数142.假定AB为一个类,则执行"AB*s=newAB(a,5);“语句时得到的ー个动态对象为。A.sB.s->aC.s.aD.*s143.假定AB为ー个类，则执行“ABrl=r2;”语句时将自动调用该类的()。A.无参构造函数B,带参构造函数C.赋值重载函数D.拷贝构造函数144.若需要使类中的一个指针成员指向ー块动态存储空间,则通常在()函数中完成。A.析构B.构造C.任一成员D.友元145.当类中的ー个整型指针成员指向ー块具有n*sizeof(int)大小的存储空间时，它最多能够存储()个整数。A.nB.n+1C.n-lD.1146.假定一个类的构造函数为"A(intaa,intbb){a=aa;b=aa*bb;}M,则执行"Ax(4,5);”语句后,x.a和x.b的值分别为()。A.4和5B.5和4C.4和20D.20和5147.假定一个类的构造函数为“A(intaa=l,intbb=0){a=aa;b=bb;}"，则执行“Ax(4);”语句后，x.a和x.b的值分别为()。A.1和0B.1和4C.4和1D.4和0148.假定AB为ー个类,则()为该类的拷贝构造函数的原型说明。A.AB(ABx);B.AB(AB&x);C.voidAB(AB&x);D.AB(intx);149.假定一个类的构造函数为"B(intax,intbx):a(ax),b(bx){}nt执行"Bx(L2),y(3,4);x=y;”语句序列后x.a的值为().A.1B.2C.3D.4150.假定一个类AB只含有一个整型数据成员a,当用户不定义任何构造函数时，系统为该类

12定义的无参构造函数为()。A.AB(){a=0;}B.AB(intaa=0):a(aa){}C.AB(intaa):a(aa){}D.AB(){}131.假定一个类AB只含有一个整型数据成员a,用户为该类定义的带参构造函数可以为(A.ABO{}B.ABO:a(0){}C.AB（intaa=O）{a=aa;}D.AB（intaa）{}153.对于任一个类,用户所能定义的构造函数的个数至多为（）«A.0B.1C.2D.任意个154.对于任一个类,用户所能定义的析构函数的个数至多为（）«A.0B.1C.2D.任意个155.假定AB为一个类,则执行"AB*px=newAB[n];”语句时将（）〇A.动态分配ー个数组B.动态分配ー个对象C,静态分配ー个数组D,静态分配ー个对象156.设px是指向ー个类对象的指针变量,则执行“deletepx;”语句时,将自动调用该类的（）«A.无参构造函数B,带参构造函数C.析构函数D.拷贝构造函数157.当ー个类对象离开它的作用域时，系统自动调用该类的（）«A.无参构造函数B.带参构造函数C.拷贝构造函数D,析构函数158.假定一个类对象数组为A[n],当离开它定义的作用域时,系统自动调用该类析构函数的次数为（）«A.0B.1C.nD.n-1159.假定AB为ー个类,则执行“ABa[10];”语句时调用该类无参构造函数的次数为（）.A.0B.1C.9D.10160.假定AB为一个类,则执行"AB*px=newAB[n];”语句时调用该类无参构造函数的次数为（）«A.nB.n-1C.1D.0161.假定AB为一个类，则执行“ABa,b（3）,*p;”语句时共调用该类构造函数的次数为（）.A.2B.3C.4D.5162.假定AB为一个类，则执行“ABa（2）,b[3],*p[4];”语句时共调用该类构造函数的次数为（）.A.3B.4C.5D.9163.假定AB为ー个类,则执行“ABa,b（2）,c[3],*p=&a;"语句时共调用该类无参构造函数的次数为（）.A.5B.6C.3D.4164.假定AB为ー个类,则执行“AB*p=newAB（l,2）;”语句时共调用该类构造函数的次数为（）»A.0B.1C.2D.3165.假定AB为ー个类,px为指向该类的ー个含有n个对象的动态数组的指针,则执行“deleteロpx;”语句时共调用该类析构函数的次数为（）〇A.0B.1C.nD.n+1166.对类对象成员的初始化是通过构造函数中给出的（）实现的。A.函数体B.初始化表C.参数表D.初始化表或函数体167.对类中常量成员的初始化是通过构造函数中给出的（）实现的。A.函数体B.参数表C.初始化表D.初始化表或函数体

13153.对类中引用成员的初始化是通过构造函数中给出的（）实现的。A.函数体B.参数表C.初始化表D.初始化表或函数体154.类的构造函数可以带有（）个参数。A.0B.1C.2D.任意155.类的析构函数可以带有（）个参数。A.0B.1C.2D.任意156.ー个类的静态数据成员所表示属性（）«A,是类的或对象的属性B.只是对象的属性C.只是类的属性D.类和友元的属性157.类的静态成员的访问控制（）。A,只允许被定义为privateB,只允许被定义为private或protectedC.只允许被定义为publicD.可允许被定义为private、protected或public173.静态成员函数对类的数据成员访问（）。A,是不允许的B.只允许是静态数据成员C,只允许是非静态数据成员D.可允许是静态数据成员或非静态数据成员174.被非静态成员函数访问的类的数据成员（）。A.可以是非静态数据成员或静态数据成员B.不可能是类的静态数据成员C,只能是类的非静态数据成员D.只能是类的静态数据成员175.静态数据成员的初始化是在（）中进行的。A.构造函数B.任何成员函数C.所属类D.全局区176.当将一个类A或函数f（）说明为另ー个类B的友元后,类A或函数f（）能够直接访问类B的（）。A,只能是公有成员B.只能是保护成员C,只能是除私有成员之外的任何成员D.具有任何权限的成员177.引入友元的主要目的是为了（）.A,增强数据安全性B.提高程序的可靠性C,提高程序的效率和灵活性D.保证类的封装性178.ー个类的成员函数也可以成为另ー个类的友元函数,这时的友元说明（）«A,需加上类域的限定B.不需加上类域的限定C.类域的限定可加可不加D.不需要任何限定179.ー个类的友元不是该类的成员，与该类的关系密切，所以它（）。A,有this指针，有默认操作的对象B.没有this指针,可以有默认操作的对象C.有this指针，不能执行默认操作D.没有this指针,也就没有默认操作的对象180.在重载ー个运算符时,其参数表中没有任何参数，这表明该运算符是（）〇A.作为友元函数重载的1元运算符B.作为成员函数重载的1元运算符C.作为友元函数重载的2元运算符D.作为成员函数重载的2元运算符181.在成员函数中进行双目运算符重载时,其参数表中应带有（）个参数。A.0B.1C.2D.3182.双目运算符重载为普通函数时，其参数表中应带有（）个参数。A.0B.1C.2D.3183.如果表达式a+b中的“+”是作为成员函数重载的运算符，若采用运算符函数调用格式,则可表示为（）。A.a.operator+（b）B.b.operator+（a）C.operator+（a,b）D.operator（a+b）184.如果表达式a==b中的“=”是作为普通函数重载的运算符，若采用运算符函数调

14用格式,则可表示为（）。A.a.operator=（b）B.b.operator==（a）C.operator==（a,b）D.operator==（b,a）181.如果表达式a++中的“++”是作为普通函数重载的运算符,若采用运算符函数调用格式,则可表示为（）。A.a.operator++()B.operator++(a)C.operator++(a,1)D.operator++(l,a)186,如果表达式++a中的“++”是作为成员函数重载的运算符,若采用运算符函数调用格式,则可表示为()。A.a.operator++(l)B.operator++(a)C.operator++(a,1)D.a.operator++()187.关于运算符重载，下列说法正确的是()。A,重载时,运算符的优先级可以改变。B,重载时,运算符的结合性可以改变。C,重载时,运算符的功能可以改变。D.重载时,运算符的操作数个数可以改变。188.关于运算符重载，下列说法正确的是()。A,所有的运算符都可以重载。B,通过重载,可以使运算符应用于自定义的数据类型。C,通过重载,可以创造原来没有的运算符。I),通过重载,可以改变运算符的优先级。189.ー个程序中数组a和变量k定义为“inta[5][10],k;",且程序中包含有语句“a(2,5)=++k*3;”，则此语句中肯定属于重载操作符的是()〇A.()B.=C.++D.*190.假定K是ー个类名,并有定义’'Kk;intj;M,已知K中重载了操作符()，且语句“j=k⑶；”和"k句)=99;”都能顺利执行,说明该操作符函数的原形只可能是()〇A.Koperator()(int);B.intoperator()(int&);C.int&operator()(int);D.K&operator()(int);191.假定M是一个类名,且M中重载了操作符=,可以实现M对象间的连续赋值,如"ml=m2=m3;"。重载操作符=的函数原型最好是()。A.intoperaotor=(M);B.intoperator=(M&);C.Moperator-(M&);D.M&operator=(M);192.下面是重载双目运算符+的普通函数原形,其中最符合+原来含义的是()。A.Valueoperator+(Value,Value);B.Valueoperator+(Value,int);C.Value&operator+(Value,Value);D.Value&operator+(Value&,Value&);193.下面是重载双目运算符-的成员函数原形,其中最符合一原来含义的是()。A.ValueValue::operator-(Value);B.ValueValue::operator-(int);C.ValueftValue::operator-(Value);D.Value&Value::operator-(Value&);194,在重载ー运算符时,若运算符函数的形参表中没有参数,则不可能的情况是()。A.该运算符是ー个单目运算符。B.该运算符函数有一个隐含的参数this。C.该运算符函数是类的成员函数。D.该运算符函数是类的友元函数。195.关于插入运算符《的重载,下列说法不正确的是()。A.运算符函数的返回值类型是ostream&。B.重载的运算符必须定义为类的成员函数。

15C.运算符函数的第一个参数的类型是ostream&。D,运算符函数有两个参数。195.从一个基类派生出的各个类的对象之间()。A.共享所有数据成员,每个对象还包含基类的所有属性B,共享部分数据成员,每个对象还包含基类的所有属性

16C,不共享任何数据成员,但每个对象还包含基类的所有属性D.共享部分数据成员和函数成员195.如果是类B在类A的基础上构造,那么,就称（）。A.类A为基类或父类,类B为超类或子类B.类A为基类、父类或超类,类B为派生类或子类C.类A为派生类,类B为基类D.类A为派生类或子类,类B为基类、父类或超类198.C++的继承性允许派生类继承基类的（）。A.部分特性,并允许增加新的特性或重定义基类的特性B,部分特性，但不允许增加新的特性或重定义基类的特性C,所有特性，并允许增加新的特性或重定义基类的特性D,所有特性,但不允许增加新的特性或重定义基类的特性199.派生类的成员函数可以直接访问基类的（）成员。A,所有B.公有和保护C.保护和私有D.私有200.对于公有继承,基类的公有和保护成员在派生类中将（）成员。A.全部变成公有B.全部变成保护C.全部变成私有D.仍然相应保持为公有和保护201.对于公有继承，基类中的私有成员在派生类中将（）»A,能够直接使用成员名访问B.能够通过成员运算符访问C,仍然是基类的私有成员D.变为派生类的私有成员202.当保护继承时，基类的（）在派生类中成为保护成员,在类作用域外不能够通过派生类的対象来直接访问该成员。B.公有成员和保护成员D.私有成员A.任何成员C.保护成员和私有成员203,在定义ー个派生类时，若不使用保留字显式地规定采用何种继承方式,则默认为）方式。B.非私有继承A.私有继承C.保护继承D,公有继承204,建立包含有类对象成员的派生类对象时,自动调用构造函数的执行顺序依次为（）的构造函数。A.自己所属类、对象成员所属类、基类B.对象成员所属类、基类、自己所属类C.基类、对象成员所属类、自己所属类D.基类、自己所属类、对象成员所属类205.当派生类中有和基类一样名字的成员时,一般来说,（）。A,将产生二义性B.派生类的同名成员将覆盖基类的成员C,是不能允许的D.基类的同名成员将覆盖派生类的成员206.C++中的虚基类机制可以保证:（）。A,限定基类只通过一条路径派生出派生类B.允许基类通过多条路径派生出派生类,派生类也就能多次继承该基类C.当ー个类多次间接从基类派生以后,派生类对象能保留多份间接基类的成员D,当ー个类多次间接从基类派生以后,其基类只被一次继承207.下列对派生类的描述中错误的说法是:（）。A,派生类至少有一个基类B.派生类可作为另ー个派生类的基类

17C.派生类除了包含它直接定义的成员外，还包含其基类的成员D.派生类所继承的基类成员的访问权限保持不变205.派生类的对象对其基类中（）可直接访问。A.公有继承的公有成员B,公有继承的私有成员C,公有继承的保护成员D.私有维承的公有成员二、判断题1.C++中标识符内的大小写字母是没有区别的。（F）2.C++是ー种以编译方式实现的高级语言。（T）3.计算函数参数顺序引起的二义性是由不同的编译系统决定的。（T）4.返回值类型、参数个数和类型都相同的函数也可以重载。（F）5.使用关键字class定义的类中缺省的访问权限是私有（private）的。（T）6.类的私有成员只能被类中的成员函数访问,任何类以外的函数对它们的访问都是非法的。（F）7.多继承情况下,派生类的构造函数的执行顺序取决于成员初始化列表中的顺序。（F）8.在公有继承中,基类中的公有成员和私有成员在派生类中都是可见的。（F）9.在私有继承中，基类中所有成员对派生类都是不可见的。（F）10.在保护继承中,对于垂直访问等同于公有继承，对于水平访问等同于私有继承。（T）11.构造函数可以声明为虚函数。（F）12.在析构函数中调用虚函数时,采用动态束定。（F）13.在ー个成员函数内调用ー个虚函数时,对该虚函数的调用进行动态束定。（T）14.公有继承可以实现子类型。（T）15.构造函数可以声明为纯虚函数。（F）16.说明函数原型时不需要指明每个函数参数的名字，只需要说明每个参数的类型和返回值类型就可以了。对17.所有的表达式都有值。错18.程序的编译是以文件为单位的，因此将程序分到多个文件中可以减少每次对程序修改所带来的编译工作量。对19.类的静态数据成员需要在定义每个类的对象时进行初始化。错20.基类中被说明为protected和private的成员只能被其派生类的成员函数访问，不能被其它的函数访问。错21.当将一个类S定义为另ー个类A的友元类时,类S的所有成员函数都可以直接访问类A的所有成员。对22.当函数的返回值是数组类型的，传递的是数组第•个元素的地址。错23.如果派生类的成员函数的原型与基类中被定义为虚函数的成员函数原型相同，那么，这个函数自动继承基类中虚函数的特性。对24.字符串’hello,world”在内存中存放时,占用11个字节的空间。错25.用new动态申请的内存空间，必须用delete来释放。对26.静态数据成员必须在类外定义和初始化。（V）27.保护继承时，派生类中的成员函数可以直接访问基类中的protected成员。（丿）28.静态成员函数可以引用属于该类的任何函数成员。（X）29.指针常量可以指向相应类型的常量。（7）30.友元函数是在类声明中由关键字friend修饰说明的类的成员函数。（X）

181.如果程序中未声明构造函数，则系统自动产生出ー个默认形式的构造函数。（V）2.友元函数访问对象中的成员可以不通过对象名（X）3.如果程序中未声明析构函数，编译器将自动产生一个默认的析构函数。（ノ）4.类中的成员数据可以是另ー个类的对象。(V)5.常弓I用做形参,在函数屮不能更新所引用的对象。36.虚函数不能是类的静态成员。对7.重定义虚函数的派生类必须是公有继承的。对8.对于从基类继承的虚函数,派生类也可以不进行重定义。对9.纯虚函数与函数体为空的虚函数等价。错10.多态类提供了一种动态多分支派送机制。对11.作为虚函数隐含参数的this指针,决定了虚函数调用时执行的代码。对三、填空题1.C++语言是在语言的基础上发展起来的。2.C++语言的编译单位是扩展名为的文件。3.行尾使用注释的开始标记符为。4.多行注释的开始标记符和结束标记符分别为ー一和ー5.用于输出表达式值的标准输出流对象是。6,用于从键盘上为变量输入值的标准输入流对象是。7.一个完整程序中必须有一个名为的函数。8.ー个函数的函数体就是一条语句。9.当执行cin语句时,从键盘上输入每个数据后必须接着输入ー个符,然后才能继续输入下ー个数据。10.在C++程序中包含ー个头文件或程序文件的预编译命令为。11.程序中的预处理命令是指以字符开头的命令。12.一条表达式语句必须以作为结束符。13.在#include命令中所包含的头文件，可以是系统定义的头文件,也可以是ー定义的头文件。14.使用#include命令可以包含ー个头文件,也可以包含ー个文件。15.ー个函数定义由和两部分组成。16.若一个函数的定义处于调用它的函数之前,则在程序开始可以省去该函数的ー语句。17.C++头文件和源程序文件的扩展名分别为和一18.程序文件的编译错误分为和两类。19.当使用ー_保留字作为函数类型时,该函数不返回任何值。20.当函数参数表用保留字表示时,则表示该参数表为空。21.从一条函数原型语句“intfunl(void);”可知,该函数的返回类型为.„,该函数带有个参数。22.当执行cout语句输出endl数据项时,将使C++显示输出屏幕上的光标从当前位置移动到的开始位置。23.假定x=5,y=6,则表达式x++*++y的值为=24.假定x=5,y=6,则表达式x—*—y的值为〇25.假定x=5,y=6,则执行表达式y*=x++计算后,x和y的值分别为和26.假定x=5,y=6,则执行表达式y+=xー计算后,x和y的值分别为一和

197.C++常数0x145对应的十进制值为ー。8.C++常数0345对应的十进制值为。9.十进制常数245对应的十六进制的C++表示为ー10.十进制常数245对应的ハ进制的C++表示为〇11.signedchar类型的值域范围是至之间的整数。12.ini和float类型的数据分别占用ー一和一ー个字节。13.float和double类型的数据分别占用ー_和个字节。14.boo!和char类型的数据分别占用和个字节。15.unsignedshortint和int类型的长度分别为和,16.字符串"This、’sabook.

20"的长度为〇17.字符串"、nThisヽ’sapen

21

22"的长度为«18.在C++中存储字符串”abcdef"至少需要个字节。19.在C++中存储字符串”a+b=c”至少需要个字节。20.假定x和y为整型,其值分别为16和5I则xy和x/y的值分别为和21.假定x和y为整型,其值分别为16和5,则x/y和double(x)/y的值分别为和.22.假定x是ー个逻辑量，则xtrue的值为»23.假定x是一个逻辑量，则x||true的值为。24.假定x是ー个逻辑量，则xfalse的值为«25.假定x是一个逻辑量，则x||false的值为.26.假定x是一个逻辑量，则!xfalse的值为〇27.假定x是ー个逻辑量，则x!x的值为。28.假定x是ー个逻辑量，则x||!x的值为〇29.数学算式モ土ッ的C++表达式为〇2xy30.数学算式网L的C++表达式为。x+y31.数学算式々~T的C++表达式为〇ax+by32.设enumPrintstatus{ready,busy,error}:则cout«busy的输出结果是33.设enumPrintstatus{ready=2,busy,error}:则cout«busy的输出结果是34.常数ー4.205和6.7E-9分别具有和位有效数字。35.枚举类型中的每个枚举值都是一个ー_,它的值为一个ー_•36.常数!00和3.62的数据类型分别为和«37.若x=5,y=10,则计算y*=++x表达式后,x和y的值分别为ー一和ー38.假定x和ch分别为int型和char型，则sizeof(x)和sizeof(ch)的值分别为ー和〇39.假定x=10,则表达式x<=10?20:30的值为。40.表达式sqrt(81)和pow(6,3)的值分别为和«41.含随机函数的表达式rand()20的值在至区间内。42.在switch语句中,每个语句标号所含关键字case后面的表达式必须是〇43.在if语句中，每个else关键字与它前面同层次并且最接近的关键字相配套。44.作为语句标号使用的C++保留字case和defaule只能用于语句的定义体

23中。7.执行switch语句时,在进行作为条件的表达式求值后，将从某个匹配的标号位置起向下执行,当碰到下一个标号位置时（停止/不停止）执行。8.若while循环的“头”为“while（i++く=10）”,并且i的初值为〇,同时在循环体中不会修改i的值，则循环体将被重复执行.次后正常结束。9.若do循环的“尾”为“while（++i如〇）”,并且i的初值为0,同时在循环体中不会修改i的值,则循环体将被重复执行次后正常结束。10.当在程序中执行到语句时,将结束本层循环类语句或switch语句的执行。11.当在程序中执行到语句时，将结束所在循环语句中循环体的ー次执行。12.在程序中执行到语句时,将结束所在函数的执行过程，返回到调用该函数的位置。13.在程序执行完函数调用后，将结束整个程序的执行过程，返回到C++集成开发窗口。14.元素类型为int的数组a[10]共占用字节的存储空间。15.元素类型为double的二维数组a[4][6]共占用字节的存储空间。16.元素类型为char的二维数组a[10][30]共占用字节的存储空间。17.存储字符‘a,和字符串"a”分别需要占用和个字节。18.空串的长度为,存储它需要占用ー个字‘忆19.字符串”''a\'xy=4

24”的长度为。20.字符串”a:\\xxk\'数据”的长度为。21.用于存储ー个长度为n的字符串的字符数组的长度至少为。22.若a是一个字符数组，则从键盘上向该数组输入ー个字符串的表达式为23.若a是ー个字符数组，则向屏幕输出a中所存字符串的表达式为。24.一个二维字符数组a[10][20]能够存储个字符串，每个字符串的长度至多为025.对一个二维字符数组a进行初始化的数据为{”123”，”456","789"}»则a[l]元素对应的字符串为。26.strlen（”apple”）的值为,strcmpCa","A"）的值为。27.若需要把一个字符串”aaa”赋值到字符数组a中，则需要执行函数的调用来实现。28.假定对数组a口进行初始化的数据为的7,9,6,5,7,10},则a[2]和a[5]分别被初始化为和。29.假定对二维数组a[3][4]进行初始化的数据为{{3,5,6},{2,8},{7}},则aロ][1]和a[2][3]分别被初始化为和。87.在C++语言中，ー个函数由函数头和组成。88,亜载ー个函数的条件是:该函数必须在参数的个数或参数的上与其它同名函数有所不同。89.如果一个函数只允许同一程序中的函数调用，则应在该函数定义前加上C++保留字。90.若“doublex=100;"是文件Fl.CPP中的ー个全局变量定义语句,若文件F2.CPP中的某个函数需要访问此x,则应在文件F2.CPP中添加对x的声明语句为91.定义ー个函数模板要用到的第一个修饰符是。92.在函数模板的参数中,用class修饰的参数称为参数。93.如果ー个函数直接或间接地调用自身，这样的调用称为调用。94.已知intcubin（intn）{returnn*n*n;}和doublecubin（doublen）{returnn*n*n;}是ー个函数模板的两个实例,假定类型参数用T

25表示,则该函数模板的定义是«89.对于无返回值函数,定义函数时要用修饰函数类型。90.如果ー个函数定义中使用了修饰,则该函数不允许被其它文件中的函数调用。91.如果ー个函数中有多个默认参数,则默认参数必须全部处在形参表的部分。92.定义外部变量时,不用存储类说明符,而声明外部变量时用它。93.调用系统函数时，要先使用#include命令包含该系统函数的原型语句所在的94.函数形参的作用域是该函数的。95.C++提供的预处理命令有宏定义命令,条件编译命令和一,«96.程序的编译是以为单位进行的。97.C++程序运行时的内存空间可以分成全局数据区,堆区,栈区和。98.全局变量和静态局部变量具有静态生存期,存放在内存的区中。99.局部变量具有局部生存期,存放在内存的区中。100.若二维数组a有m歹。,设a[〇][〇]位于数组的第•个位置上,则计算任一元素在数组中位置序号的公式为ーー。107,若有定义(

26108.假定一个二维数组为c[5][8],则c[3]的值为二维元素的地址,c[3]+2的值为二维元素的地址。109.假定p为指向二维数组intd[4][6]的指针,则p的类型为。110.假定a是一个二维数组,则的指针访问方式为ー。111.若要把整型变量y定义为x的引用,则所使用的定义语句为。112.若y是x的引用,则对y的操作就是对的操作。113.若y是x的引用,则y和x的值,即为变量的地址。114.执行intp=newint操作得到的ー个动态分配的整型对象为.ー。115.执行int*p=newinl[10]操作,使p指向动态分配的数组中下标为〇的元素,该元素可表示为或。116.执行char*p=newchar('a')操作后,p所指向的数据对象的值为«117.执行newchar[m][n]操作时的返回值的类型为0118.执行操作将释放由p所指向的动态分配的数据空间。119.执行操作将释放由p所指向的动态分配的数组空间。120.NULL是ー个符号常量,通常作为空指针值,它的具体值为〇121.变量v定义为"doublev=23.4;”,要使指针pv指向v,则定义pv的语句为122.已知语句“coutくくp;”的输出是“Hello!”,则语句"coutく＜・p;“输出的是123.已知语句“coutくくs;"的输出是“apple”,则执行语句"coutくくs+2;"的输出结果为0124.指针变量pv和pc定义为avoid*pv-"Hello,word!,r;char*pc;"J要将pv值赋给pc,则正确的赋值语句是〇125.数组a定义为“inta[100];"I要使p[j]与a[j]等效,则指针p应定义为〇int*p=a;(或:int*p=a[〇];)126.数组b定义为“intb[20][100];"l要使p[j][k]与b[j][k]等效,则指针p应定义为»127.与结构成员访问表达式pー〉name等价的表达式是。128.与结构成员访问表达式(*fp).score等价的表达式是。129.已知变量a定义为“inta=5;",要使ra成为a的引用,则ra应定义为130.已知有定义“intx,a[]={5,7,9},*pa=a;",在执行"x=++*pa;"语句后,x的值是。131.已知有定义“intx,a[]={6,10,12},*pa=a;",在执行“x=*++pa;“语句后,*pa的值是〇132.已知有定义“intx,a[]={15,17,19),*pa=a;",在执行"x=*pa++;”后,*pa的值是0133.以面向对象方法构造的系统,其基本单位是。134.每个对象都是所属类的ー个。135.对象将其大部分实现细节隐藏起来,这种机制称为«136.基类和派生类的关系称为。137.复杂对象可以山简单对象构成,这种现象称为。138.对象是对问题城中客观事物的,它是ー组属性和在这些属性上操作的139.特殊类的对象拥有其一般类的全部属性与操作,称特殊类了一般类。140.如果一个派生类的基类不止ー个,则这种继承称为〇141.如果ー个派生类只有一个唯一的基类,则这样的继承关系称为。142.C++支持两种多态性:时的多态性和时的多态性。

27108.在C++中,编译时的多态性是通过实现的,而运行时的多态性则是通过实现的。109.面向对象软件开发的生命周期分为三个阶段,即分析、和〇110.面向対象的分析包括分析和分析两步。111.类定义中,既包含数据成员,也包含成员。112.类中的数据成员的访问属性通常被指明为.113.类中的供外部调用定义的函数成员,其访问属性通常被定义为〇114.对于类中定义的任何成员，其隐含访问权限为0115.对于结构中定义的任何成员，其隐含访问权限为«116.为了使类中的成员不能被类外的函数通过成员操作符访问，则应把该成员的访问权限定义为〇117.若在类的定义体中给出了一个成员函数的完整定义，则该函数属于函数。118.若在类的定义体中只给出了一个成员函数的原型，则在类外给出完整定义时，其函数名前必须加上和两个冒号分隔符。119.若在类的定义体中只给出了一个成员函数的原型，则在类外给出完整定义时，其函数名前必须加上类名和两个分隔符。120.若要把类外定义的成员函数规定为内联函数，则必须把关键字放到函数原型或函数头的前面。121.把一个类的定义体和所有成员函数的定义体所构成的程序范围叫做该类的122.假定AA是一个类，“AA*abc();”是该类中一个成员函数的原型，则在类外定义时的函数头为.123.成员函数的参数表在类作用域中，成员函数的返回值类型类作用域中。124.为了避免在调用成员函数时修改对象中的任何数据成员，则应在定义该成员函数时，在函数头的后面加上关键字。125.若只需要通过ー个成员函数读取数据成员的值，而不需要修改它，则应在函数头的后面加上关键字。126.若采用x.abc(y)表达式调用一个成员函数,在成员函数中使用的就代表了类外的x对象。127.若采用p->abc(y)表达式调用一个成员函数，在成员函数中使用的就代表了类外的P指针。128.内联函数的定义模块与模块必须放在同一个文件中。129.假定AA是ー个类，"AA*abc()const;”是该类中一个成员函数的原型,在该函数体中(能够/不能够)向・this或其成员赋值。130.在一个用数组实现的队列类中，包含有两个数据成员,ー个指明队首元素位置,另ー个指明〇131.在ー个用数组实现的队列类中,包含有两个数据成员,ー个指明队列长度，另ー个指明元素的位置。132.在一个用数组实现的队列类中,假定数组长度为MS,队首元素位置为first,队列长度为length,则插入一个新元素的位置为.133.在一个用数组实现的队列类中，假定数组长度为MS,队首元素位置为first,队列长度为length,则删除ー个元素后队首的位置为»134.在ー个用数组实现的队列类中，假定数组长度为MS,队首元素位置为first,队列长度为length,则队列为空的条件为«135.在ー个用数组实现的队列类中，假定数组长度为MS,队首元素位置为first,队列长度为length,则队列为满的条件为«136.当ー个队列为空时，不能对其做元素的操作。137.当ー个队列为满时，不能对其做元素的操作。

28108.从ー个队列中删除元素就是删除位置上的元素。109.向ー个队列中插入元素就是把该元素放到元素的后一位置上。110.在・个用链表实现的队列类中,假定每个结点包含的值域用elem表示,包含的指针域用next表示，链队的队首指针用elemHead表示，队尾指针用elemTai!表示,当链队非空时，指向队首结点的后继（即下ー个）结点。196,在一个用链表实现的队列类中,假定每个结点包含的值域用elem表示，包含的指针域用next表示,链队的队首指针用elemHead表示，队尾指针用elemTai!表示,当链队非空时，新插入结点的地址应当赋给所指结点的next域。197.在ー个用链表实现的队列类中，队尾结点的指针域的值为。198,在一个用链表实现的队列类中,若链队中只含有一个结点,则队首指针的值与队尾指针的值。199,在一个用链表实现的队列类中，若链队为空或只含有一个结点,则队首指针的值与队尾指针的值〇200,在ー个用链表实现的队列类中，若队首指针与队尾指针的值不同，则说明链队中至少包含有个结点。201.ー个类的函数实现对该类对象的初始化功能。202.ー个类的函数通常用于实现释放该类对象中指针成员所指向的动态存储空间的任务。203.当用户为ー个类定义有时，则系统不会为该类再自动生成一个默认构造函数。204.假定用户没有给ー个名为AB的类定义构造函数,则系统为其定义的构造函数为205.假定用户没有给ー个名为AB的类定义析构函数,则系统为其定义的析构函数为206.定义类动态对象数组时，其元素只能靠自动调用该类的来进行初始化。207.在ー个类中定义拷贝构造函数的目的，是为了当利用该类的ー个对象初始化另一个对象时,能够避免这两个对象的同一指针同时指向同一块。208.为了释放类对象中指针成员所指向的动态存储空间，则需要为该类定义209.假定AB为一个类,则执行“ABa[10];”语句时，系统自动调用该类构造函数的次数为〇210.假定一个类对象数组为A[N],当离开它的作用域时，系统自动调用该类析构函数的次数为。211.对类中对象成员的初始化是通过在构造函数中给出的来实现的。212.对类中常量成员的初始化是通过在构造函数中给出的来实现的。213.对类中引用成员的初始化只能通过在构造函数中给出的来实现。214.对类中一般数据成员的初始化既可以通过在构造函数中给出的初始化表来实现，也可以通过构造函数中的来实现。215.假定要把aa定义为AB类中的ー个常量整数型数据成员,则定义语句为216.假定要把aa定义为AB类中的ー个引用整数型数据成员，则定义语句为217.假定AB类中只包含一个整型数据成员a,并且它是ー个常量成员，若利用参数aa对其进行初始化，则该类的构造函数的定义为。218.假定AB类中只包含一个整型数据成员a,并且它是ー个引用成员,若利用引用参数aa对其进行初始化，则该类的构造函数的定义为〇

29201.假定指针p指向ー个动态分配的类对象，则当执行“deletep;”语句时，在释放P所指向的动态存储空间之前将自动调用该类的。202.假定用户为类AB定义了一个构造函数“AB(intaa){a=aa;}”,则系统(会/不会)为该类自动定义ー个无参构造函数"AB(){ド。203.假定用户为类AB定义了一个构造函数"AB(intaa,char*bb=NULL):a(aa),b(bb){}n,则该类中至少包含有个数据成员。204.假定用户为类AB定义了•个构造函数“AB(intaa){a=aa;}”,该构造函数实现对数据成员的初始化。205.假定用户为类AB定义了一个构造函数''AB(intaa=0):a(aa){}”,则定义该类的对象时,可以有种不同的定义格式。206.假定用户为类AB定义了一个构造函数“AB(intaa):a(aa){ド’,则定义该类的对象时，有种定义格式。207.假定用户只为类AB定义了一个构造函数"AB(intaa,intbb=0){a=aa;b=bb;}".则定义该类的对象时,其实参表中至多带有个实参。208.假定用户只为类AB定义了一个构造函数"AB(intaa,intbb=0){a=aa;b=bb：)",则定义该类的对象时,其实参表中至少带有个实参。209.假定用户为类AB定义了一个构造函数"AB(intaa=0,intbb=0){a=aa;b=bb;}”,则定义该类的对象时，可以有种不同的定义格式。210.假定用户只为类AB定义了一个构造函数“AB():a(0),b(0){ド,则定义该类对象x的定义语句"ABx();"是(正确/错误)的。211.假定用户只为类AB定义了一个构造函数“AB():a(0),b(0){ド'，则定义该类对象x的定义语句"ABx;"是(正确/错误)的。212.假定用户只为类AB定义了一个构造函数“AB():a(〇),b(0){ド'，则定义该类对象x的定义语句"ABx⑸；"是(正确/错误)的。213.假定AB为ー个类,则类定义体中的"AB(ABx);"语句为该类ー的原型语句。214.假定AB为ー个类，则该类的拷贝构造函数的函数头为〇215.假定AB为一个类，该类中含有一个指向动态数组空间的指针成员pa,则在该类的析构函数中应该包含有一条语句。216.静态成员函数ー访问类的静态数据成员,ー访问类的非静态数据成员。217.静态数据成员必须在所有函数的定义体外进行。218.ー个类的成员函数也可以成为另一个类的友元函数，这时的友元说明必须在函数名前加上的限定。219.重载运算符时，该运算符的、结合性以及操作符的个数不允许改变。220.ー个单目运算符作为类的成员函数重载时有一ー个参数;如果作为独立函数重载，则有个参数。221.一个双单目运算符作为类的成员函数重载时有个参数;如果作为独立函数重载，则有个参数。222.除了运算符外，其他重载的运算符都可以被派生类继承。223.作为类的成员函数重载ー个运算符时，参数表中只有一个参数，说明该运算符有个操作数。224.在重载ー个单目运算符时，参数表中没有参数，说明该运算符函数只能是类的225.重载插入运算符(く时,其运算符函数的返回值类型应当是〇

30201.重载抽取运算符〉〉时,其运算符函数的返回值类型应当是。202.重载插入运算符(く或抽取运算符〉〉时，其运算符函数的参数有个。203.重载插入运算符〈く或抽取运算符》时,其运算符函数不能被定义为类的函数。204.类型转换函数没有类型,而且参数表为〇205.在・个或若干个类的基础上构造ー个新类,被称为ー206.派生类的成员函数可以直接访问基类的成员，不能直接访问基类的成员。207.当保护继承时，基类的成员在派生类中成为保护成员，派生类对象不能直接访问基类的成员。208.在定义ー个派生类时，使用关键字或者不显式地使用它则表示为继承。209.若多个基类及其派生类中都定义了同名函数成员，要访问相应函数时，就需要在函数名前加上和类区分符。210.若要保证ー个公共的基类在派生类中只产生一个基类子对象，则必须都以的方式直接继承它。211.引进虚基类的根本目的是为了消除。212.在每个成员函数中，隐含的第一个参数的参数名为。四、程序填充1.斐波那契数列的第1和第2个数分别为0和1,从第三个数开始，每个数等于其前两个数之和。求斐波那契数列中的前20个数,要求每行输出5个数。#inc1udevoidmainO{intf,fl,f2,i;cout«w斐波那契数列:

31"；fl=0;f2=l;cout«setw(6)«fl«setw(6)«f2;for(i=3;i<=20;i++){f=(1)；cout<voidmain()(doublex,pl=l,p2=l,s=0;inti,j=l;coutくく〃输入x的值:"；cin>>x;

32for(i=l;i<=10;i++){pl*=—(1);p2*=(2);s+=j*pl/p2J〃j的值为(T”"j=(3);}cout«s<#includevoidmainO(inti,n;for(n=2;⑴__n++){inttemp=int(sqrt(n))i〃求出n的平方根并取整for(i=2;—(2)—;i++)if(n%i==0)—⑶—；if(i>temp)cout<

33;)(1)(2)(3)4.采用辗转相除法求出两个整数的最大公约数。#includevoidmain()(inta,b;coutくく”请输入两个正整数:";cin>>a»b;while(a<=0||—(1)){coutくく”重新输入:"；cin»a>>b;}while(b){intr;r=a%b;—⑵一；—⑶—；//分别修改a和b的值)cout«a«endl;//输出最大公约数)⑴⑵(3)5.把从键盘上输入的一个大于等于3的整数分解为质因子的乘积。如输入24时得到的输出结果为“2223”,输入50时得到的输出结果为“255”,输入37时得到的输出结果为“37”。#includevoidmain(){intx;coutくぐ请输入ー个整数,若小于3则重输:"；docin»x;while((1));inti=2;do{while(⑵){cout«i«*';

34x/=i;)_(3)_；}while(i=i&&(3));returnp*a*b;)(1)(2)(3)7.在输出屏幕上打印出ー个由字符‘*’组成的等腰三角形,该三角形的高为5行,从上到下每行的字符数依次为1,3,5,7,9〇#includevoidmain()(inti,j;for(i=l;(1);i++){for(j=l;j<=9;j++)if(j<=5-iII(2))cout«'';else(3);cout«endl;8.统计字符串中英文字母个数的程序。#includeintcount(charstr[]);voidmain(){charsi[80];coutくく''Enteraline:";cin»sl;cout«"count="«count(si)<=*a'&&str[i]<='z'||(1))_(2)_；—(3)—;)

35(1)(2)(3)7.主函数调用ー个fun函数将字符串逆序。#inc1ude#includeくstring.h>—⑴一；voidmain(){chars[80];cin>>s;_(2)_；coutくく”逆序后的字符串:”くくsくくendl;}voidfun(charss[]){intn=strlen(ss);for(inti=0;(3);i++){charc=ss[i];ss[i]=ss[n-1-i];ss[n-1-i]=c;⑴⑵(3)10.从ー个字符串中删除所有同一个给定字符后得到ー个新字符串并输出。#includeconstintlen=20;voiddelstr(chara[],charb[],charc)：voidmain(){charstrl[len],str2[len];charch;coutくく“输入一个字符串:"；cin»strl;coutくく〃输入一个待删除的字符:〃;cin»ch;delstr(strl,str2,ch);cout«str2«endl;)voiddelstr(chara[],charb[],charc)intj=0;for(inti=0;(1);i++)if(—⑵—)b[j++]=a[i];b[j]=—(2)一;)(1)(2)(3)11.采用指针访问方式从键盘给数组a[N]输入数据,然后对元素值重新按逆序存放并输出。^include

36constintN=8;voidmainO(inta[N],*p,*q;for(p=a;pvoidmain(){intx;coutくく”输入ー个整数:"；cin»x;inta[20],k=0,r;do{r=x%2;a[k++]=r;x=—(1)—；}while(⑵);for(一k;k>=0;k一)__(3)cout«endl;(1)(2)(3)13.对数组a[n]按升序进行的选择排序算法voidSelectSort(inta[],(1))(inti,j,k：for(i=l;i=0;j—)〃为x顺序向前寻找合适的插入位置if(x

37;else(3);a[j+l]=x;))(1)(2)(3)15.对按从小到大排列的有序数组a[n]进行二分查找x的算法,若查找成功返回该元素下标,否则返回ー1。intBinarySearch(inta[],intx)(intlow=0,high=N-lJ〃定义并初始化区间下界和上界变量intmid;//定义保存中点元素ド标的变量while(low<=high){mid=(1);if(xニニa[mid])⑵一;elseif(x=0;j—)if(strcmp(p,table[j])<0)(2);elsebreak;table[j+l]二_(3)—;(1)(2)(3)17.假定有定义为"structNODE{intdata;NODE*next;};”,下面算法根据table数组中的n个元素建立一个表头指针为L的链表,链表中结点值的顺序与数组元素值的顺序相同。voidf5(NODE*&L,inttablet],intn)(if(n<=0){L=NULL;return;}L二newNODE;〃生成附加的头结点intiニ〇;NODE*p=L;while((1)){p二p-〉next二(2);p->data=(3);i++；)

38p->next=NULL;〃把最后一个结点的指针域置空P=L;L=L->next;//使L指向链表的第一个带值的结点deletep;17.假定有定义为"structNODE{intdata;NODE*next;};",下面算法根据table数组中的n个元素建立一个表头指针为L的链表,链表中结点值的顺序与数组元素值的顺序正好相反。voidf6(N0DE*&L,inttablet],intn)L=NULL;if(n<=0)return;inti=0;NODE*p;while((1)){p=newNODE;p->data=(2)pー〉next二L;,(3)_；i++；18.假定有定义为"structNODE{intdata;NODE*next;};”,下面算法是依次显示输出以L为表头指针的链表中各结点的值。voidf7(NODE*L)(for(—(1)—;p!=NULL;—(2)—)cout<<(3)«'';cout«endl;}(1)(2)(3)20.假定有定义为"structNODE{intdata;NODE*next;};下面算法是把以L为表头指针的链表中各结点依次按相反次序链接并返回新链表的表头指针。NODE*f8(NODE*L){if(L==NULL)returnNULL;NODE*p=NULL,*q=L,*t;while(q!=NULL){t=q；q=一(1)一;t->next=(2);P=t;}_(3)_;(1)(2)21.已知一维数组类ARRAY的定义如ト，ARRAY与普通一维数组区别是:其重载的运算符[]要对下标是否越界进行检查。classARRAY{int*v;〃指向存放数组数据的空间

39ints!〃数组大小public:ARRAY(inta[],intn);'ARRAY(){delete[]v;}intsizeO{returns;}int&operator[](intn);};.(1)_operator[](intn)〃[]的运算符成员函数定义(if(n<0||—(2)—){cerrくく"下标越界!”;exit(l)：}return_(3);(1)(2)(3)22.已知一维数组类ARRAY的定义如下,构造函数的作用是把参数n的值赋给s,给v动态分配长度为n的数组空间,接着利用数组参数a初始化v所指向的数组。classARRAY{int*v!〃指向存放数组数据的空间ints!〃数组大小public:ARRAY(inta[],intn);~ARRAY0{delete[]v;}intsize(){returns;}int&operator[](intn););—(1)—ARRAY(inta[],intn)(if(n<=0){v=NULL;s=0;return;}s=n;v=—(2)一;for(inti=0;iclassAA{inta[10];intn;

40public:voidSetA(intaa[],intnn);〃用数组aa初始化数据成员a,〃用nn初始化数据成员nintMaxAOi〃从数组a中前n个元素中查找最大值voidSortAO!〃采用选择排序的方法对数组a中前n个元素〃进行从小到大排序voidInsertAOノ/采用插入排序的方法对数组a中前n个元素进行从小到大排序voidPrintAO;〃依次输出数组a中的前n个元素};该类中MaxA()函数的实现如下,请在标号位置补充适当的内容。int(1)(intx=a[0];for(inti=l;ix)—(2)—:_(3)_;(1)(2)(3)24.已知一个类的定义如下:#includeclassAA{inta[10];intn;public:voidSetA(intaa[],intnn);〃用数组aa初始化数据成员a,〃用nn初始化数据成员nintMaxAO:〃从数组a中前n个元素中查找最大值voidSortAOJ〃采用选择排序的方法对数组a中前n个元素〃进行从小到大排序voidInsertAO;〃采用插入排序的方法对数组a中前n个元素进行从小到大排序voidPrintAO;〃依次输出数组a中的前n个元素};voidAA::SortA()(inti,j;for(i=0;(1);i++){intx=a[i],k=i;for(j=i+l;jclassAA{inta[10];intn;public:voidSetA(intaa[],intnn);〃用数组aa初始化数据成员a,〃用nn初始化数据成员nintMaxAO;〃从数组a中前n个元素中査找最大值

41voidSortAOJ〃采用选择排序的方法对数组a中前n个元素〃进行从小到大排序voidInsertAO"/采用插入排序的方法对数组a中前n个元素进行从小到大排序voidPrintAO:〃依次输出数组a中的前n个元素}；void(1)(inti,j;for(i=l：i=0;j—)if(xclassAA{inta[10];intn：public:voidSetA(intaa[],intnn);〃用数组aa初始化数据成员a,〃用nn初始化数据成员nintMaxAO;〃从数组a中前n个元素中查找最大值voidSortA()J〃采用选择排序的方法对数组a中前n个元素〃进行从小到大排序voidInsertAO;〃采用插入排序的方法对数组a中前n个元素进行从小到大排序voidPrintAO:〃依次输出数组a中的前n个元素//最后输出ー个换行}；使用该类的主函数如ド:voidmain()(inta[10]={23,78,46,55,62,76,90,25,38,42}：AAx;(1)_；intm=(2);_(3)_;cout<classAA{inta[10];intn;public:voidSetA(intaa[],intnn);〃用数组aa初始化数据成员a,〃用nn初始化数据成员nintMaxAO:〃从数组a中前n个元素中查找最大值voidSortAOJ〃采用选择排序的方法对数组a中前n个元素〃进行从小到大排序voidPrintAOJ〃依次输出数组a中的前n个元素,〃最后输出ー个换行}；

42使用该类的主函数如下：voidmain()inta[10]={23,78,46,55,62,76,90,25,38,42};(1);x.SetA(a,8);int_(2);_(3)—;x.PrintA();cout<

43intPopOi〃从栈顶弹出ー个元素boolEmpty(){〃判栈空if(top==-l)returntrue;elsereturnfalse;}intDepth(){returntop+1;}〃返回栈的深度voidPrint();〃按照后进先出原则依次输出栈中每个元素,直到栈空为止private:intelem[ARRAY_SIZE];〃用于保存堆栈元素的数组inttop;〃指明栈顶元素位置的指针该类的Pop和Print函数的实现分别如下:(1)_{if(top==-l){coutくく"栈空!"«endl;exit(l);〃中止运行}return(2);voidStack::Print(){while(!Empty())cout<<(3)くぐ(1)(2)(3)31.classA{inta;public:A(){aニ0;}(1){}〃定义构造函数,用参数aa初始化数据成员a}；main(){—(2)—;〃定义类A的指针对象p—⑶_;〃用P指向动态对象并初始化为整数5(1)(2)(3)32.classA{char*a;public:⑴〃定义无参构造函数，使a的值为空A(char*aa){a=(2);strcpy(a,aa);〃用aa所指字符串初始化a所指向的动态存储空间〃定义析构函数,删除a所指向的动态存储空间};(1)(2)(3)

4432.classA{inta,b;public:A(intaa二〇,intbb=O)(1){}〃分别用aa和bb对应初始化a和b}；main(){—⑵—;〃定义类A的对象x并用5初始化,同时定义y并用x初始化(3)_;//定义p指针,使之指向对象x)(1)(2)(3)33.classA{inta,b;public:—⑴ー〃定义构造函数,使参数aa和bb的默认值为0,〃在函数体中用aa初始化a,用bb初始化b}；main(){A*pl,*p2;(2);〃调用无参构造函数生成由pl指向的动态对象一⑶—;〃调用带参构造函数生成山p2指向的动态对象,〃使a和b成员分别被初始化为4和5)(1)(2)(3)34.#include#includeclassA{int*a;intn;intMaxLen;public:A():a(0),n(0),MaxLen(0){}A(int*aa,intnn,intMM){n二nn;MaxLen二MM;if(n>MaxLen)exit(1);(1);〃由a指向长度为MaxLen的动态数组for(inti=0;i

45for(i=0;i<10;i++);(3)〃把r对象的a数据成员中的每个〃元素值依次累加到s中cout«*s=*<#includeclassA{int*a;intn;intMaxLen;public:A():a(0),n(0),MaxLen(O){)A(int*aa,intnn,intMM){n=nn;MaxLen=MM;if(n>MaxLen)exit(1);a=newint[MaxLen];—(1)—;〃以i为循环变量把aa数组中每个元素值〃传送给a数组的对应元素中)、A();intGetValue(inti){returna[i];}〃函数体返回a[i]的值)；—(2)_〃析构函数的类外定义voidmainO(intb[10]={l,2,3,4,5,6,7,8,9,10);Ar(b,10,10);inti,s=0;—⑶—;〃以i为循环变量,把r对象的a数据成员中的〃每个元素值依次累加到s中coutくく"s="くくsくくendl;}(1)(2)(3)37.一种类定义如下:classGoodsprivate:chargdname[20];〃商品名称intweight;staticinttotalweight;public:〃商品重量〃同类商品总重量

46Goods(char*str,intw){strcpy(gd_name,str);weight=w;totalweight+=weight;}ヽGoods(){totalweight-=char*GetN(){_(1)_;}//构造函数weight;}〃返回商品名称intGetW(){returnweight;}(2)GetTotal_Weight(){〃定义静态成员函数返回总重量一(3)—;)|⑴⑵(3)37.classPoint(private:intx,y;public:Point(){x=y=0;}Point(intxO,intyO){x=xO;y=yO;}intGetXO{returnx;}intGetY(){returny;}voidPrint。{coutくく"Point("くくxくく"，・くくyくく")"くくendl;}—⑴—;〃友元函数声明—⑵—;〃友元函数声明}；Pointoperator+(Point&pt,intdd)〃加号操作符重载函数,实现Point类对象与整数加法(Pointtemp=pt;temp.x+=dd;temp.y+=dd;returntemp;}Pointoperator+(Point&ptl,Point&pt2)〃加号操作符重载函数,实现两个Point类对象的加法Pointtemp=ptl;temp.x+=pt2.x;(3)_；returntemp;(1)(2)(3)

4739,在下面一段类定义中,Derived类是由直接基类Base1和Base2所派生的,Derived类包含有两个间接基类BaseBase,在初始化函数Init中,需要把xl和x2的值分别赋给属于基类Basel的x成员和属于基类Base2的x成员。classBaseBase{protected:intx;public:BaseBase(){x=1;}}；classBasel:publicBaseBase{public:Basel(){}}；classBase2:publicBaseBase{public:Base2()(})；classDerived:(1)(public:Derived(){}voidInit(intxl,intx2){—(2)—；—(3)—;)voidoutput(){coutくくBasel::xくぐ’くくBase2::xくくendl;}}；(1)(2)(3)40.在下面一段类定义中,Derived类公有继承了基类Base。需要填充的函数由注释内容给出了功能。classBase(private:intmeml,mem2J〃基类的数据成员public:Base(intml,intm2){meml=ml;mem2=m2;)voidoutput(){cout<

48public:〃构造函数,由ml和m2分别初始化meml和mem2,由m3初始化mem3Derived(intml,intm2,intm3);〃输出meml,mem2和mem3数据成员的值voidoutput(){(1);cout<

49classbicycle:(1)〃自行车类(private:intHeightJ〃车高public:bicycleO{};voidRun(){cout«"Abicycleisrunning!"«endl;}}；classmotorcar:(2)〃机动车类(private:intSeatNum;〃乘人数public:motorcar(){};voidRun(){cout«"Amotorcarisrunning!"<#includevoidmain(){inta[8]={25,48,32,85,64,18,48,29};intmax,min;max=min=a[0];for(inti=0;i<8;i++){if(x>a[i])max=a[i];if(xvoidmain()(inta,b;for(a=l,b=2;bく50;){cout«a«，'くくbくぐ,;a=a+b;b=a+b;}cout«endl;cout«a<<''<constintM=3,N=4;voidmain()(inti,j,s=0;for(i=l;i<=M;i++)for(j=l;j<=N;j++)s+=i*j;coutくく“s="«s«endl;)4.^includeくiostream.h>voidmain()if(a+b>10)c=a*b;elsec=3*a+b;if(c<=20)cout«c*c;elsecoutくく4+c-5;cout<

50a=a+b;b=a+b;c+=a+b;coutくく“a,b,c=”くくaくく‘，‘くくbくく‘，‘くくcくくendl;)1.#includevoidmain()(intx=5;switch(2*x-3){case4:cout«x«,';case7:cout«2*x+l«,';case10:cout«3*x-l«,';break;default:cout<<"default"<#includeinta[4]={36,-5,73,8};voidmain()(inti,y;for(i=0;i<4;i++){if(a[i]<0)y=l;elseif(a[i]<10)y=a[i]*a[i]+3;elseif(a[i]<60)y=4*a[i]-5;elsey=int(sqrt(a[i]));//sqrt(x)为取x的平方根函数cout<inta[8]={36,25,20,43,12,70,66,35);voidmain(){intsO,si,s2;s0=sl=s2=0;for(inti=0;i<8;i++){switch(a[i]%3){case0:s0+=a[i];break;case1:sl+=a[i];break;case2:s2+=a[i];break;cout«sO«,'«sl«,'«s2«endl;8.#includeconstintN=5;voidmainO{inti,p=l,s=0;for(i=l;i

518.#includeconstintM=20;voidmain()(intc2,c3,c5;c2=c3=c5=0;for(inti=l;iく=M;i++){if(i%2=0)c2++;if(i%3==0)c3++;if(i%5=0)c5++;}cout«c2«,’くくc3くく''«c5«endl;)9.^includeくiomanip.h>voidmainO(inti,j;for(i=0;i<5;i++){for(j=i;j<5;j++)coutくく'*';cout<voidmain()(for(inti=l,s=0;i<20;i++){if(i%2==0IIi%3==0)continue;cout«i«'';s+=i;

52cout«s<constintT=6;voidmainO{inti,j;for(i=l;i<=T;i+=2)for(j=2;j<=T;j+=2){if(i+jvoidmain()(inta,b,c=0;for(a=l;a<4;a++)for(b=6;b>l;b-=2){if((a+b)%2==0)c+=a+b;elsec+=a*b;if(b==2)cout«a«,‘くくbくく''«c«endl;})10.#includeくiostream.h>constintB=2;voidmainO(intp=l,s=l;while(s<50){p*=B;s+=p;}coutくく“s=”くくsくくendl;)11.^includeくiostream.h>voidmainO(intx=24,y=88;inti=2,p=l;do{while(x%i=0&&y%i==0){p*=i;x/=i;y/=i;

53i++；}while(x>=i&&y>=i);cout«p*x*y<constintN=3;voidmain()(inta[N][N]={{7,-5,3},{2,8,-6},{1,-4,-2}};intb[N][N]={{3,6,-9},{2,-8,3},{5,-2,-7)};inti,j,c[N][N];for(i=0;iくN;i++)〃计算矩阵Cfor(j=0;jinta=5;voidmain(){intb=a+20;inta=10;coutくくaくぐ’くくbくくendl;{inta=0,b=0;for(inti=l;i<6;i++){a+=i;b+=a;)cout«a«''<intfl(intx,inty)(x=x+y;y=x+y;coutくく"x="くくxくく"，y="<

54intz=f1(x,y);coutくく"x="くくxくく"，y="«y;cout«",z="<voidf2(int&x,int&y)(intz=x;x=y;y=z;)voidf3(int*x,int*y)(intz=*x;*x=*y;*y=z;)voidmain()(intx=10,y=26;cout<<"x,y="«x«","<voidf4(inta[],intn,int&s)(s二〇;for(inti二〇;iくn;i++)s+二a[i];}voidmain()(intb[8]={4,8,6,9,2,10,7,12};intx;f4(b,5,x);cout«x<<*';inty;f4(b+3,4,y);cout«y«,';coutくくx+yくくendl;)10.#includevoidmain(){inta[8]={36,25,48,14,55,40,50,24);intbl,b2;bl=b2=a[0];for(inti=l;i<8;i++)if(a[i]>bl){b2=bl;bl=a[i];}elseif(a[i]>b2)b2=a[i];cout«bl«,’くくb2くくendl;)11.#includevoidmain(){chara口二〃abcdabcabfgacd”;intil=0,i2=0,i=0;

55while(a[i]){if(a[i]==,a')il++;if(a[i]==,b')i2++;i++；}cout«il«,'«i2«''«i«endl;)8.#includevoidmain(){inta[10]={76,83,54,62,40,75,90,92,77,84);intb[4]={60,70,90,101};intc[4]={0};for(inti=0;iく10;i++){intj=0;while(a[i]>=b[j])j++;c[j]++;}for(i=0;iく4;i++)cout<#includeくstring.h>voidmain(){chara[5][10]={"student,"worker","soldier","cadre","peasant");charsi[10],s2[10];strcpy(si,a[0]);strcpy(s2,a[0]);for(inti=l;i<5;i++){if(strcmp(a[i],si)>0)strcpy(si,a[i]);if(strcmp(a[i],s2)<0)strcpy(s2,a[i]);}coutくくsiくく’'«s2«endl;10.#includeconstintN=5;voidfun();voidmain()(for(inti=l;ivoidmain()(chars[3][5]=「1234","abed”,〃+-*/"};char*p[3];for(int1=0;I<3;1++)p[I]=s[I];for(1=2;I>=0;I一一)cout<voidmain()(inti,j,len[3];

56chara[3][8]={"year","month","day"};for(i=0;iく3;i++){for(j=0;j<8;j++)if(a[i][j]~\0*){len[i]=j;break;}cout<#includeくstring.h>classCD{char*a;intb;public:voidInit(char*aa,intbb)(a=newchar[strlen(aa)+l];strepy(a,aa);b=bb;char*Geta(){returna;}intGetbO{returnb;}voidOutput(){coutくくaくぐ’くくbくくendl;}}dx;voidmain()(CDdy;dx.Init("abcdef”,30);dy.Init("shenyafen”,3*dx.Getb()+5);dx.Output();dy.Output();9.#include#includeくstring.h>classCD{char*a;intb;public:voidInit(char*aa,intbb)(a二newchar[strlen(aa)+l];strcpy(a,aa);b二bb;}char*Geta(){returna;}intGetbO{returnb;)voidOutput(){coutくくaくぐ,<

57dx.Init("abcdef”,30);strcpy(a,dx.GetaO);strcat(a,xyz");dy.Init(a,dx.Getb()+20);dx.Output();dy.Output();8.#includeclassCE{private:inta,b;intgetmax(){return(a>b?a:b);}public:intc;voidSetValue(intxl,intx2,intx3){a=xl;b=x2;c=x3;}intGetMaxO;)；intCE::GetMaxO{intd=getmax();return(d>c?d:c);}voidmain()(intx=5,y=12,z=8;CEex,*ep=&ex;ex.SetValue(x,y,z);cout<SetValue(x+y,y-z,20);cout«ep->GetMax()<classCE{private:inta,b;intgetminO(return(aSetValue(x+y,y-z,10);cout«ep->GetMin()«endl;CEa=*ep;

58cout«a.GetMin()*3+15«endl;8.#includeclassFranction{〃定义分数类intnumei〃定义分子intdenoJ〃定义分母public:〃把・this化简为最简分数,具体定义在另外文件中实现voidFranSimp();〃返回两个分数・this和x之和,具体定义在另外文件中实现FranctionFranAdd(constFranction&x);〃置分数的分子和分母分别〇和1voidInitFranction(){nume=0;deno=l;}〃置分数的分子和分母分别n和dvoidInitFranction(intn,intd){nume=n;deno=d;}〃输出ー个分数voidFranOutput(){coutくくnumeくぐ/'くくdenoくくendl;}}；voidmainO{Franctiona,b,c,d;a.InitFranction(7,12);b.InitFranction(-3,8);c.InitFranctionO;c=a.FranAdd(b);d=c.FranAdd(a);coutくくa:a.FranOutput();coutくく"b:b.FranOutput();cout<<"c:c.FranOutput();cout<<"d:d.FranOutput();}9.#includeclassFranction{〃定义分数类intnumei〃定义分子intdeno;〃定义分母public:〃把・this化简为最简分数,具体定义在另外文件中实现voidFranSimp();〃返回两个分数・this和x之和,具体定义在另外文件中实现FranctionFranAdd(constFranction&x);〃置分数的分子和分母分别〇和1voidInitFranction(){nume=0;deno=l;}〃置分数的分子和分母分别n和dvoidInitFranction(intn,intd){nume=n;deno=d;}〃输出ー个分数voidFranOutput(){cout«nume«*/'<

59b.InitFranction(3,10);c.InitFranctionO;c=a.FranAdd(b);d=c.FranAdd(a);coutくくa:a.FranOutput();cout«*b:b.FranOutput();cout«*c:;c.FranOutput();coutくく"d:';d.FranOutput();)8.#inc1ude#includeくstring.h>classA{char*a;public:A(char*s){a=newchar[strlen(s)+l];strcpy(a,s);cout«a<classA{int*a;public:A(intx=0):a(newint(x)){}~A()(deletea;}intgetA(){return*a;}voidsetA(intx){*a=x;}}；voidmain(){Axl,x2(3);A*p=&x2;p->setA(x2.getA()+5);xl.setA(15+xl.getAO);cout<classA{inta;public:

60A(intaa=0):a(aa){cout«a«'';}~A(){coutくく〃Xxk”;}}；voidmainO{A*p;Ax[3]={l,2,3},y=4;cout<classA{inta,b;public:AO{a=b=0;}A(intaa,intbb)(a=aa;b=bb;}intSumO{returna+b;}int*Mult0{int*p=newint(a*b);returnp;)}；voidmain(){int*k;Ax(2,3),*p;p=newA(4,5);cout«x.Sum()«''«*(x.Mult())<Sum()くく’'<<♦(k=p->Mult())<classA{inta[10];intn;public:A(intaa[],intnn):n(nn){for(inti=0;iclassA{inta,b;public:A(intaa,intbb){a=aa;b=bb;}floatMultip(charop){switch(op){case'+':returna+b;case,一':returna-b;case':returna*b;case'/':if(b!=0)returnfloat(a)/b;else{coutくく"除数为〇!"くくendl;return0;}default:coutくぐ、n'くくopくく"非法运算符!"<

61return0;}}}；voidmain(){Ax(10,4);chara[6]="+-*/©*；inti=0;while(a[i]){floatk=x.Multip(a[i]);if(k!=0)cout«k«,';i++；}cout«endl;}37.#includeclassPoint{intx,y;public:Point(intxl=0,intyl=0):x(xl),y(yl){coutくく“Point:"くくxくぐ’くくyくぐ、n';}~Point(){coutくく“Pointdestructor!

62";}}；classCircle{Pointcenter;〃圆心位置intradius;〃半径public:Circle(intex,intcy,intr):center(ex,cy),radius(r){cout«"Circleradius:"«radius<<'

63;)"Circle(){cout«"Circledestructor!

64*;}}；voidmain()(Circlec(3,4,5);}38.#include#includeclassPoint(intx,y;public:Point(intxl=0,intyl=0):x(xl),y(yl){coutくく“Point:"くくxくぐ’くくyくぐ、n';)"Point(){cout«"Pointdes!

65";)}；classText{chartext[100];〃文字内容

66public:Text(char*str){strcpy(text,str);cout«，zTextcon!

67”;)~Text(){coutくく“Textdes!

68";}}；classCircleWithText:publicPoint,publicText{public:CircleWithText(intex,intcy,char*msg):Point(ex,cy),Text(msg){cout«"PointwithTextcon!

69";J"CircleWithText(){cout«"PointwithTextdes

70*;}}；voidmain()(CircleWithTextcm(3,4,"hello");}37.#includeclassDate(public:voidSetDate(inty,intm,intd){Year=y;Month二m;Day=d;}voidPrintDateO{coutくくYearくく"/"くくMonthくく"/"くくDayくくendl;}DateO(SetDate(2000,1,1);}Date(inty,intm,intd){SetDate(y,m,d);}protected:intYear,Month,Day;}；classrFime(public:voidSetTime(inth,intm,ints){Houre=h;Minutes=m;Seconds=s;}voidPrintTimeO{coutくくHoureくく"："くくMinutesくく"："くくSecondsくくendl;}Time(){SetTime(0,0,0);}Time(inth,intm,ints){SetTime(h,m,s);}protected:intHoure,Minutes,Seconds;}；classDate_Time:publicDate,publicTimepublic:

71DateTime():Date(),TimeO{};Date_Time(inty,intmo,intd,inth,intmi,ints):Date(y,mo,d),Time(h,mi,s){}voidPrintDate_Time(){PrintDateO;PrintTime();}};voidmain()(Date_Timedt_a,dt_b(2002,10,1,6,0,0);dt_a.PrintDate_Time();dtb.SetTime(23,59,59);dt_b.PrintDate_Time();dta.SetDate(2002,12,31);dt_a.PrintDate_Time();)37.^includeclassDate(public:Date(inty=2001,intm=l,intd=l){Year=y;Month二m;Day=d;}voidPrintDateO{coutくくYearくく"/"くくMonthくく"/"くくDayくくendl;}protected:intYear,Month,Day;)；classrFime(public:Time(inth=5,intm=30,ints=0){Houre=h;Minutes二m;Seconds=s;}voidPrintTimeO{coutくくHoureくく"："くくMinutesくく"："くくSecondsくくendl;}protected:intHoure,Minutes,Seconds;}；classDate_Time:publicDate,publicTime(public:Date_Time(){};Date_Time(inty,intmo,intd,inth=0,intmi=0,ints=0):Date(y,mo,d),Time(h,mi,s){}voidPrintDate_Time(){PrintDateO;PrintTime();))；voidmain()(Date_Timea,b(2002,10,1,6,20,0),c(2003,3,8,6,7);a.PrintDate_Time();b.PrintDate_Time();

72a.PrintDate_Time();37.//*********************test.h********************〃ttincludeclassBasepublic:Base(inti,intj){x0=i;y0=j;}voidMove(intx,inty){x0+=x;y0+=y;}voidShow(){coutくく"Base("くくxOくく"，"くくyOくく")"くくendl;}private:intxO,yO;}；classDerived:privateBasepublic:Derived(inti,intj,intm,intn):Base(i,j){x=m;y=n;}voidShow(){cout«"Next("«x«","«y«")"«endl;}voidMovel(){Move(2,3);}voidShowl(){Base::Show();}private:intx,y;)；11**************************£0§'t，(cpp************************//ttinclude"test.h"voidmain()Baseb(l,2);b.Show();Derivedd(3,4,10,15);d.Movel();d.Show();d.Showl();45./*************test.h***********************/#includeclassPointpublic:voidInitP(floatx0=0,floaty0=0){X=x0;Y=yO;}voidMove(floatxf,floatyf){X+=xf;Y+=yf;}floatGetXO{returnX;}floatGetY(){returnY;}private:floatX,Y;}；classRectangle:publicPoint(public:

73voidInitR(floatx,floaty,floatw,floath){InitP(x,y);W=w;H=h;)voidZoomR(floatk){W*=k,H*=k;}floatGetH(){returnH;}floatGetW(){returnW;}private:floatW,H;};〃**************************test.cpp************************〃#include"test.h"voidmain()(Rectanglerect;rect.InitRdO,20,30,40);cout<classBase(public:virtualvoidSet(intb){x=b;}virtualintGet(){returnx;}private:intx;};classDerived:publicBase(public:voidSet(intd){y=d;}intGet(){returny;}private:inty;!/**************************test,cpp************************//ttinclude"test,h"void

74main(){BaseBobj;DerivedD_obj;Base*p=&Bobj;p->Set(100);coutくく“Bobjx="くくpー〉Get()<Set(200);cout«"D_objy="«p->Get()«endl;p->Base::Set(300);cout<<"Bobjx="«p->Base::Get()«endl;p->Set(p->Get0+200);cout<<"Dobjy="«p->Get()«endl;}六、指出以下程序或函数的功能1.#includevoidmain()(inti,s=0;for(i=2;i<=30;i+=2)s+=i*i；cout«"s="<-includeくstdlib.h>#includevoidmain()(inti=10,a;while(i>0){a=rand()%100+10;intj,k=int(sqrt(a)+le-5);〃sqrt(x)为求x的平方根函数for(j=2;j<=k;j++)if(a%j==0)break;if(j>k){cout<0)cout<

75cout<doublefl(intn){doublesign=l,s=l;for(inti=2;i<=n;i++){s+=sign/(i*i);sign*二一1;)returns;}voidmainO{inta;cin»a;cout«fl(a)<#includeくmath.h>voidmain()intx,y;cin»x;y=int(sqrt(x));//sqrt(x)为求x的算术平方根for(inti=l;i<=y;i++)if(x%i==O)coutくく“x二”くくiくく’*'«x/i«endl;}4.#includevoidmain()

76(inti,p=l,s=0;intN;coutくく”输入ー个正整数:";cin»N;for(i=l;i<=N;i++){p*=i;s+=p;)cout«s«endl;)1.#include#include#includeconstN=10;intff(intx,inty){intz;cout«x«*+‘くくyくく’二’;cin»z;if(x+y==z)return1;elsereturn0;)voidmain()(inta,b,c=0;srand(time(0));〃初始化随机数序列for(inti=。;iくN;i++){a=rand()%20+l;//rand()函数产生0-32767之间的一个随机数b=rand()%20+1;c+=ff(a,b);)coutくく“得分:"くくc*10くくendl;)2.intsi(intn)(intx;if(n==l)x=l;elsex=sl(n-l)+n*n;returnx;3.voidfun5(char*a,constchar*b){while(*b)*a++=・b++;*a=0;)4.templateboolfun8(Taロ,intn,Tkey)(

77for(inti=0;i=sum)cout«a[i]«,';cout«endl;)2.voidf4(chara[M][N])(intcl,c2,c3;cl=c2=c3=0;for(inti=0;iくM;i++)if(strlen(a[i])<5)cl++;elseif(strlen(a[i])>=5&&strlen(a[i])<15)c2++;elsec3++;cout«cl«,’くくc2くく’'«c3«endl;}3.voidfun3(inta[][N],intm,int&row,int&col)(intx=a[0][0];row=col=0;for(inti二〇;iくm;i++)for(intj=0;jx){x=a[i][j];row=i;col=j;

78if(mstr2[i])return1;elsereturn-1;if(strl[i]==str2[i])return0;elseif(strl[i]>str2[i])return1;elsereturnT;)18.IntNode*FindMax(IntNode*f)(if(!f)returnNULL;IntNode*p=f;f=f->next;while(f){if(f->data>p->data)p=f;f=f->next;}returnp;)假定IntNode的类型定义为:structIntNode{intdata;〃结点值域IntNode*next;〃结点指针域)；19.intCount(IntNode*f)

79{if(!f)return0;intc=0;

80while(f){C++；f=f->next;)returnc;)假定IntNode的类型定义为:structIntNode{intdataJ〃结点值域IntNode*next;〃结点指针域}；16.voidOutput(IntNode*f)(if(!f)return;while(f){cout«f->data«,';f=f->next;)cout«endl;)假定!ntNode的类型定义为:structIntNode{intdata;〃结点值域IntNode*next;〃结点指针域)；17.voidInput(IntNode*&f)(intn;coutくく”从键盘给n输入ー个整数:"；docin>>n;while(n<0);if(n==0){f=NULL;return;}f=newIntNode;IntNode*p=f;coutくく”从键盘输入”くくnくく”个整数:”；while(n-){p二p->next二newIntNode;cin>>p->data;}p->next=NULL;p=f;f=f->next;deletep;)假定IntNode的类型定义为:structIntNode{intdata;〃结点值域IntNode*next;〃结点指针域

8116.intf(constchar*s)inti=0;while(*s++)i++;returni;}；17.char*f(char*s){intn=strlen(s);char*r=newchar[n+1];for(inti=0;i=a*&&s[i]<=z)r[i]=s[i]」a'+'A';elser[i]=s[i];r[n]=‘、0';returnr;七、程序改错1.在下面的定义中,NODE是链表结点的结构,appendToList则是ー函数,其功能是:在list所指向的链表的末尾添加一个新的值为x的结点,并返回表头指针。函数中有两处错误,指出错误所在行的行号并提出改正意见。structNODE{intdata;NODE*next;)；〃1行〃2行〃3行〃4行〃5行//6行〃7行,链表非空先找到表尾〃8行,让原表尾指针指向新添加的NODE*appendToList(NODE*list,intx){NODE*p=newint;p->data=x;p->next=NULL;if(list==NULL)returnp;NODE*pl=list;while(pl->next!=NULL)pl=pl->next;pl=P；结点returnlist;错误行的行号为和〇分别改正为和一2.在下面的定义中,NODE是链表结点的结构,addToList则是ー函数,其功能是:将ー个值为x的新结点添加到以plist为表头指针的链表的首部（即第一个结点的前面）并返回表头指针。函数中有两处错误,指出错误所在行的行号并提出改正意见。structNODE{intdata;NODE*next;

82NODE*adndToList(NODE*plist,intx){〃1行NODE*p;〃2行*p=newNODE;//3行p->data=x:〃4行p->next=NULL;〃5行plist=p;〃6行returnpJ〃7行)错误行的行号为和。分别改正为和。1.假定要求下面程序的输出结果为“11/15”,其主函数中存在着三行语句错误,请指出错误语句行的行号并改正错误行。#includeclassFranction{〃定义分数类intnume:〃定义分子intdeno;〃定义分母public:〃把・this化简为最简分数,具体定义在另外文件中实现voidFranSimp();〃返回两个分数・this和x之和,具体定义在另外文件中实现FranctionFranAdd(constFranction&x);〃置分数的分子和分母分别〇和1voidInitFranction(){nume=0;deno=l;}〃置分数的分子和分母分别n和dvoidInitFranction(intn,intd){nume=n;deno=d;}〃输出ー个分数voidFranOutput(){coutくくnumeくぐ/'くくdenoくくendl;}}；voidmain()//I行{//2行Franctiona,b,c:〃3行a.InitFranction(6,15);//4行b.InitFranction(l);//5行c.InitFranction();〃6行c=FranAdd(a,b);//7行coutくくc.numeくく’/'«c.deno«endl;〃8行)〃9行错误行的行号为ヽ和〇分别改正为ヽ和2.假定要求下面程序的输出结果为“23/20”,其主函数中存在着三条语句错误,请指出错误语句行的行号并改正。

83#includeclassFranction{〃定义分数类intnumei〃定义分子intdeno;〃定义分母public:〃把・this化简为最简分数,具体定义在另外文件中实现voidFranSimp();〃返回两个分数・this和x之和,具体定义在另外文件中实现FranctionFranAdd(constFranction&x);〃置分数的分子和分母分别〇和1voidInitFranction(){nume=0;deno=l;}〃置分数的分子和分母分别n和dvoidInitFranction(intn,intd){nume=n;deno=d;}〃输出ー个分数voidFranOutput(){cout<InitFranction(6,15);//5行b.InitFranction(3,4);〃6行Franctionc;〃7行c.InitFranction();〃8行c=a.FranAdd(b);〃9行cout<

84)错误行的行号为、和»//16行6.下面程序段第4-10行中存在着三条语句的语法错误,请指出错误语句的行号并改正。classA{//I行inta,b;〃2行constintc;//3仃public//4行A():c(0);a(0);b(0){)〃5行A(intaa,intbb)c(aa+bb);{a=aa;b=bb;}〃6行}I〃7行Aa,b(l,2):〃8行A*x=&a,&y=b;//9行A*z=newA,w[10];〃10行错误行的行号为ヽ和0分别改正为_、ー和0Public:A():c(0),a(0),b(0){)A(intaa,intbb):c(aa+bb){a=aa;b=bb;}7,下面程序段第4-9行中存在着三条语句错误,请指出错误语句的行号并说明原因。classA{//I行inta,bI〃2行constintc;//3行public:〃4行A(){a=b二cニ。;}〃5行A(intaa,intbb):c(aa+bb){a=aa;b=bb;}〃6行);//7行Aa,b(l,2,3);〃8行Ax(2,3),y(4);〃9行错误行的行号为ヽ和0错误原因分别为ヽ和08.下面程序段第10-17行中存在着三条语句错误,请指出错误语句的行号并说明原因。classA{//I行inta;//2行public:〃3行A(intaa=0):a(aa){}//4行);//5行classB{//6行inta,b;〃7行constintc;〃8行Ad;//9行

85public://10行B():c(0){a=b二〇;}〃“行B(intaa,intbb):d(aa+bb){〃12行a=aa;b=bb;c=aa-bb;〃13行//14行〃15行Ba,b(l,2):〃16行Bx=a,y(b),z(l,2,3),;//17行错误行的行号为ヽ和〇错误原因分别为ヽ和。8.假定要求下面程序输出结果为“d=800,f=60”,在第4-23行中存在着三条语句错误,请指出错误语句的行号并改正。#includeclassA{〃1行inta[10];intn;〃2行public:〃3行A(intaa[],intnn):n(nn){〃4行for(inti=0;i

86friendfract&operator+=(fract,fract&);〃2行voidshowO{cout«den«，/'«num;}〃3行}；//4行friendfract&operator+=(fractfl,fractf2)〃5行{//7行fl.den=fl.den*f2.num+f1.num*f2.den;//8行fl.num*=f2.num;〃9行returnfl;//10行voidmainO{fractfr(3,4);fr+=fract⑸7);fr.show();}错误行的行号为和。分别改正为和,ハ、程序设计1.编ー程序求出满足不等式1+1/2+1/3+...+l/n25的最小n值。2.计算1+3+3ク+...+3m的值并输出,假定分别用i,p,s作为循环变量、累乘变量和累加变量的标识符。3.求满足不等式22+42+...+n2<1000的最大n值,假定分别用i和s作为取偶数值和累加值的变量,并限定使用do循环编程。4.已知y=<セー+マ(X-0),求出并显示当x分别取ー3.8,6.4,2.3,3ax~+4ax-l(x>0)-4.2,8.9,3.5,-5.0,4.5时所对应的y值,要求把a定义为常量,其值设定为10.2,x的每个值由键盘输入,并假定用ー100作为终止标志,求平方根函数为sqrt(x)。5.求出从键盘上输入的10个整数中的最大值,要求输入变量用x表示,存储最大值的变量用max表示。6.已知6WaW30,15WbW36,求满足不定方程2a+5b=126的全部整数组解。如(13,20)就是一个整数组解,并以所给的样式输出每个解。7.某班级学生进行百米跑测试，规定成绩在12秒以内(含12秒)为优秀，在12秒以上至15秒为达标，在!5秒以上为不达标，编ー程序，从键盘上输入每个人的成绩，以x作为输入变量,并以小于〇的任何数作为终止标志,分别用变量cl,c2和c3统计出成绩为优秀、达标和不达标的人数。8.编写一个函数，分别求出由指针a所指向的字符串中包含的每种卜进制数字出现的

87次数,把统计结果保存在数组b的相应元素中。5.按照下面函数原型语句编写ー个函数,返回二维数组中所有元素的平均值,假定采用变量v存放平均值。6.按照下面函数原型语句编写ー个递归函数计算出数组a中n个元素的平方和并返回。intf(inta[],intn);7.按照函数原型语句“voidp(intn);”编写・个递归函数显示出如下图形,此图形是n=5的情况。5555544443332218.按照函数原型语句“voidp(intn);”编写ー个递归函数显示出如下图形,此图形是n=5的情况。1223334444555559.根据下面类中Count函数成员的原型和注释写出它的类外定义。classAA{int*a;intn;intMS;public:voidInitAA(intaa[],intnn,intms){if(nn>ms){coutくく“Error!”くくendl;exit(1);}MS=ms;n=nn;a=newint[MS];for(inti=0;ims){coutくく"Error!”くくendl;exit(1);}MS=ms;n=nn;a=newint[MS];for(inti=0;i

88)intSearch(intx);〃从数组a的前n个元素中顺序查找值为x的元素,〃若查找成功则返回元素的下标,否则返回一員)；5.根据下面类中MaxMin函数成员的原型和注释写出它的类外定义。classAA{int*a;intn;intMS;public:voidlnitAA(intaa[],intnn,intms){if(nn>ms){cout<<*Error!"«endl;exit(1);}MS=ms;n=nn;a=newint[MS];for(inti=0;ims){cout<<"Error!"«endl;exit(1);}MS=ms;n=nn;a=newint[MS];for(inti=0;ims){coutくく“Error!”くくendl;exit(1);}MS二ms;n=nn;a=newint[MS];for(inti=0;i

89intCompareBig(AAb):〃比较・this与b的大小,从前向后按两数组〃中的对应元素比较,若・this中元素值大则返回1,若b中〃元素值大则返回ー1,若相等则继续比较下ー个元素,直到〃一个数组中无元素比较,此时若两者的n值相同则返回0,〃否则若・this中的n值大则返回1»若b中的n值大则返回T。}；5.根据下面类中Reverse函数成员的原型和注释写出它的类外定义。classAA{int*a;intn;intMS;public:voidInitAA(intaa[],intnn,intms){if(nn>ms){coutくく“Error!”くくendl;exit(1);}MS=ms;n=nn;a=newint[MS];for(inti=0;ims){coutくく"Error!"くくendl;exit(1);}MS=ms;n=nn;a=newint[MS];for(inti=0;i

90for(inti=0;i

91〃结果(其长度为两数组长度之和)存入临时对象并返回intLenthO{returnn;}〃返回数组长度voidPrint(){〃输出数组for(inti=0;i

925.根据下面类中Uion函数的原型和注释写出它的类外定义。classStrings{char*s;〃指向动态分配的字符串数组空间intn;〃记录字符串长度public:Strings(char*str);〃构造函数,利用str字符串长度初始化n,〃利用str字符串初始化s所指的字符串空间Strings(Strings&str);〃拷贝构造函数StringsfiGive(Strings&str);〃实现str赋值给・this的功能并返回・thisStringsUion(Strings&str);〃实现・this和str中的字符串连接的功能,〃把连接结果存入临时对象并返回intLenthO{returnn;}〃返回字符串长度voidPrint0{cout<x){t=x;x=y;y=t;}}intVariance。{returnx*x-y*y;}〃其它函数从略}；voidmain。{A_classA_obj(3,5);coutくく"Result:"くくA_obj.Variance()«endl;)7.下面给出了矩阵类Matrix定义。为了求两个矩阵对象的乘积,需要定义ー个Matrix的友元函数Multiply。。请按照友元函数Multiply()的声明编写出该函数的定义。classMatrix{public:Matrix(introw,intcol);〃构造ー个具有row行co!列的矩阵^Matrix。{delete[]mem;}〃析构函数friendboolMultiply(Matrix&ml,Matrix&m2,Matrix&m3);〃定义Multiply。为友元函数,该函数把mlXm2的值赋给m3〃其他成员函数从略private:int*memI〃动态申请矩阵空间constintrows,cols;〃矩阵的行数和列数);Matrix::Matrix(introw,intcol):rows(row),cols(col){mem=newint[row*col];)

93boolMultiply(Matrix&ml,Matrix&m2,Matrix&m3){〃确定矩阵是否能够进行相乘if(ml.rows!=m3,rows||m2,cols!=m3,cols|ml.cols!=m2,rows)returnfalse;〃定义sum变量,用于计算乘积矩阵m3中每个元素的值intsum;//请在下面编写剩余部分5.已知类定义如下,其中Shape为基类,Circle和Rectangle分别Shape的直接派生类,Square为Rectangle的直接派生类和Shape的间接派生类。请模仿Circle类,写出Rectangle类的所有成员函数。/******************文件shape,h*************************/constfloatPI=3.14159f:〃定义圆周率常量classShape〃几何图形抽象类(public:virtualfloatGetPerimeter()=0:〃纯虚函数,计算周长virtualfloatGetAre()=0;〃纯虚函数,计算面积)；classCircle:publicShape〃圆类{public:Circle(floatrad):rad(rad){}"CircleO{}floatGetPerimeter(){return2*PI*rad;}〃计算圆形周长floatGetAre0{returnPl*rad*rad;}〃计算圆形面积private:floatrad:〃圆的半径}；classRectangle:publicShape〃矩形类{public:〃在下面编写每个成员函数private:floatlength,widthJ〃矩形的长和宽}；classSquare:publicRectangle〃正方形类(public:Square(floatlen):Rectangle(len,len){}"Square(){}

94}；5.已知类定义如下,其中Shape为基类,Circle和Rectangle分别Shape的直接派生类,Square为Rectangle的直接派生类和Shape的间接派生类。请模仿Rectangle类,写出Circle类的所有成员函数。/******************文件shape,h*************************/constfloatPI=3.14159f;〃定义圆周率常量classShape〃几何图形抽象类{public:virtualfloatGetPerimeter()=0:〃纯虚函数,计算周长〃纯虚函数,计算面积virtualfloatGetAre()=0;}；classRectangle:publicShape〃矩形类(public:Rectangle(floatlen,floatwid):length(len),width(wid){}^Rectangle0{}floatGetPerimeter(){return2*(length+width);}〃计算矩形周长floatGetAre0{returnlength*width;}〃计算矩形面积private:floatlength,width;〃矩形的长和宽)；classCircle:publicShape〃圆类(public:〃在下面编写每个成员函数private:floatrad;〃圆的半径)；classSquare:publicRectangle〃正方形类(public:Square(floatlen):Rectangle(len,len){}^Square(){}

95模拟试题（第一套）ー、单项选择题（每小题2分,共20分）1.设x和y均为bool量,则x||y为假的条件是（）。A,它们均为真B.其中一个为真C,它们均为假D.其中一个为假2.假定一个二维数组的定义语句为“inta[3][4]={{3,4},{2,8.6}）;”,则元素a[l][2]的值为（）«A.2B.4C.6D.83.假定p是具有int**类型的指针变量,则给p赋值的正确语句为（）。A.p=newint;B.p=newint*;C.p-newint**;D.p-newint[10];4.软件产品在需求发生变化、运行环境发生变化或发现软件产品本身的错误或不足时进行相应的软件更新的难易程度叫做软件的（）.A.可维护性B.可复用性C,兼容性D.正确性5.若需要把ー个类外定义的成员函数指明为内联函数,则必须把关键字（）放在函数原型或函数头的前面。A.inB.inlineC.inLineD.InLiner6,在ー个用数组实现的队列类中,假定数组长度为MS,队首元素位置为first,队列长度为length,则队尾的后一个位置为（）。A.length+1B.first+lengthC.（first+length-l）%MSD.（first+length）%MS7.假定一个类的构造函数为"A（intaa,intbb）{a=aa;b=aa*bb;}",则执行"Ax（4,5）;”语句后，x.a和x.b的值分别为（）.A.4和5B.5和4C.4和20D.20和58.假定AB为ー个类,则执行“AB*p=newAB（l,2）則语句时共调用该类构造函数的次数为（）。A.0B.1C.2D.39.ー个类的成员函数也可以成为另ー个类的友元函数,这时的友元声明（）类域的限定。A.需加上B.不需加上C.可加可不加D.取消10.队列具有（）的操作特性。A,先进先出B.先进后出C.进出无序D,仅进不出二、填空题（每小题2分,共20分）1.多行注释的开始标记符为。2.假定x=5,y=6,则表达式x++*++y的值为3.假定x是ー个逻辑量,则x&&true的值与x的值

961.含随机函数的表达式rand()%20的值在〇至的整数区间内。2.程序的编译是以为单位进行的。3.ー个数组的实际上是指向该数组的第一个元素的指针,并且在任何时候都不允许修改它。4.指针变量pv和pc定义为"void*pv="Hello,word!n;char*pc;",要将pv值赋给pc.则正确的赋值语句是pc=()pvo5.ー个类的函数通常用于实现释放该类对象中指针成员所指向的动态存储空间的任务。6.假定用户为类AB定义了一个构造函数“AB(intaa):a(aa){}",则是该类的数据成员。7.在多文件结构的程序中,通常把含有main。函数的文件称为该程序的〇三、程序填充题，根据题意在横线上填写合适的内容。(每小题6分，共24分)1.采用辗转相除法求出两个整数的最大公约数。#includevoidmain(){inta,b;coutくく”请输入两个正整数:"；cin»a>>b;while(a<=0I|b<=0){coutくく”重新输入:";cin»a>>b;}while(b){intr;r=a%b;；;〃分别修改a和b的值}cout«a«endl;〃输出最大公约数2.用插入排序方法对table指针数组中size个指针所指向的字符串进行按升序排序的算法。voidsort(char*table[],intsize){for(inti=l;i=0;j)if(strcmp(p,table[j])<0)table[j+l]=;elsebreak;table[j+l]=;

971.类A的定义classA{char*a;public:AO{a二NULL;}〃定义无参构造函数,使a为空指针A(char*aa){a=char[strlen(aa)+l];strcpy(a,aa)1〃用aa所指字符串初始化a所指向的动态存储空间}〃定义析构函数,删除a所指向的动态存储空间)；2.类Goods的定义class(private:charName[20]:〃商品名称intWeight;〃商品重量staticinttotalWeight;〃同类商品总重量public:Goods(char*str,intw){〃构造函数strcpy(Name,str);Weight=w;totalWeight+=Weight;)“Goods(){totalWeight一二Weight;}char*GetNO{;}〃返回商品名称intGetW(){returnweight;}staticintGetTotalWeight(){〃定义静态成员函数返回总重量四、理解问答题,分别写出前2小题的程序运行结果和指出后2小题的程序或函数功能。(每小题6分,共24分)1.#includeconstintT=6;voidmain()(inti,j,k=0;for(i=l;i<=T;i+=2){for(j=2;j<=T;j+=2)k++;coutくく"k="«k«endl;

98运行结果:1.#includeclassCE{private:inta,b;intgetmax(){return(a>b?a:b);}public:intc;voidSetValue(intxl,intx2,intx3){a=xl;b=x2;c=x3;)intGetMax();}；intCE::GetMax(){intd=getmax();return(d>c?d:c);)voidmain(){intx=5,y=12,z=8;CEex;ex.SetValue(x,y,z);cout<voidmainO{inti,p=l;intN;coutくく”输入ー个正整数:"；cin»N;for(i=l;i<=N;i++)p*=i;coutくく"N!="«p«endl;)程序功能:3.intf(char*s)(inti=0;while(*s++)i++;returni;函数功能:五、编程题(每小题6分,共12分)1.编写ー个函数,分别求出由指针a所指向的字符串中包含的每种十进制数字出现的次数,把统计结果保存在数组b的相应元素中,该函数的原型声明如下:voidfun(char*a,intb口)；2.根据下面类中CompareBig函数成员的原型和注释写出它的类外定义。classAA{int*a;

99intn;intMS;public:voidInitAA(intaa[],intnn,intms){if(nn>ms){coutくく“Error!”くくendl;exit(1);}MS=ms;n=nn;a=newint[MS];for(inti=0;i

100模拟试题（第二套）ー、单项选择题（每小题2分,共20分）1.字符串"a+b=12

101”的长度为（）。A.6B.7C.8D.92.假定一个二维数组的定义语句为“inta[3][4]={{3,4},{2,8.6}）;”,则元素a[2][1]的值为（）«A.0B.4C.8D.63.以下正确的描述是（）«A,函数的定义可以嵌套,函数的调用不可以嵌套B,函数的定义不可以嵌套,函数的调用可以嵌套C,函数的定义和函数的调用均可以嵌套I）,函数的定义和函数的调用均不可以嵌套4.设有定义“doublearray[10];”，则表达式sizeof（array）/sizeof（array[0]）的结果为array数组的（）〇A.首地址B.元素个数C.每个元素所占的字节数D.总字节数5.若使p指向包含30个整型元素的动态数组空间,则使用的定义语句为（）。A.int*p=newint[30];B.int*p=newint（30）;C.int*p=new[30];D.*p=newint[30];6.软件产品与其他软件产品组合成一个整体的难易程度叫做软件的（）。A.可维护性B.可复用性C,兼容性D.正确性7.在多文件结构的程序中,通常把类的声明单独存放于（）中。A.主文件B.实现文件C.库文件D,头文件8.在一个用数组实现的队列类中,假定数组长度为MS,队首元素位置为first,队列长度为length,则队首的后一个位置为（）,A.first+1B.（first+l）%MSC.（first-l）%MSD.（first+length）%MS9.假定一个类的构造函数为"A（intaa=l,intbb=O）{a=aa;b=bb;}”,则执行‘'Ax（4）;”语句后,スぶ和スメ的值分别为（）»A.1和〇B.1和4C.4和1D.4和〇10.假定AB为一个类,则执行“ABa（2）,b[3个・p[4];”语句时共调用该类构造函数的次数为（）«A.3B.4C.5D.9二、填空题（每小题2分,共20分）1.用于输出表达式值的标准输出流对象是。

1021.假定x=5,y=6,则表达式x—*—y的值为02.假定x是一个逻辑量,则x||true的值为。3.C++提供的预处理命令有宏定义命令,条件编译命令和命令。4.假定a是ー个ー维数组,则a[i]的指针访问方式为.5.变量v定义为"doublev=23.4;”,要使指针pv指向v,则定义pv的语句为〇6.若在类的定义体中只给出了一个成员函数的原型,则在类外给出完整定义时，其函数名前必须加上和两个冒号分隔符。7.若采用x.abc(y)表达式调用一个成员函数，在成员函数中使用的就代表了类外的x对象。8.假定用户没有给ー个名为AB的类定义析构函数,则系统为其定义的析构函数为9.假定用户只为类AB定义了一个构造函数"AB(intaa,intbb=O){a=aa;b=bb;}",则定义该类的対象时，其实参表中至多带有个实参。三、程序填充题,根据题意在横线上填写合适的内容。(每小题6分,共24分)1.下面函数是求两个整型参数a和b的最小公倍数。intf2(inta,intb){inti=2,p=l;do{while(a%i==0&&){p*=i;a/=i;b/=i;}i++;}while(a>=i&&)：returnp*a*b;)2.对数组a中的元素按相反次序重新排列。voidPV(inta[],intn)(inti：for(i=0;i

1031.假定有定义为"structNODE{intdata;NODE*next;};”,下面算法是把以L为表头指针的链表中各结点依次按相反次序链接并返回新链表的表头指针。NODE*f8(NODE*L)(if(L==NULL)returnNULL;NODE*p=NULL,*q=L,*t;//p为新链表的表头指针,初始值为空while(q!=NULL){t=q；q=q->next;t->next=;P=；)returnp;)2.类A的定义classA{int*a;intn;intMaxLen;public:A():a(0),n(0),MaxLen(0){}〃无参构造函数A(int*aa,intnn,intMM){〃带参构造函数n二nn;MaxLen=MM;if(n>MaxLen)exit(1);a=newint[MaxLen];for(inti=0;iconstintB=2;voidmain()(intp=l,s=l;while(s<50){p*=B;s+=p；}coutくく"s=”くくsくくendl;)运行结果:2.#includeclassCE{private:inta,b;intgetminO{return(a

104intx=5,y=12,z=8;CE*ep=newCE;ep->SetValue(x+y,y-z,10);cout<GetMin()<

1052.根据下面类中拷贝构造函数的原型写出它的类外定义。classArray{int*a;intn;public:〃指向动态分配的整型数组空间〃记录数组长度Array(intaa[],intnn);〃构造函数,利用aa数组长度nn初始化n,〃利用aa数组初始化a所指向的数组空间Array(Array&aa);〃拷贝构造函数)；模拟试题(第三套)ー、单项选择题(每小题2分,共20分)1.C++程序的基本功能模块为()。A,表达式B.标识符C.语句D.函数2.当处理特定问题的循环次数已知时,通常采用()来解决。A.for循环B.while循环C.do循环D.switch语句3.下面函数原型语句正确的是()。A.intFunction(voida);B.voidFunction(int);C.intFunction(a);D.int(doublea);4.假定变量m定义为“intm=7;"，则定义变量p的正确语句为()。A.intp=&m;B.int*p=&m;C.int&p=*m;D.int*p=m;5.假定变量a和pa定义为doublea[10],*pa=a;"，要将12.35赋值给数组a中的下标为5的元素,不正确的语句是()。A.pa[5]=12.35;B.a[5]=12.35;C.*(pa+5)=12.35;D.*(a[0]+5)=12.35;6.假定AA为ー个类，a为该类私有的数据成员,GetValueO为该类公有函数成员,它返回a的值,x为该类的ー个对象,则访问x对象中数据成员a的格式为()。A.x.aB.x.a()C.x->GetValue()D.x.GetValueO7.类的构造函数是在定义该类的ー个()时被自动调用执行的。A,成员函数B.数据成员C.对象D,友元函数8.假定AB为ー个类，则执行“ABx;”语句时将自动调用该类的()。A.带参构造函数B.无参构造函数C.拷贝构造函数D.赋值重载函数9.假定一个类AB只含有一个整型数据成员a,当用户不定义任何构造函数时,系统为该类定义的无参构造函数为()。A.AB(){a=0;}B.AB(intaa=0):a(aa){}C.AB(intaa):a(aa){}D.AB(){}10.如果表达式a++中的“++”是作为普通函数重载的运算符,若采用运算符函数调用格式，则可表示为()。A.a.operator++()B.operator++(a)C.operator++(a,1)D.operator++(l,a)

106二、填空题(每小题2分，共20分)1.存储字符‘a，和字符串"a”分别需要占用和个字节。2.重载ー个函数的条件是:该函数必须在参数的ーー或参数对应的一ー上与其它同名函数不相同。3.假定p是ー个指向整数对象的指针,则用表示该整数对象,用表示指针变量P的地址。4.元素a[i]和b[i][j]的指针访问方式分别为和。5.已知有定义“intx,a[]={5,7,9},*pa=a;",在执行"x=++*pa;“语句后,x的值是,*(pa+l)的值为〇6.在ー个用数组实现的队列类中,假定数组长度为MS,队首元素位置为first,队列长度为length,则队列为空和队列为满的条件分别为和。7.对类中一和一成员的初始化只能通过在构造函数中给出的初始化表项来实现的。8.假定AB为ー个类,该类中含有一个指向动态数组空间的指针成员pa,则在该类的析构函数中应该包含有一条语句。9.假定派生类及其基类中都定义有同名函数成员,若要在派生类中调用基类的同名函数成员时,就需要在其函数名前加上和。10.派生类的成员函数能够直接访问所含基类的成员函数和成员函数。三、程序填充题,对程序、函数或类中划有横线的位置,根据题意按标号把合适的内容填写到程序后面的标号处。(每小题5分,共20分)11统计字符串中英文字母个数的程序。#includeintcount(charstrロ)；voidmain(){charsi[80];coutくく“Enteraline:";cin»sl;cout«"count="«count(si)«endl;)intcount(charstr[]){intnum=0;〃给统计变量赋初值for(inti=0;str[i];i++)if(str[i]>=>a'&&str[i]くニ‘z'||(1))(2);一⑶一;)11)(2)(3)2.对数组a[n]中的n个元素按升序进行的选择排序算法。voidSelectSort(inta[],(1)){inti,j,k;for(i=l;i

107)(1)(2)(3)3.下面是一维数组类ARRAY的定义,ARRAY与普通一维数组的区别是:(a)用()而不是口进行下标访问,(b)下标从1而不是从。开始,(c)要对下标是否越界进行检査。classARRAY{

108int*vi〃指向存放数组数据的空间ints:〃数组大小public:ARRAY(inta[],intn);"ARRAY(){delete[]v;}intsizeO{returns;}int&operator()(intn);)；_(1)operator()(intn)//()的运算符成员函数定义(if((2)){cerrくく”下标越界!”；exit(1);)return(3)_;)⑴⑵(3)3.ー种类定义如下:classGoodsprivate:〃商品名称〃商品重量〃同类商品总重量〃构造函数chargdname[20];intweight;staticinttotalweight;public:Goods(char*str,intw){strcpy(gd_name,str);weight=w;totalweight+=weight;"Goods(){totalweight-=weight;}char*GetNO{(1);}〃返回商品名称intGetW(){returnweight;}(2)GetTotal_Weight(){〃定义静态成员函数返回总重量_(3);四、理解问答题,写出前三小题的程序运行结果和指出后两小题的程序(或函数)所能实现的功能。(每小题6分,共30分)1.#includeくiomanip.h>constintN=3;voidmain(){inta[N][N]={{7,-5,3},{2,8,-6},{1,-4,-2)};intb[N][N]={{3,6,-9},{2,-8,3},{5,-2,-7}};inti,j,c[N][N];for(i=0;iくN;i++)〃计算矩阵Cfor(j=0;j

109运行结果:1.#include#includeclassA{char*a;public:A(char*s){a=newchar[strlen(s)+l];strcpy(a,s);cout<classA{inta,b;public:A(){a=b=0;}A(intaa,intbb){a=aa;b=bb;}intSumO{returna+b;}int*MultO{int*p=newint(a*b);returnp;));voidmain(){Ax(2,3),*p;p=newA(4,5);cout<Sum()«*'«*(p->Mult())<boolfun8(Ta[],intn,Tkey)(for(inti=0;i

110int*a;〃指向动态分配的整型数组空间intn;〃记录数组长度public:Array(intaa[],intnn);〃构造函数,利用aa数组长度nn初始化n,〃利用aa数组初始化a所指向的数组空间Array(Array&aa);〃拷贝构造函数Array&Give(Array&aa);〃实现aa赋值给・this的功能并返回*thisArrayUion(Array&aa)J〃实现・this和aa中的数组合并的〃功能,把合并结果存入临时对象并返回intLenthO{returnn;}〃返回数组长度voidPrint(){〃输出数组for(inti=0;iaD.x.a7.假定AB为一个类,则执行’'ABx（a,5）;”语句时将自动调用该类的（）„A.带参构造函数B.无参构造函数C,拷贝构造函数D.赋值重载函数8.对于任一个类,用户所能定义的析构函数的个数至多为（）«A.0B.1C.2D,任意个9.对类中引用成员的初始化是通过构造函数中给出的（）实现的。A.函数体B.参数表C.初始化表D.初始化表或函数体10.如果表达式a==b中的“==”是作为普通函数重载的运算符,若采用运算符函数调用格式，则可表示为（）。A.a.operator=（b）B.b.operator==（a）C.operator"（a,b）D.operator"（b,a）

111二、填空题（每小题2分,共20分）1.常数ー4.205和6.7E-9分别具有和位有效数字。2.元素类型为double的二维数组a[4][6]共有一ー个元素,共占用一丁」的存储空间。3.假定对二维数组a[3][4]进行初始化的数据为{{3,5,6},{2,8},{7}},则a[l][l]和a[2][3]分别被初始化为和。4.假定p为指向二维数组intd[4][6]的指针,则p的类型为,其中一个元素d[i][j]表示成指针访问方式为。5.已知变量a定义为“inta=5;",要使ra成为a的引用,则ra应定义为,要使rb指向a,则rb应定义为〇6.若只需要通过ー个成员函数读取其数据成员的值,而不需要修改它们,则应在函数头的后面加上关键字;若只需要读取引用参数的值,不需要对其修改,则应在该参数说明的开始使用关键字。7.假定一个类对象数组为A[N],当定义该数组时，将自动调用该类的无参构造函数的次数为次，当离开它的作用域时，将自动调用该类析构函数的次数为次。8.假定AB为ー个类,则类定义体中的“AB(AB&x);”语句为该类ー的腹型语句，而"operator(AB&x);”为该类的原型语句。9.在定义ー个派生类时，使用ー关键字表示为私有继承,使用关键字表示为公有继承。10.重载ー个运算符时,该运算符的ヽ以及操作符的个数不允许改变。三、程序填充题,对程序、函数或类中划有横线的位置，根据题意按标号把合适的内容填写到程序后面的标号处。(每小题5分，共20分)1.在输出屏幕上打印出一个由字符‘*’组成的等腰三角形,该三角形的高为5行,从上到下每行的字符数依次为1,3,5,7,9〇#includevoidmain()(inti,j;for(i=l;—(1)—;i++){for(j=l;j<=9;j++)if(j<=5-iII(2))cout«'';else(3);cout«endl;))11)(2)(3)2.从一个字符串中删除所有同一字符后得到ー个新字符串并输出。#includeconstintlen=20;voiddelstr(chara[],charb[],charc);voidmain(){charstrl[len],str2[len];charch;coutくぐ输入一个字符串:"；cin»strl;cout«”输入一个待删除的字符;”;

112cin»ch;delstr(strl,str2,ch);cout«str2«endl;voiddelstr(chara[],charb[],charc)intj=0;for(inti=0;(1);i++)if(—(2)—)b[j++]=a[i];b[j]=—(2)—:)(1)(2)(3)3.已知一维数组类ARRAY的定义如下,ARRAY与普通・维数组区别是:其重载的运算符[]要对下标是否越界进行检查。classARRAY{int*v;//指向存放数组数据的空间intsJ〃数组大小public:ARRAY(inta[],intn);ARRAY(){delete[]v;}intsizeO{returns;}int&operator[](intn);)；(1)operator[](intn)〃[]的运算符成员函数定义(if(n<0II(2)){cerrくく”下标越界!”;exit(1);)return(3);)(1)(2)(3)4.一个类定义如下:classPointIprivate:intx,y;public:Point(){x=y=0;}Point(intxO,intyO){x=xO;y=yO;}intGetX(){returnx;}intGetY(){returny;}voidPrint(){cout«"Point("«x«","«y«")"«endl;}—⑴—;〃友元函数声明(2)—;〃友元函数声明)；Pointoperator+(Point&pt,intdd)〃加号操作符重载函数,实现Point类对象与整数的加法{Pointtemp=pt;temp.x+=dd;temp.y+=dd;returntemp：Pointoperator+(Pointftptl,Point&pt2)〃加号操作符重载函数,实现两个Point类对象的加法{Pointtemp=pt1;temp.x+=pt2.x;temp.y+=pt2.y;(3)_；

113}(1)(2)(3)四、理解问答题,写出前三小题的程序运行结果和指出后两小题的程序(或函数)所能实现的功能。(每小题6分,共30分)1.#includeconstintB=2;voidmain()(intp=l,s=l;while(s<50){p*=B;s十二p;}coutくく"s=”くくsくくendl;)运行结果:2.#inc1udeclassCE{private:inta,b;intgetminO{return(aSetValue(x+y,y-z,10);cout«ep->GetMin()<classA{inta[10];intn;public:A(intaa[],intnn):n(nn){for(inti=0;i#include#includeconstintN=10;int

114ff(intx,inty){intz;coutくくxくく’+’くくyくく‘二’；cin>>z;it(x+yニニz)return1;elsereturn0;inta,b,c=0;srand(time(0));〃初始化随机数序列for(inti=0;i=，a*&&s[i]く='z')r[i]=s[i]-'a'+'A';elser[i]=s[i];r[n]=,\Qf;returnr;)程序功能:五、编程题(每小题5分,共10分)1.编写一个函数,分别求出由指针a所指向的字符串中包含的每种十进制数字出现的次数,把统计结果保存在数组b的相应元素中,该函数的原型如下。voidfun(char*a,intbロ)；2.根据下面类中CompareBig函数成员的原型和注释写出它的类外定义。classAA{int*a;intn;intMS;public:voidInitAA(intaa[],intnn,intms){if(nn>ms){cout«"Error!"<

115〃否则若・this中的n值大则返回1,若b中的n值大则返回ー1。《面向对象程序设计》综合复习题集参考解答

116ー、单选题1.A2.C3.B4.B5.B6.C7.A8.D9.B10.D11.D12.C13.D14.D15.C16.A17.B18.A19.C20.B21.B22.C23.C24.B25.D26.C27.A28.A29.C30.B31.D32.C33.D34.C35.C36.A37.B38.B39.C40.A41.C42.C43.A44.B45.B46.A47.B48.B49.C50.B51.D52.B53.A54.D55.C56.D57.C58.B59.C60.D61.D62.B63.A64.C65.A66.C67.C68.B69.B70.C71.A72.D73.B74.D75.A76.C77.D78.D79.C80.C81.D82.A83.B84.D85.A86.A87.B88.C89.D90.C91.A92.D93.D94.B95.D96.C97.A98.B.99.C100.D101.A102.B103.B104.C105.D106.B107.A108.D109.B110.C111.D112.A113.A114.B115.D116.B117.A118.C119.A120.B121.D122.C123.A124.C125.B126.A127.C128.C129.D130.B131.D132.C133.A134.B135.A136.C137.C138.B139.A140.C141.B142.A143.D144.D145.B146.A147.C148.D149.B150.C151.D152.C153.D154.B155.A156.C157.D158.C159.D160.A161.A162.B163.D164.B165.C166.B167.C168.C169.D170.A171.C172.D173.B174.A175.D176.D177.C178.A179.D180.B181.B182.C183.A184.C185.C186.D187.C188.B189.A190.C191.D192.A193.A194.D195.B196.C197.B198.C199.B200.D201.C202.B203.A204.C205.B206.D207.D208.A二、判断题1X6X11X16J21V26V31V36J41V2J7X12X17X22X27J32X37V3V8X13V18V23428X33V38V4X9X14V19X24X29X34J39X5V10V15X20X25V30V35V40V三、填空题1.C2..cpp、程ノ予3.//4./・ヽ5.cout6.cin7.main8.复合9.空白10.#include11.#12.分号13.用户（或编程者）14.程序15.函数头、函数体16.原型（或声明）17..h、.cpp18.警告（warning）、致命(error)19.void20.void21.int022.下一行23.3524.2525.6、3026.4、1127.32528.22929.0xF5（F大小写均可）30.036531.-128ヽ+12732.44、

11733.4、834.1、135.2、436.1537.1538.739.640.1、341.3、3.242.X43.true(或1)14.false(或〇)45.x46.!x47.false(或〇)18.true(或D49.(x+y)/(2*x*y)50.3*x*y/(x+y)51.l/(a*x*x+b*y*y)52.153.3、54.4、255.枚举常量、整数56.int、double57.6、6058.4、159.2060.921661.〇、1962.常量63.if64.switch65.不停止66.1167.1068.break69.continue70.return71.主（或main）72.4073.19274.30075.1、276.〇、177.878.1179.n+180.cin»a81.cout<Tcubin(Tn){returnn*n*n;}95.void96.static97.右边（或后面）98.extern99.头文件100.函数体101.文件包含命令102.文件103.代码区（程序区）104.全局数据105.栈106.i*m+j+l107.2、4108.13109.总和110.4111.地址DataType*112.(char*)p113.int**114.*pp115.*p、p116.*p、*p117.25118.42119.26120.42121.4*i122.*(a+i)123.a+i*sizeof(a[i])124.第一个、修改125.b[7]、b[2]126.int*p=x;127.*p128.int[n]>int*129.c⑶[0]、c[3][2]130.int(*)[6]131.*(a[i]+j)或・(*(a+i)+j)或・(a+i)[j]132.inty=x;133.x134.相等、X135.*p136.p[〇]、・P137.ra'138.char(*)[n]139.deletep140.delete[]p141.0(或‘、〇’)142.double*pv=v;143.H144.pie145.pc=(char*)pv;146.int(*p)[100]=b;147.(*p).name148.fp->score149.intra=a;150.6151.10152.17153.对象154.实例155.封装156.继承157.聚合158.抽象、封装体159.继承160.多继承（或多重继承）161.单继承162.编译、运行163.重载、虚函数164.设计、实现165.问题域、应用166.函数167.private(或私有)168.public(或公有)169.private(或私有)170.public(或公有)171.private172.内联173.类名174.冒号175.inline176.作用域177.AA*AA::abc()178.不在

118179.const180.const181.*this182.this183.187.类定义184.(first+length)MS不能够185.188.队列长度(first+l)MS186.队首189.193.195.length==0190.队首ElemHead->nextlength==MS191.194.196.删除队尾ElemTail192.插入197.NULL198.相同199.相同200.2201.205.207.构造202.~AB(){}动态存储空间析构203.206.208.构造函数无参构造函数析构函数204.ABO{}209.10210.N211.初始化表212.初始化表213.初始化表214.函数体215.constintaa;216.intaa;217.AB(intaa):a(aa){}218.AB(intaa):a(aa){};219.析构函数220.不会221.2222.a223.2224.1225.2226.1227.231.3228.拷贝构造函数232.错误229.正确AB(AB)(注:可附带任何ー个名字的参数)230.错误233.delete[]pa;234.只能、不能235.初始化236.类域237.优先级238.〇、1239.1、2240.赋值241.2242.成员函数243.ostream244.istream245.2246.成员247.返回值、空249.公有和保护、私有250.公有和保护、251.private、私有252.类名253.虚基类254.二义性255.this四、程序填充1.(1)fl+f2(2)i%5==0(3)f2.(1)x(2)i(3)-j3.(1)n<=99(2)i<=temp(3)break4.(1)b<=0(2)a=b(3)b=r5.(1)x<3(或xく:2)(2)x%i=0(3)i++6.(1)b%i==0(2)i++(或++i)(3)b>=i7.(1)i<=5(2)j〉=5+I(3)coutくぐ*，8.(1)str[i]>=,A,&&str[i]<=,Z,(2)num++(3)returnnum9.(1)voidfun(charss[])(2)fun(s)(3)inext(3)p->data248.任何继承(派生)

11920.(1)q->next21.(1)int&ARRAY::22.(1)ARRAY::23.(1)int&ARRAY::24.(1)AA::MaxA()25.(1)26.(1)27.(1)28.(1)29.(1)30.(1)i=s(2)newint[n](2)ns⑵x=a[i](b){x=a[j];a[j+l]=a[j]x.MaxA()m=x.MaxA()(2)(2)top++(或++top)elem[top-](3)returnp(3)v[n](或*(v+n))⑶v[i]=a[i](3)v[n-l](或・(v+nT))(3)returnxk=j;}(c)a[i]=x(3)break(3)x.PrintAO(3)x.SortAO(3)newElem(3)PopO31.答案:(1)A(intaa):a(aa)(2)A*p(3)p=newA(5)32.答案:(1)A(){a=0;}或A():a(0){}注:数据〇可用NULL代替(2)newchar[strlen(aa)+l](3)、A(){delete[]a;}33.答案:(1):a(aa),b(bb)(2)Ax(5),y(x)注:x(5)与x=5等效,y(x)与y=x等效(3)A*p=&x34.答案:(1)A(intaa=0,intbb=O){a=aa;b=bb;}(2)pl=newA(3)p2=newA(4,5)35.答案:(1)a=newint[MaxLen](b){returna[i];}(c)s+=r.GetValue(i)36.答案:(1)for(inti=0;i

120min:18

1211.1235813213455892.s=603.121a,b,c=7,12,304.1114switchend.6.36139-517388677.114138558.111223369424339.1064]0***************11.15711133712.++*+*****13.12122230326614.s=6315.26416.101-640-36-6-917.102515351025

12218.x=13,y=21

123x=5,y=8,z=3419.x,y=10,26x,y=26,10y,y=10,26z,y=25,1120.29285721.555022.431423.215224.workercadre25.58111426.+-*/abed123427.year:4month:5day:328.abedef30shenyafen9529.abedef30abcdefxyz5030.122031.42732.a:7/12b:-3/8c:5/24d:19/2433.a:6/15b:3/10c:7/10d:11/1034.xuxiaokai

124weirongDestructor!Destructor!19.15820.1234000XxkXxkXxk21.5692022.d=800f=4023.146402.5@非法运算符!24.Point:34Circleradius:5Circledestructor!Pointdestructor!25.Point:34Textcon!PointwithTextcon!PointwithTextdesTextdes!Pointdes!26.2000/1/10:0:02002/10/123:59:592002/12/310:0:027.2001/1/15:30:02002/10/16:20:02003/3/86:7:028.Based,2)Next(10,15)Base(5,7)29.10,20,30,4015,26,30,4015,26,210,28030.B_objx=100Dobjy=200B_objx=300Dobjy=400

125六、指出以下程序或函数的功能1.计算并输出2?+4ゝ62+…+302的值。2.随机产生出10个10至100之间的素数并显示出来。3.此函数用于把卜进制整数x转换为卜六进制数字串输出4.计算并输出1+ナ印的值,其中a的值由键盘输入。5.以参数a和b为运算对象,以参数op为四则算术运算符,求出运算结果并返回。6.把从键盘上输入的ー个整数x分解为所有可能的每两个因子之积。7.计算并输出fi!的值，其中N值由键盘输入。8.让计算机随机产生出I0道加数在20以内整数的加法题供用户计算,每道题10分，计算完成后打印出得分。9.用递归求出1+22+3ゝ...+バ的值。10.实现字符串系统函数strcpy的功能,把b所指的字符串拷贝到a所指的字符数组空间中。11.函数模板，从ー维数组a[n]中查找值为key的元素，若查找成功则返回真否则返回假。12.显示输出数组a[n]中大于等于平均值的所有元素值。13.对于二维字符数组a中保存的M个字符串，分别统计并输出其长度小于5、大于等于5且小于15、大于等于15的字符串个数。14.从一个二维整型数组中査找具有最大值的元素，由引用参数row和col带回该元素的行号和列号。15.ー个递归函数过程，求出两个自然数m和n的最小公倍数。16.实现strcat函数的功能，把str2所指字符串连接到strl所指字符串的后面,并返回str!指针。17.实现strcmp函数的功能，比较两个字符串strl和str2的大小，若strl较大则返回1,若str2较大则返回T,若两者相等则返回〇。18.从表头指针f指向的、由IntNode类型的结点所构成的链表中查找出data域的值最大的结点并返回指向该结点的指针。19.统计出以表头指针为f的链表中结点的个数。20.对于以表头指针为f的链表，依次显示出每个结点的data域的值。21.首先从键盘上输入ー个整数给n,然后依次输入n个整数建立以表头指针为f的链表。22.求出并返回字符指针参数s所指向的字符串长度。23.根据参数s所指向的字符串,生成一个由r所指向的新字符串并返回，该字符串使s字符串中的小写字母均变为大写。七、程序改错1.28NODE*p=newNODE;pl->next二p;2.35p=newNODE;pー〉next二plist;3.578b.InitFranctiond,3);c=a.FranAdd(b);c.FranOutput()4.6910b->InitFranction(3,4);c=aー〉FranAdd(*b);c.FranOutput()5.5912public:}intCE::GetMin(){6.456

126Public:A():c(0),a(0),b(0){}A(intaa,intbb):c(aa+bb){a=aa;b=bb;}7.589在函数体给常量c赋值定义b多一个参数定义y少ー个参数8.131517在函数体给常量c赋值缺少分号定义z多一个参数,分号前多一个逗号9.51920a[i]=aa[i];d*=x.Get(i);intf=x.SumA(6);10.25friendfract&operator+=(fract&,fract);fract&operator+=(fract&fl,fractf2);ハ、程序设计1.若采用for循环编写程序,则如下所示:voidmain(){inti=0;doubles=0;while(s<5)s+=double(l)/++i;coutくく"n=”くくiくくendl;)#includevoidmain(){inti;doubles=0;for(i=l;s<5;i++)s+=l.0/i;cout«"n="<voidmain()inti!〃用i作为循环变量intp=l:〃用p作为累乘变量ints=l;〃用s作为累加循环变量for(i=l;i<=10：i++){p*=3;s+=p;}cout<voidmain()(inti=0:〃用i作为依次取值偶数的变量ints=0;〃用s作为累加变量do{i+=2;s+=i*i;}while(s<1000);coutくく“n=”くくi-2くくendl;)4.#include#includeconstdoublea=10.2;voidmain()(doublex,y;cin»x;while(x!=-100){if(x<=0)y=sqrt(a*a+x*x);elsey=3*a*x*x+4*a*xT;

127coutくくxくく''«y«endl;cin»x;})1.#includevoidmain()(intx,max;cin»x;max=x;for(inti=0;i<9;i++){cin»x;if(x>max)max=x;)cout«"max:<voidmain()(inta,b;for(a=6;a<=30;a++)for(b=15;b<=36;b++)if(2*a+5*b==126)coutくぐ(’くくaくぐ,’くくbくぐ)'くくendl;)3.#includevoidmain()(intcl,c2,c3;doublex;cl=c2=c3=0;cin»x;while(x>0){if(x<=12)cl++;elseif(x<=15)c2++;elsec3++;cin»x;}coutくくclくく，，くくc2くく，z«c3«endl;)4.voidfun4(char*a,intb口)(inti;for(i=0;i<10;i++)b[i]=0;while(*a){intj二・a-，〇，；

128if(j>=0&&j<=9)b[j]++;a++;}}1.doubleMean(doublea[M][N],intm,intn);doubleMean(doublea[M][N],intm,intn){inti,j;doublev=0.0;for(i=0;i

1298.intAA::Search(intx){inti;for(i=0;iくn;i++)if(a[i]==x)returni;return-1;}9.intAA::MaxMin(int&x,int&y)intmx,my;mx=my二a[0];for(inti=l;imx)mx=a[i];if(a[i]0)return1;elsereturn0;)10.intAA::Compare(AAb)(if(n!=b.n)return0;for(inti=0;ib.n)k=b.n;elsek=n;for(inti=0;ib.a[i])return1;elseif(a[i]

130inti,x;for(i=0;in=n;px->MS=MS;px->a=newint[MS];for(inti=0;ia[n-l-i]=a[i];returnpx;}9.Array::Array(intaa[],intnn){n=nn;a二newint[n];for(inti=0;i

131Arrayr(w,k);returnr;}8.Strings::Strings(char*str){n=strlen(str);s=newchar[n+1];strcpy(s,str);

132Strings::Strings(Stringsftstr){n=str.n;s=newchar[n+1];strcpy(s,str.s);}26.Strings&Strings::Give(Strings&str){delete[]s;n=str.n;s=newchar[n+1];strcpy(s,str.s);return*this;}27.StringsStrings::Uion(Strings&str){Stringsr(つ;r.n=n+str.n;r.s=newchar[r.n+1];strcpy(r.s,s);strcat(r.s,str.s);returnr;)28.classA_class{private:intx,y,t;public:A_class(inti,intj):x(i),y(j){if(y>x){t=x;x=y;y=t;};}〃其它函数从略friendintVariance(A_class&ac):〃参数名任意}；intVariance(A_class&ac){returnac.x*ac.x-ac.y*ac.y;}voidmain(){A_classA_obj(3,5);coutくく“Result:"くくVariance(A_obj)<

13326.Rectangle(floatlen,floatwid):length(len),width(wid){}"Rectangle0{}floatGetPerimeter(){return2*(length+width);}〃计算矩形周长floatGetAre(){returnlength*width;}〃计算矩形面积27.Circle(floatrad):rad(rad){}"CircleO()floatGetPerimeter(){return2*PI*rad;}〃计算圆形周长floatGetAre0{returnPl*rad*rad;}〃计算圆形面积

134模拟试题（第一套）ー、单项选择题（每小题2分,共20分）1.C2.C3.B4.A5.B6.D7.C8.B9.A10.A二、填空题（每小题2分,共20分）1./*2.353.相同4.195.文件6.数组名7.char*8.析构9.a10.主文件三、程序填充题,根据题意在横线上填写合适的内容。（每小题6分，共24分）评分标准:每空3分1.a=b>b=r2.tabletj]>p3.new、~A（）{delete[]a;}4.returnName、returntotalWeight四、理解问答题,分别写出前2小题的程序运行结果和指出后2小题的程序或函数功能。（每小题6分,共24分）1.k=92.123.计算并输出N阶乘的值,其中N值由键盘输入。4.求出并返回字符指针参数s所指向的字符串长度。五、编程题(每小题6分,共12分)评分标准:按编程完整程度酌情给分。1.voidfun(char*a,intb[])(inti;for(i=0;i<10;i++)b[i]=0;〃2分while(*a){intj二・a-，〇，；if(j>=0&&j<=9)b[j]++;a++;)//6分)2.intAA::CompareBig(AA&b){intk;if(n>b.n)k=b.n;elsek=n:〃1分for(inti=0;ib.a[i])return1;elseif(a[i]

135elseif(k

136ー、单项选择题每小题2分,共20分)1.B2.A3.B4.B5.A6.C7.D8.B9.D10.B二、填空题(每小题2分,共20分)1.cout2.253.true(或1)4.文件包含5.*(a+i)6.double*pv=&v;7.类名8.*this9.~AB(){}10.2三、程序填充题,根据题意在横线上填写合适的内容。(每小题6分,共24分)评分标准:每空3分。1.b%i==0>b>=i2.a[i]=a[n-i-l]>a[n-i-l]=x3.p、t4.a[i]=aa[i]>delete[]a四、理解问答题,分别写出前2小题的程序运行结果和指出后2小题的程序或函数功能。(每小题6分,共24分)评分标准:第3、4小题根据叙述完整程度酌情给分。1.s二632.43.以参数x和y作为运算对象,以参数。p所存字符作为运算符,要求从键盘上输入运算结果,若正确则返回1否则返回〇。4.根据参数s所指向的字符串,生成一个山r所指向的新字符串并返回,该字符串使s字符串中的小写字母均变为大写。五、编程题(每小题6分,共12分)评分标准:按编程完整程度酌情给分。1.intf(inta[],intn)(if(n==0)return0;〃1分elsereturna[nT]*a[nT]+f(a,nT);〃6分)2.Array::Array(Array&aa){n=aa.n;〃1分a=newint[n];〃3分for(inti=0;i

137模拟试题(第三套)ー、单项选择题(每小题2分,共20分)1.D2.A3.B4.B5.D6.D7.C8.B9.D10.C二、填空题(每小题2分,共20分)评分标准:每小题若有两个空,则每空1分;若只有一个空,则每空2分。1.122.个数(或数目)类型3.*p&p4.*(a+i)*(*(b+i)+j)5.676.length—0length—MS7.对象基类常量引用(四取二即可)8.delete[]pa;9.基类名类区分符10.公有保护三、程序填充题,对程序、函数或类中划有横线的位置,根据题意按标号把合适的内容填写到程序后面的标号处。(每小题5分,共20分)评分标准:对ー空给2分,对两空给4分,对三空给5分。1.(1)str[i]>='A'&&str[i]く='Z'(2)num++(3)returnnum2.(1)intn(2)k=j(3)a[k]=x3.(1)int&ARRAY::(2)ns⑶v[n-l]4.(1)returngd_name(2)staticint(3)returntotalweight四、理解问答题,写出前三小题的程序运行结果和指出后两小题的程序(或函数)所能实现的功能。(每小题6分，共30分)1.101-6〃2分40-3〃2分6-6-9〃2分2.xuxiaokai〃3分weirong〃3分3.56〃3分920〃3分4.实现字符串系统函数strcpy的功能，把b所指的字符串拷贝到a所指的字符数组空间中。5.函数模板,从ー维数组a[n]中查找值为key的元素,若查找成功则返回真否则返回假。第4、5小题评分标准:按叙述完整程度酌情给分。五、编程题(每小题5分,共10分)评分标准:按编程完整程度酌情给分。1.intf(inta[],intn)if(n==0)return0;elsereturna[n-l]*a[n-l]+f(a,n-l);

138)1.Array::Array(Array&aa){n=aa.n;a=newint[n];for(inti=0;i

139模拟试题(第四套)ー、单项选择题(每小题2分,共20分)1.A2.A3.C4.C5.D6.D7.A8.B9.C10.C二、填空题(每小题2分,共20分)评分标准:每小题若有两个空,则每空1分;若只有一个空,则每空2分。1.422.241923.804.int(*)[6]*(*(d+i)+j)5.int&ra=a;int*rb=&a;6.constconst7.NN8.拷贝构造函数赋值重载函数9.privatepublic10.优先级结合性三、程序填充题,对程序、函数或类中划有横线的位置,根据题意按标号把合适的内容填写到程序后面的标号处。(每小题5分,共20分)评分标准:对ー空给2分,对两空给4分,对三空给5分。1.(1)i<=5(2)j>=5+i(3)coutくぐ・，2.(1)a[i](或a[i]!=，、〇，)(2)a[i]!=c⑶‘、〇’3.(1)int&ARRAY::(2)n>=s(3)v[n](或・(v+n))4.(1)friendPointoperator+(Point&pt,intdd)(2)friendPointoperator+(Point&ptl,Point&pt2)(3)returntemp四、理解问答题,写出前三小题的程序运行结果和指出后两小题的程序(或函数)所能实现的功能。(每小题6分,共30分)评分标准:第4、5小题根据叙述完整程度酌情给分。1.s=632.4//3分27//3分3.d=800//3分f=40//3分4.让计算机随机产生出10道20以内整数的加法题供用户计算,每道题!0分,计算完成后打印出得分。5.根据参数s所指向的字符串,生成一个由r所指向的新字符串并返回,该字符串使s字符串中的小写字母均变为大写。五、编程题(每小题5分，共10分)评分标准：按编程完整程度酌情给分。1.voidfun(char*a,intb[])

140for(i=0;i<10;i++)b[i]=O;while(*a){intj=*a-Z〇"；if(j>=0&&j<=9)b[j]++;a++;})1.intAA::CompareBig(AA&b)(intk;if(n>b.n)k=b.n;elsek二n;for(inti=0;ib.a[i])return1;elseif(a[i]