还剩20页未读,继续阅读
本资源只提供10页预览,全部文档请下载后查看!喜欢就下载吧,查找使用更方便
文本内容:
1.面向对象程序设计中的数据隐藏指的是参考答案为:D A.输入数据必须输入保密口令B.数据经过加密处理 C.对象内部数据结构上建有防火墙 D.对象内部数据结构的不可访问性[解析]输入数据必须输入保密口令和数据经过加密处理都不是面向对象程序设计的特征;对象内部数据结构上也不可能建有防火墙,所以它们都不是面向对象程序设计中所指的数据隐藏面向对象程序设计系统中的封装单位是对象,对象之间只能通过接口进行信息交流,外部不能对对象中的数据随意地进行访问,这就造成了对象内部数据结构的不可访问性,也使得数据被隐藏在对象中这就是面向对象程序设计中的数据隐藏所指2.下列各项中不符合函数重载必须满足的条件的是参考答案为:D A.必须有不同的参数个数 B.对应的参数类型必须不相同 C.A和B必须同时满足 D.A和B只要满足一个即可[解析]我们知道,在同一个作用域中,要实现函数重载必须满足的条件的是
①有不同的参数个数;或者
②对应的参数有不相同的数据类型,即
①和
②中只要有一个满足就可以了当然两者都满足更好,但这不是必须的3.下列带缺省值参数的函数说明中,正确的说明是 参考答案为:A A.intFunintxinty=2intz=3; B.intFunintx=1intyintz=3;C.intFunintxinty=2intz; D.intFunintx=1intyintz=3; [解析]在带缺省值参数的函数说明中,正确的说明应该是无缺省值的参数依次排列在参数表的左边,排完无缺省值的参数后,再依次排列带缺省值的参数从所给出的四个选项来看,只有“intFunintxinty=2intz=3”符合这条规定,其它的都不符合4.有如下的对类“CSample”的说明,其中()是错误的 classCSample{ 参考答案为:A A.inta=23; B.CSample; public: C.CSampleintval; D.~CSample; };[解析]在上面对类“CSample”说明中,“CSample”和“CSampleintval”是该类重载的构造函数、“~CSample”是该类的析构函数,这三个语句都是正确的错误的语句是“inta=23”,因为它违反了在类的声明(不管是引用性声明,还是定义性声明)中都不能以赋值表达式的形式给它的数据成员进行初始化5.已知类A中的一个成员函数的说明如下 voidSetAa; 则该函数的参数“Aa”的含义是 参考答案为:C A.指向A的指针为a B.将变量a的地址赋给类A C.类A对象引用a用作函数的形参 D.变量A与a按位与后作函数参数[解析]因为A是一个类,所以“Aa”表示a是类A的对象,但因为对象a的前缀了符号“”,则“a”表示是类A的对象引用所以“Aa”的含义是类A对象引用a用作函数的形参6.若类A和类B的定义如下 classA{ public: intij; voidget; }; classB:privateA{ intij; protected: intk; public: voidmake; }; voidB::make{k=i*j;} 则其中()是非法的表达式 参考答案为:D A.voidget; B.intk; C.voidmake; D.k=i*j; [解析]对于给定的四项中,前三项都是正确的,只有第四项是错误的因为,类B是类A的私有派生类(缺省访问类型),所以A中的公类型的数据成员在类B中成为了私有数据成员,但函数“voidB::make”既然是类B的成员函数,则既可访问类A中的公有数据成员,也能访问类B中的私有数据成员,则表达式“k=i*j;”造成了访问的二义性,即其中的i和j,到底是取自类A呢?还是取自类B呢?7.下面的主程序中,语句()是错误的 classA{ inti; public: virtualvoidfun=0; Ainta{i=a;} }; classB{ intj; public: voidfun{cout”B::fun\n”;} Bintbintc:Ab{j=c;} }; voidmain 参考答案为:A A.{Aa5; B.A*pa; C.Bb7; D.B*pb; } [解析]在类A中,函数“virtualvoidfun=0”为纯虚函数,因此,类A为抽象类作为抽象类,它是不能被用来定义具体对象的,而语句“Aa5;”恰恰是定义抽象类的对象的,所以它是错误的8.拷贝(复制)构造函数的作用是 参考答案为:C A.进行数据类型的转换 B.用对象调用成员函数 C.用对象初始化对象 D.用一般类型的数据初始化对象 [解析]进行数据类型的转换和用一般类型的数据初始化对象都是一般构造函数的功能用对象调用成员函数不用构造函数,只要用“对象名.成员函数名”即可所以拷贝(复制)构造函数的作用,只能是用对象来初始化对象9.下列说法中,正确的说法是 参考答案为:B A.所有的运算符都能被重载 B.运算符被重载时,它们的优先级与结合性不会改变 C.当需要时,我们可以自定义一个运算符来进行重载 D.每个运算符都可以被重载成成员函数和友元函数 [解析]当重载运算符时,不是所有的运算符都能被重载,有几个运算符是不能被重载的,如三元运算符“?”、‘.’、‘*’、‘’、‘#’等;也不是每个运算符都可以被重载成成员函数和友元函数,如运算符‘=’、‘()’、‘[]’、和‘→’都只能被重载成成员函数;无论何时,都不能自定义运算符来进行重载,也即重载只能对已有运算符进行;但是运算符被重载时,它们的优先级与结合性不会改变10.下面对结构或类中成员的访问中,不正确的访问是 参考答案为:A A.*pointer.salary;(其中pointer为指向类对象的指针) B.pointer-salary; C.x=worker.salary;(其中worker为具有类类型的对象) D.LocationrA=A1;intx=rA.GetX;(Location为已定义的类,A为对象)[解析]因pointer为指向类对象的指针,所以“pointer-salary”是正确的访问数据成员的形式;因worker为具有类类型的对象,所以“worker.salary”也是正确的访问数据成员的形式;因Location为已定义的类,A1为对象,所以“LocationrA=A1;intx=rA.GetX;”表示以对象A1初始化对象引用rA,然后由对象引用rA调用成员函数GetX给变量x赋值,这样的访问成员函数的形式也是正确的;“*pointer.salary;”中,因为运算符‘.’的优先级高于运算符‘*’的优先级,所以相当于“*(pointer.salary);”,那正确的形式应该是“*(pointer→salary);”故“*pointer.salary”是不正确的访问11.C++对C语言作了很多改进,即从面向过程变成为面向对象的主要原因是DA.增加了一些新的运算符B.允许函数重载,并允许设置缺省参数C.规定函数说明符必须用原型D.引进了类和对象的概念12.下列符号不能组成标识符的是AA.连接符B.下划线C.大小写字母D.数字字符13.类型修饰符unsigned不能修饰DA.charB.intC.longintD.float14.在inta=3int*p=a;中,*p的值是DA.变量a的地址值B.无意义C.变量p的地址值D.315.下列关于指针的操作中,错误的是DA.两个同类型的指针可以进行比较运算B.可以用一个空指针赋给某个指针C.一个指针可以加上两个整数之差D.两个同类型的指针可以相加二,填空题 不写解答过程,将正确的答案写在每小题的空格内错填或不填均无分1.面向对象程序设计中的多态性包括静态多态性和动态多态性,前者由____________机制支持,而后者则由____________机制支持答函数重载、虚函数[解析]静态多态性又称编译时多态性,调用何函数应该在编译之前就知道了,所以必须由函数重载机制来支持动态多态性又称运行时多态性,调用何函数只有在运行时才知道,所以由虚函数(与指针或引用)机制来支持2.由charconst*str=”stucture”;所以定义的指针称为____________,关键字const所修饰的是____________答指向常量的指针、指针所指的字符串[解析]根据由‘*’在修饰符“const”中位置的不同,它所修饰的对象也不同,“const”表示所修饰的是指针所指的常量,该指针称为指向常量的指针;“*const”表示所修饰的是指针本身,该指针称为常指针;“*const”则表示所修饰的是指针本身和指针所指常量,该指针称为指向常量的常指针3.引入虚基类的目的是为了解决多重继承中的____________和____________问题答二义性、多占用空间[解析]在允许多重继承时可能出现两个问题,第一个是公有派生类中的成员通过不同基类调用它们上一级公共基类的同一成员,这就产生了调用的二义性;每一个基类都为它们的上一级公共基类存有备份,这就引起了公共基类的重复存储,也就多占了存储空间引入虚基类的目的是为了解决多重继承中的这两个问题4.构造函数与析构函数所调用的虚函数是____________的函数,因此调用时实现的是____________联编答所在类、静态[解析]在生成派生类的对象时,先调用基类的构造函数生成基类对象,再调用派生类的构造函数来生成派生类对象所以当在构造函数中调用虚函数时,当调用基类的构造函数时,此时派生类还未生成,所以它只能调用自己的虚函数;调用派生类构造函数时,它也只能调用自己的虚函数,因为虚函数的调用是不能由派生类调用基类的在析构派生类对象是时,先调用派生类的析构函数析构掉派生类对象,再调用基类的析构函数来析够掉基类的对象所以当在析够构函数中调用虚函数时,派生类的析构函数调用的是它自己的虚函数(原因同构造函数),基类的析构函数调用的也是它自己的虚函数,因为此时派生类对象以已被析构掉了由上可见,当构造函数与析够函数调用虚函数时,它们调用的都是自己类的函数,因此调用时实现的是静态联编7.说明一个const成员函数(又称常量成员函数)的方法是,将const写在__________之间,而且它修饰的是__________答函数头与函数体、this指针[解析]为了说明一个常量成员函数的方法是,将const写在函数头的右圆括号‘)’与函数体的左花括号‘{’之间,而且它修饰的是对象所属的this指针表示该函数不能修改它所在对象中的数据成员的值20.对某个运算符的重载,实际上是用关键字____________与该运算符组成一个运算符函数,而且该运算符函数的返回类型不能是____________的答operater、void[解析]对某个运算符的重载,实际上是用关键字operater与该运算符组成一个运算符函数,而且该运算符函数的返回类型不能是无类型的,即不能是void的三改错题1.分析下列程序中的错误,并说明出错原因 #include classbase{ constintn; public: base{cout”Initializingdefault\n”;} baseintm{cout”Initializing\n”;n=m;} ~base{cout”Destroying\n”;} }; voidmain {basex1; basey=x; }答
(1)n=m;const数据成员不以该形式赋值
(2)错误处basey=x;,以对象初始化对象[解析]
(1)作为const数据成员n不能用赋值表达式的形式为其赋初值,必须在定义构造函数时在函数头中以“baseintm nm”形式来初始化
(2)basey=x;语句中‘=’不是赋值的意思,而是初始化的意思即在定义类base的对象y时,以对象x给它初始化,相当于basey(x);但是以对象初始化对象时,必须调用拷贝构造函数才行因程序中没给出拷贝构造函数,也不能调用系统的缺省拷贝构造函数,因用户给出了构造函数后,再也不能调用系统提供的任何缺省构造函数所以,basey=x;是错误的2.分析下列程序中的错误,并说明出错原因 #include classA{ intx; public: Ainta{x=a;fun;} virtualvoidfun=0; }; classB:publicA{ public: Bintb:Ab{} voidfun{} }; voidmain {Aaa5; Bbb8; }答1)Aaa5;抽象类不能定义对象[解析]
(1)在构造函数“Ainta”调用了纯虚函数“fun”,因构造函数调用虚函数是静态联编,即调用的是它自己类的虚函数在此调用的是纯虚函数,它只被说明,而未定义,所以不可能被执行,因此出错
(2)抽象类相当于是对类的引用性声明,所以它只能定义该类的指针和引用,而不能定义它的对象在此,A为抽象类,而“Aaa5”却定义了A的对象,因此是错误的3.分析下列程序中的错误,并说明出错原因 #include classAA{ intaa; AAintxx{aa=xx;} public: intget{returnaa;} ~AA{cout”Destroying”AAendl; }; main {AAelem5; coutelem.getendl; }答
(1)AAintxx的访问属性错、应具有公有属性[解析]
(1)构造函数虽是由系统自动调用来生成对象的,但一般都是在类外调用,所以它的访问属性必须是公有的程序中构造函数的访问属性是私有的(缺省值),运行中必定出错四.完成程序题 根据题目要求,完成程序填空1.仔细阅读下列求两个点之间距离的程序,根据程序的输出结果在划线处填入正确语句 classpoint{ floatxy; public: pointfloatafloatb{x=a;y=b;} floatdistancepointp{ floatdx=_____
①______; floatdy=_____
②______; returnfloatsqrtdx*dx+dy*dy; } }; voidmain {pointp123p23243; coutp
1.___
③___endl; } 答
①p.x-x
②p.y-y
③distancep2 [解析]由于求两点之间距离的函数“distance”为成员函数,所以由该函数的this指针所指对象可用作起点(参数之一),另一个用作终点的参数,必须在函数的参数表中显式地给出dx和dy分别计算两个结点间x和y坐标间的距离,因此应该为dx=p.x–x和dy=p.y–y对它们求平方相加后开方即可,得到两点间的距离floatsrrtda*da+dy*dy在主程序中求p1和p2两个结点之间的距离,由于由p1调用距离函数,所以由p2作为它的参数,即distancep22.两个复数只有当它们的实部和虚部分别相等时,才被认为它们相等在空格处填入合适的内容,以完成下面的程序,使其重载运算符“==”,用以比较两个复数的相等请在主函数中输出比较的结果 #include classcomplex{ doublerealimag; public: complexdoublerdoublei{real=r;imag=i;} booloperator==complex; }; intcomplex::operator==complexcom {return_____
①_____} voidmain {complexc
112.
332.5c
221.
718.6; if______
②______ returncout”true\n”; else returncout”false\n”; } 答
①real==com.realimag==com.imag
②c1==c2或c
1.operator==c2 [解析]若两个复数的相等,则必有它们的实数部分和虚数部分都相等,所以运算符重载函数中返回“real==com.realimag==com.imag”,只有real==com.real与imag==com.imag都为真时,该函数的返回值才为真在主程序中,为了比较两个复数c1和c2,可以隐式地写成“c1==c2”,也可显式写成“c
1.operator==c2”3.下列程序中声明了两个类AA和BB,其中函数“print”是类AA的成员函数,但是类BB的友元函数请在
①、
②和
③处各填入正确的内容,使程序能正常运行 #include _____
①______; classAA{ intt; public: AAintx{t=x;} voidprintBBb; }; classBB{ ints; public: BBinty{s=y;} friendvoid___
②___printBB; }; void____
③_____ {cout”AA”T”;BB”W.Sendl;} voidmain {AAm6; BBn8; m.printn; } 答
①classBB;
②AA::
③AA::printBBw [解析]由于AA类的成员函数“print”是类BB的友元函数,因此它必须有一个BB类的引用作为参数,以便有引用BB类数据成员的接口但此时BB类还未定义,为解决此矛盾,在
①处先对BB类作引用性声明“classBB;”,告诉系统BB类在后面定义因为函数“print”是类AA的成员函数,在类外定义必须加上类名和作用域分辨符,即在
②处加上“AA::”在BB类外定义“print”时,因是友元,所以没有加上“BB”的必要,但“AA”还是必须加的,所以在
③处填“AA::printBBw”五.程序分析题1.请分析以下的程序,给出该程序的正确执行结果 #include intaddintxinty{returnx+y;} voidmain {intm=2n=3; cout”1”addm++m+nendl; m=2n=3; cout”2”add++mm+nendl; m=2n=3; cout”3”endl; m=2n=3; cout”4”endl; } 答17 28 38 49[解析]在说明答案之前,要说明两个问题1)C++语言中,函数参数是压在栈里的,因压栈是从前往后进行的,所以出栈就是从后向前进行的,也即先取最后的参数,然后再向前逐个取用;2)对于单加运算,m++是先执行后加1,++m是加1后再执行 由此,因m=2n=3;,所以1(m++)+(m+n)=2+(2+3)=7(m++后执行,且后加1,所以m=2一直未变)2(++m)+(m+n)=3+(2+3)=8(++m后执行,但先加1,执行++m时,m=3了)3(m+n)+(m++)=(3+3)+2=8(先执行m++,后加1,执行m+n时,m=3了)4(m+n)+(++m)=(3+3)+3=9;(先执行++m,且先加1,故一开始就有m=3)3.请分析下面的程序并给出该程序的执行结果 #include classAA{ inta; public: AA{cout”InitualizingAA!\n”;} ~AA{cout”DestroyingAA!\n”; }; classBB{ intb; AAp; public: BB{cout”InitualizingBB!\n”;} ~BB{cout”DestroyingBB!\n”; }; voidmain {BBX; cout”Endingmain!\n”; }答InitualizingAA! InitualizingBB! Endingmain! DestroyingBB! DestroyingAA![解析]虽然在主程序中只定义了一个类BB的对象,但在类BB中声明了类AA的对象作为它的数据成员当一个类中含有对象作为数据成员时,在生成对象时,先调用成员对象的构造函数,再调用类自己的构造函数,所以输出了“InitualizingAA!”(成员对象构造函数的输出)和“InitualizingBB!”(类自己构造函数的输出)对象生成后,执行下一句输出语句,则输出“Endingmain!”此时程序结束,调用析构函数来析构掉对象,先调用类自身的析构函数,其输出为“DestroyingBB!”,再调用成员对象的析构函数,其输出为“DestroyingAA!”4.写出下列程序的运行结果 #include classAA{ public: staticintn; AA{n++;} }; intAA::n=0; main {cout”AA::n=”AA::nendl; AAd1; coutd
1.nendl; AAd2; coutd
2.nendl; AAd3d4; coutd
1.nendl; coutd
2.nendl; } 答AA::n=0 d
1.n=1 d
2.n=2 d
1.n=4 d
2.n=4 [解析]由于数据成员n的访问属性是公有的,所以在类外可访问它;又它是静态变量,所以具有全局性在构造函数中,执行的是n++操作,即每次调用构造函数n就加1当程序开始时,因未定义对象,所以n的值为初始化时的值,则输出为“AA::n=0”当定义了对象d1后,由于调用了构造函数,则该对象中n=1,故输出“d
1.n=1”同理,对象d2输出“d
2.n=2”由于接下来生成了两个对象d3和d4,调用两次构造函数,n两次加1,此时n=4,所以下面两条语句的输出为“d
1.n=4”和“d
2.n=4”5.写出下列程序的输出结果 #include classAA{ public: AA{}{cout”ConstructorofAA.\n”;fun;} virtualvoidfun{cout”AA::funcalled.\n”;} }; classBB:publicAA{ public: BB{cout”ConstructorofBB.\n”;fun;} voidfun{cout”BB::funcalled.\n”;} }; voidmain {BBd;}答ConstructorofAA. AA::funcalled. ConstructorofBB. BB::funcalled.[解析]虽然函数fun说明为虚函数,但当在构造函数中被调用时,呈现的是静态联编,即基类和派生类都调用各自的函数fun所以,当生成对象d时,先调用基类的构造函数,在构造函数中又调用自己的函数“fun”,所以输出为“ConstructorofAA.”和“AA::funcalled.”同理调用派生类的构造函数时,生成的输出为“ConstructorofBB.”和“BB::funcalled.”6.请给出下面的程序的输出结果 #include templateclassT voidsortT*aintn {Tnum; forinti=0;in-1;i++ {forintj=i;jn-1;j++ ifa[j]a[j+1] {num=a[j];a[j]=a[j+1];a[j+1]=num;} } fori=0;in;i++ couta[i]endl; } voidmain {intiver
[5]={124592337}; doubledver
[5]={
22.
356.
743.
513.
88.6}; sortiver5; sortdver.5; } 答912233745
8.
613.
822.
343.
556.7[解析]这是使用模板的例子函数sort是一个递增的排序函数,T是个模板当数组是整型数据类型时,它为整型数组排序;当数组为双精度数据类型时,它为双精度数组排序所以输出如上结果7.分析以下程序的执行结果#includeiostream.hvoidmain{inta;intb=a;//变量引用b=10;couta=aendl;}解本题说明变量引用的方法b是a的引用,它们分配相同的空间,b的值即为a的值所以输出为a=108.分析以下程序的执行结果#includeiostream.hclassSample{intx;public:Sample{};Sampleinta{x=a;}SampleSamplea{x=a.x+1;}voiddisp{coutx=xendl;}};voidmain{Samples12s2s1;s
2.disp;}解本题说明类拷贝构造函数的使用方法Sample类的SampleSamplea构造函数是一个拷贝构造函数,将a对象的x值赋给当前对象的x后加1所以输出为x=39.分析以下程序的执行结果#includeiostream.hclassSample{public:intx;inty;voiddisp{coutx=xy=yendl;}};voidmain{intSample::*pc;Samples*p=s;pc=Sample::x;p-*pc=10;pc=Sample::y;p-*pc=20;p-disp;}解本题说明了类数据成员指针的使用方法这里通过指向对象的指针来给类数据成员赋值,其原理与上题相似输出为x=10y=2010.分析以下程序的执行结果#includeiostream.hclassSample{intx;inty;public:Sampleintaintb{x=a;y=b;}intgetx{returnx;}intgety{returny;}};voidmain{intSample::*fp;fp=Sample::getx;Samples27;intv=s.*fp;fp=Sample::gety;intt=s.*fp;coutv=vt=tendl;}解本题说明了类成员函数指针的使用方法在main中定义的fp是一个指向Sample类成员函数的指针执行fp=Sample::getx后fp指向成员函数getxintv=s.*fp语句等价于intv.getxv=x=2;执行fp=Sample::gety之后,fp指向成员函数getyintt=s.*fp语句等价于intt=s.getyt=x=7所以输出为v=2t=711.分析以下程序的执行结果#includeiostream.hclassSample{intx;inty;public:Sampleintaintb{x=a;y=b;}intgetx{returnx;}intgety{returny;}};voidmain{intSample::*fp;fp=Sample::getx;Samples27*p=s;intv=p-*fp;fp=Sample::gety;intt=p-*fp;coutv=vt=tendl;}解本题说明了类成员函数指针的使用方法这里通过指向对象的指针来调用指向类成员函数的指针,其原理与上题相似输出仍为v=2t=712.分析以下程序的执行结果#includeiostream.hclassbase{public:base{coutconstructingbaseclassendl;}~base{coutdestructingbaseclassendl;}};classsubs:publicbase{public:subs{coutconstructingsubclassendl;}~subs{coutdestructingsubclassendl;}};voidmain{subss;}解本题说明单继承情况下构造函数和析构函数的调用顺序这里base为基类,subs为派生类所以输出为constructingbaseclassconstructingsubclassdestructingsubclassdestrcutingbaseclass注意在单继承情况下,首先调用基类的构造函数,随后调用派生类的构造函数,析构函数的调用顺序则正好相反13.分析以下程序的执行结果#includeiostream.hclassbase{intn;public:baseinta{coutconstructingbaseclassendl;n=a;coutn=nendl;}~base{coutdestructingbaseclassendl;}};classsubs:publicbase{basebobj;intm;public:subsintaintbintc:baseabobjc{coutconstructingsubcassendl;m=b;coutm=mendl;}~subs{coutdestructingsubclassendl;}};voidmain{subss123;}解本题说明派生类中含有对象成员情况下构造函数和析构函数的调用顺序这里base为基类subs为派生类,subs类的构造函数中含有对象成员所以输出为constrcutingbaseclassn=1constructingbaseclassn=3constructingsubclassm=2destructingsubclassdestructingbaseclassdestructingbaseclass注意当派生类中含有对象成员时,构造函数的调用顺序如下基类的构造函数2对象成员的构造函数3派生类的构造函数析构函数的调用顺序与之相反14.分析以下程序的执行结果#includeiostream.hclassA{public:intn;};classB:publicA{};classC:publicA{};classD:publicBpublicC{intgetn{returnB::n;}};voidmain{Dd;d.B::n=10;d.C::n=20;coutd.B::nd.C::nendl;}解D类是从类和类派生的而类和类又都是从类派生的,但各有自己的副本所以对于对象d,d.B::n与d.C::n是两个不同的数据成员它们互无联系所以输出为10,2015.分析以下程序的执行结果#includeiostream.hclassA{public:intn;};classB:virtualpublicA{};classC:virtualpublicA{};classD:publicBpublicC{intgetn{returnB::n;}};voidmain{Dd;d.B::n=10;d.C::n=20;coutd.B::nd.C::nendl;}解D类是从类和类派生的而类和类又都是从类派生,但这是虚继承关系即是虚基类因此和共用一个的副本所以对于对象d,d.B::n与d.C::n是一个成员所以输出为20,2016.分析以下程序执行结果#includeiostream.hintaddintxinty{returnx+y;}doubleadddoublexdoubley{returnx+y;}voidmain{inta=4b=6;doublec=
2.6d=
7.4;coutaddabaddcdendl;}解本题说明函数重载的使用方法,这里有两个add函数,一个add函数的参数与返回值为int型,另一个的参数与返回值为double型,它们是根据参数类型自动区分的所以输出为10,1017.分析以下程序的执行结果#includeiostream.hclassSample{inti;doubled;public:voidsetdataintn{i=n;}voidsetdatadoublex{d=x;}voiddisp{couti=id=dendl;}};voidmain{Samples;s.setdata10;s.setdata
15.6;s.disp;}解本题说明重载成员函数的使用方法setdata成员函数有两个,根据其参数类型加以区分所以输出为i=10d=
15.622.分析以下程序的执行结果#includeiostream.hclassSample{intn;public:Sample{}Sampleinti{n=i;}Sampleoperator=Sample;voiddisp{coutn=nendl;}};SampleSample::operator=Samples{Sample::n=s.n;return*this;}voidmain{Samples110s2;s2=s1;s
2.disp;}解本题说明重载运算符=的使用方法operator=成员函数实现两个对象的赋值所以输出为n=10六.程序设计题1.设计一个三角形类Triangle,包含三角形三条边长的私有数据成员,另有一个重载运算符“+”,以实现求两个三角形对象的面积之和解在Triangle类中设计一个友元函数operator+Trianglet1Trianglet2,它重载运算符+,返回t1和t2两个三角形的面积之和本题程序如下#includeiostream.h#includemath.hclassTriangle{intxyz;doublearea;public:Triangleintiintjintk{doubles;x=i;y=j;z=k;s=x+y+z/
2.0;area=sqrts*s-x*s-y*s-z;}voiddisparea{coutArea=areaendl;}frienddoubleoperator+Trianglet1Trianglet2{returnt
1.area+t
2.area;}};voidmain{Trianglet1345t2456;doubles;coutt1:;t
1.disparea;coutt2:;t
2.disparea;s=t1+t2;cout总面积=sendl;}本程序执行结果如下t1:Area=6t2:Area=
9.92157总面积=
15.92162.重载运算符“+”友元函数只能返回两个三角形的面积之和,不能计算三个三角形的面积之和,改进一下,使之能计算任意多个三角形的面积之和解重载运算符为什么不能计算3个三角形的面积之和呢?对于式子:s=t1+t2+t3,先计算t1+t2,返回一个double数然后再进行该double数+t3的计算,显然没有这样的重载运算符“+”友元函数,只需要添加这样重载运算符“+”友元函数即可本题程序如下#includeiostream.h#includemath.hclassTriangle{intxyz;doublearea;public:Triangleintiintjintk{doubles;x=i;y=j;z=k;s=x+y+z/
2.0;area=sqrts*s-x*s-y*s-z;}voiddisparea{coutArea=areaendl;}frienddoubleoperator+Trianglet1Trianglet2{returnt
1.area+t
2.area;}frienddoubleoperator+doubledTrianglet{returnd+t.area;}};voidmain{Trianglet1345t2456t3567t4678;doubles;coutt1:;t
1.disparea;coutt2:;t
2.disparea;coutt3:;t
3.disparea;coutt4:;t
4.disparea;s=t1+t2+t3+t4;cout总面积=sendl;}本程序的执行结果如下t1:Area=6t2:Area=
9.92157t3:Area=
14.6969t4:Area=
20.3332总面积=
50.95173.设计一个学生类student包括姓名和三门课程成绩,利用重载运算符”+“将所有学生的成绩相加放在一个对象中,再对该对象求各门课程的平均分解#includeiostream.h#includeiomanip.h#includestring.hclassstudent{charname
[10];intdeg1deg2deg3;public:student{}studentcharna[]intd1intd2intd3{strcpynamena;deg1=d1;deg2=d2;deg3=d3;}friendstudentoperator+students1students2{staticstudentst;st.deg1=s
1.deg1+s
2.deg1;st.deg2=s
1.deg2+s
2.deg2;st.deg3=s
1.deg3+s
2.deg3;returnst;}voiddisp{coutsetw10namesetw5deg1setw5deg2setw5deg3endl;}friendvoidavgstudentsintn{coutsetw10平均分setw5s.deg1/nsetw5s.deg2/nsetw5s.deg3/nendl;}};voidmain{students1Li778285s2Zheng756289;students3Ma898795s4Xu557965s;out输出结果endl;s
1.disp;s
2.disp;s=s1+s2;avgs2;s
3.disp;s
4.disp;s=s3+s4;avgs2;}运行结果输出结果li778285zheng756289平均分767287Ma898795Xu557965平均分7283804.计算e的值e是自然对数的底,它和π一样是数学中最常用的无理数常量其近似值的计算公式为e=1+1/1!+1/2!+1/3!+...+1/n-1!+r当n充分大时,这个公式可以计算任意精度e的近似值为了保证误差rε,只需1/n-1!rε程序代码如下//program2_
4.cpp#includeiostream.hvoidmain{constdoubleeps=
0.1e-10;intn=1;floate=
1.0r=
1.0;do//开始do循环循环条件由后面的while中的表达式值确定{e+=r;n++;r/=n;}whilereps;coutTheapproximateValueofnaturallogarithmbaseis:;couteendl;}5.16.设计一个立方体类Box,它能计算并输出立方体的体积和表面积解Box类包含三个私有数据成员a立方体边长、volume体积和area表面积,另有两个构造函数以及seta设置立方体边长、getvolume计算体积、getarea计算表面积和disp输出结果本题程序如下#includeiostream.hclassBox{floata;floatvolume;floatarea;public:Box{}Boxfloatr{a=r;}voidsetafloatr{a=r;}voidgetvolume{volume=a*a*a;}voidgetarea{area=6*a*a;}voiddisp{cout体积volume表面积areaendl;}};voidmain{Boxobj
14.5obj2;obj
2.seta
6.4;obj
1.getvolume;obj
1.getarea;coutobj1=;obj
1.disp;obj
2.getvolume;obj
2.getarea;coutobj2=;obj
2.disp;}本程序的执行结果如下obj1=体积
91.125表面积
121.5obj2=体积
262.144表面积
245.76。