C++面向对象程序设计教程课后习题答案(游洪跃)

C++面向对象程序设计教程第1章C++程序设计基础习题解答

编辑ppt一、选择题1．下列语句中，错误的是

。A）constintbuffer=256; B）constinttemp；C）constdouble*point; D）double*constpt=newdouble(5.5);解析：修饰符const声明的常量只能被读取，该常量必须在声明时进行初始化，并且它的值在程序中不能改变。选项B）没有初始化，错误。选项C）定义了一个指向constdouble的指针，其意义为指针point指向的变量不能通过指针point来改变，D）中表示指针pt是常量指针，已在声明时进行了初始化。答案：B编辑ppt2．关于函数重载，下列叙述中错误的是

。A）重载函数的函数名必须相同 B）重载函数必须在参数个数或类型上有所不同C）重载函数的返回值类型必须相同 D）重载函数的函数体可以有所不同解析：函数重载是用同一个函数名字在不同的参数类型或参数个数上做类似的操作方作，它们的实现方法可以不同。所以说，重载函数的函数名必须相同，函数体可以有所不同。函数重载必须在参数类型或参数个数上不一样，不能依靠返回值不一样来区分重载函数。答案：C编辑ppt3．有以下程序：voidFun(inti,intj){ cout<<i+j<<endl; //输出i+j}voidFun(inti){ cout<<i++<<endl; //输出i++}intmain() //主函数main(){ inta=1; //定义变量i Fun(a); //调用Fun() return0; //返回值0,返回操作系统}该程序执行后输出的结果是

。A）1 B）2 C）3 D）4解析：由于主函数中调用的Fun()函数只有一个参数，故执行的是voidFun(inti)的版本，执行“cout<<i++<<endl;”时，由于是后缀“++”，所以先输出i的值1，再使i加1。答案：A编辑ppt二、编程题1．编写一个C++程序，要求输出“欢迎学习C++语言!”。参考程序:#include<iostream> //编译预处理命令usingnamespacestd; //使用命名空间stdintmain() //主函数main(){ cout<<"欢迎学习C++语言!"<<endl; //用C++的方法输出一行

system("PAUSE"); //调用库函数system()，输出提示信息

return0; //返回值,返回操作系统}

编辑ppt*2．编一个程序，用一个函数实现求n个整型数据的最小值。函数原型如下：intMin(inta[],intn)参考程序:#include<iostream> //编译预处理命令usingnamespacestd; //使用命名空间stdintMin(inta[],intn) //求n个整型数据的最小值{ intm=a[0],i; //临时变量 for(i=1;i<n;i++) { //依次比较求最小值 if(a[i]<m) { //如果a[i]更小 m=a[i]; //a[i]为当前最小值 } }

returnm; //返回最小值}intmain() //主函数main(){ inta[]={1,2,3,4,5,6,7,8,9,-10},n=10; cout<<"最小值为"<<Min(a,n)<<endl; //输出最小值 system("PAUSE"); //调用库函数system()，输出提示信息 return0; //返回值,返回操作系统}编辑ppt3．求2个数或3个整数中的最大数，用两个同名函数实现，要求编写测试程序。参考程序:#include<iostream> //编译预处理命令usingnamespacestd; //使用命名空间stdintMax(intx,inty) //求x,y的最大值{ returnx>y?x:y; //返回x,y的最大值}intMax(intx,inty,intz) //求x,y,z的最大值{ intm=x>y?x:y; //x,y的最大值

m=m>z?m:z; //m,z的最大值

returnm; //返回x,y,z的最大值}intmain() //主函数main(){ cout<<"2,3的最大值为"<<Max(2,3)<<endl;

cout<<"1,6,8的最大值为"<<Max(1,6,8)<<endl;

system("PAUSE"); //调用库函数system()，输出提示信息

return0; //返回值,返回操作系统}编辑ppt4．用变量的引用作函数形参，实现交换两个整型变量，要求编写测试程序。参考程序:#include<iostream> //编译预处理命令usingnamespacestd; //使用命名空间stdvoidSwap(int&x,int&y) //交换x,y的值{ intt=x;x=y;y=t; //循环赋值交换x,y的值}intmain() //主函数main(){ intx=1,y=6; cout<<"交换前:"<<x<<","<<y<<endl; Swap(x,y); cout<<"交换后:"<<x<<","<<y<<endl; system("PAUSE"); //调用库函数system()，输出系统提示信息 return0; //返回值,返回操作系统}编辑ppt*5．编一个程序，用同一个函数名对n个数据进行从小到大排序，数据类型可以是整型、单精度实型、双精度实型，用重载函数实现。参考程序:#include<iostream> //编译预处理命令usingnamespacestd; //使用命名空间stdvoidSort(inta[],intn) //对a[0]...a[n-1]进行排序{ inttem,i,j; //定义变量 for(i=0;i<n-1;i++) for(j=i+1;j<n;j++) if(a[i]>a[j]) { //a[i]比a[j]更大 tem=a[i];a[i]=a[j];a[j]=tem; }}……编辑ppt*5．编一个程序，用同一个函数名对n个数据进行从小到大排序，数据类型可以是整型、单精度实型、双精度实型，用重载函数实现。参考程序:……voidSort(floata[],intn) //对a[0]...a[n-1]进行排序{ floattem; //临时变量 inti,j; //定义变量 for(i=0;i<n-1;i++) for(j=i+1;j<n;j++) if(a[i]>a[j]) { //a[i]比a[j]更大 tem=a[i];a[i]=a[j];a[j]=tem; }}……编辑ppt*5．编一个程序，用同一个函数名对n个数据进行从小到大排序，数据类型可以是整型、单精度实型、双精度实型，用重载函数实现。参考程序:……voidSort(doublea[],intn) //对a[0]...a[n-1]进行排序{ doubletem; //临时变量 inti,j; //定义变量 for(i=0;i<n-1;i++) for(j=i+1;j<n;j++) if(a[i]>a[j]) { //a[i]比a[j]更大 tem=a[i];a[i]=a[j];a[j]=tem; }}……编辑ppt*5．编一个程序，用同一个函数名对n个数据进行从小到大排序，数据类型可以是整型、单精度实型、双精度实型，用重载函数实现。参考程序:……intmain() //主函数main(){ inta[]={1,3,2,5,6,9,0,6}; //定义a floatb[]={1.6,3.3,2.8,5.6,6.8,9.6,0.6,6.8}; //定义b doublec[]={1.2,3.1,2.6,5.8,6.8,9.8,0.8,6.2};//定义c inti,n=8; //定义变量 Sort(a,n); //对a排序 cout<<"a:"; //输出提示 for(i=0;i<n;i++) cout<<a[i]<<""; //输出a[i] cout<<endl; //换行……编辑ppt*5．编一个程序，用同一个函数名对n个数据进行从小到大排序，数据类型可以是整型、单精度实型、双精度实型，用重载函数实现。参考程序:…… Sort(b,n); //对b排序 cout<<"b:"; //输出提示 for(i=0;i<n;i++) cout<<b[i]<<""; //输出b[i] cout<<endl; //换行 Sort(c,n); //对c排序 cout<<"c:"; //输出提示 for(i=0;i<n;i++) cout<<c[i]<<""; //输出c[i] cout<<endl; //换行 system("PAUSE"); //调用库函数system()，输出系统提示信息 return0; //返回值,返回操作系统}编辑pptC++面向对象程序设计教程第2章类和对象习题解答

编辑ppt一、选择题1．下列选项中，不属于面向对象程序设计特征的是

。A）继承性 B）多态性C）类比性 D）封装性解析：封装性、继承性和多态性是面向对象思想的3个主要特征。封装性指将数据和算法捆绑成一个整体，这个整体就是对象，描述对象的数据被封装在其内部。继承性是指一种事物保留了另一种事物的全部特征，并且具有自身的独有特征。多态性主要指当多个事物继承自一种事物时，同一操作在它们之间表现出不同的行为。答案：C编辑ppt2．在面向对象方法中，实现信息隐蔽是依靠

。A）对象的继承 B）对象的多态C）对象的封装 D）对象的分类解析：在面向对象方法中，封装性是指将数据和算法捆绑成一个整体，这个整体就是对象，描述对象的数据被封装在内部，只可以通过对象提供的算法来进行操作，从而实现信息隐蔽。答案：C编辑ppt3．下列关于类和对象的叙述中，错误的是

。A）一个类只能有一个对象 B）对象是类的具体实例C）类是某一类对象的抽象 D）类和对象的关系就像数据类型和变量的关系解析：在面向对象设计中，类是同一种对象的抽象，而不只是对一个对象的抽象，一个类具有多个对象。对象是类的具体实例。就像数据类型和变量的关系，一种数据类型可以定义多个变量，一个变量却只能是一种数据类型。答案：A编辑ppt4．有以下类声明：classMyClass{intnum;};则MyClass类的成员num是

。A）公有数据成员 B）公有成员函数 C）私有数据成员 D）私有成员函数解析：函数声明时，函数名后必须带“｛｝”，所以num是数据成员。在类中，当没有用访问权限标识符标识时，默认为私有权限。答案：C编辑ppt5．在下列函数原型中，可以作为类AA构造函数的是

。A）voidAA(int); B）intAA(); C）AA(int)const D）AA(int);解析：构造函数用于初始纶对象的数据成员，没有返回类型，而且由于常成员函数不能更新对象的数据成员，所以常成员函数也不可能作为构造函数。答案：D编辑ppt6．下列关于this指针的叙述中，正确的是

。A）任何与类相关的函数都有this指针 B）类的成员函数都有this指针C）类的友元函数都有this指针 D）类的非静态成员函数才有this指针解析：this指针只能在类的成员函数中使用，它指向该成员函数被调用的对象。但是有两种与类相关的函数都没有this指针，即静态成员函数和友元函数。答案：D编辑ppt7．有以下程序：classTest{private: staticintn; //静态成员public: Test(){n+=2;} //构造函数 ~Test(){n-=3;} //析构函数 staticintGetNum(){returnn;} //返回n};intTest::n=1; //初始化nintmain() //主函数main(){ Test*p=newTest; //定义指针p deletep; //释放p指向的动太对象 cout<<"n="<<Test::GetNum()<<endl;//输出n return0; //返回值0,返回操作系统}执行后的输出结果是

。A）n=0 B）n=1 C）n=2 D）n=3解析：静态数据成员初始化的值为1，执行“Test*p=newTest”将调用构造函数，执行“n+=2;”，n的值变为3，执行“deletep;”时将调用析构函数，执行“n-=3;”，n的值减3，变为0。答案：A编辑ppt8．有以下程序：classMyClass{private: intn; //数据成员public: MyClass(intk):n(k){} //构造函数 intGet(){returnn;} //返回n intGet()const{returnn+1;} //返回n+1};intmain() //主函数main(){ MyClassa(5); //定义对象a constMyClassb(6); //定义对象b cout<<a.Get()<<b.Get()<<endl; //输出信息

return0; //返回值0,返回操作系统}运行后的输出结果是

。A）55 B）57 C）75 D）77解析：const是一个判断重载的标志，a.Get调用“intGet(){returnn;}”，故得到5，而常对象b执行"b.Get”时，调用常成员函数“intGet()const{returnn+1;}”，故得到6+1=7。答案：B编辑ppt9．由于常对象不能被更新，因此

。A）通过常对象只能调用它的常成员函数 B）通过常对象只能调用静态成员函数C）常对象的成员都是常成员 D）通过常对象可以调用任何不改变对象值的成员函数解析：通过常对象只能调用类中的常成员函数，而不能调用类中的其他成员函数。答案：A编辑ppt10．下列情况中，不会调用复制构造函数的是

。A）用一个对象去初始化同一类的另一个新对象时B）将类的一个对象赋予该类的另一个对象时C）函数的形参是类的对象，调用函数进行形参和实参结合时D）函数的返回值是类的对象的引用，函数执行返回调用时解析：只要在程序的执行中，需要用一个对象来初始化另一个对象，都要调用复制构造函数，包括A、B、C三种情况。答案：D编辑ppt11．以下关键字不能用来声明类的访问权限的是

。A）public B）static C）protected D）private解析：类的访问权限有三种：公有、私有、保护，关键字分别是public，private，protected,。static用于静态成员的声明。答案：B编辑ppt12．有以下程序：classMyClass{public: MyClass(){cout<<"A";} //无参构造函数 MyClass(charc){cout<<c;} //带参构造函数 ~MyClass(){cout<<"B";} //析构函数};intmain() //主函数main(){ MyClassa,*p; //定义变量 p=newMyClass('X'); //分配动态空间 deletep; //释放动态空间 cout<<endl; //换行

return0; //返回值0,返回操作系统}执行这个程序，屏幕上将显示输出

。A）ABX B）ABXB C）ABXB D）AXBB解析：定义对象a时，调用一次构造函数“MyClass(){cout<<"A";}”，但定义对象指针p时不调用构造函数；使用new动态创建对象时，根据参数情况调用“MyClass(charc){cout<<c;}”，输出X；执行“deletep;”时，需要调用一次析构函数，输出B;最后主函数结束时，对象a调用一次析构函数，输出B。答案：D编辑ppt13．有以下程序：classTest{public: staticinta; //静态成员 voidInit(){a=1;} //初始化函数 Test(inta=6){Init();a++;} //构造函数};intTest::a=0; //初始化aTestobj; //定义全局对象intmain() //主函数main(){ cout<<obj.a<<endl; //输出a return0; //返回值0,返回操作系统}运行时输出的结果是

。A）0 B）1 C）2 D）3解析：首先初始化静态数据成员a为0，然后在定义全局对象obj时调用构造函数。这时有两个a，一个是“Test(inta=6){Init();a++;}”函数中的局部变量a，另一个是静态数据成员a，需要靠作用域来区分。在执行Init()时，由于离开了构造函数“Test(inta=6){Init();a++;}”的作用域，Init()里的a为静态数据成员，这时静态数据成员a赋值为1；之后回到构造函数执行a++，这个a为“Test(inta=6){Init();a++;}”中的a，值变为7，但当构造函数执行完毕后，该局部变量a随之消失，与对象无关。obj.a调用的是静态数据成员，结果为1。答案：B编辑ppt14．有以下程序：classTest{private: longx; //私有数据成员public: Test(longa):x(a){} //构造函数 friendlongFun(Tests); //友元};longFun(Tests){ if(s.x<=1)return1; //递归结束 elsereturns.x*Fun(Test(s.x-1)); //递归调用}intmain() //主函数main(){ intsum=0; //定义变量 for(inti=0;i<6;i++) sum+=Fun(Test(i)); //累加求和 cout<<sum<<endl; //输出sum

return0; //返回值0,返回操作系统}运行后的输出结果是

。A）120 B）16 C）154 D）34解析：友元函数Fun()参数表中的对象在初始化时需执行构造函数“Test::Test(longa)”，调用过程为：先调用构造函数Test(i)，使Test中x的值为i，再通过友元函数直接访问Test.x，执行Fun()中的语句，可得到：Fun(Test(0))=1，Fun(Test(1))=1，Fun(Test(2))=2*1，Fun(Test3)=3*2*1=6，Fun(Test(4))=4*3*2*1=24，Fun(Test(5))=5*4*3*2*1=120，sum=1+1+2+6+24+120=154。答案：C编辑ppt15．有以下程序：classTest{private: inta; //数据成员public: Test(){cout<<"无参构造函数"<<endl;} //无参构造函数 Test(inta){cout<<a<<endl;} //带参构造函数 Test(constTest©):a(copy.a) //复制构造函数 {cout<<"复制构造函数"<<endl;} ~Test(){cout<<"析构函数"<<endl;} //析构函数};intmain() //主函数main(){ Testa(3); //定义对象

return0; //返回值0,返回操作系统}运行时的输出结果是

。A）3 B）无参构造函数 C）复制构造函数 D）3 析构函数 析构函数 析构函数解析：创建对象a时带有参数3，故调用构造函数Test(inta)，输出3并换行；程序结束时调用析构函数~Test()，输出“析构函数”并换行。答案：D编辑ppt16．有以下程序：classMyClass{private: intn; //数据成员public: MyClass(intm):n(m){} //构造函数 voidPrint()const{cout<<"const:n="<<n<<"";} //常成员函数 voidPrint(){cout<<"n="<<n<<"";} //非常成员函数};intmain() //主函数main(){ constMyClassobj1(10); //常对象 MyClassobj2(20); //非常对象 obj1.Print(); //输出信息 obj2.Print(); //输出信息 cout<<endl; //换行

return0; //返回值0,返回操作系统}程序的输出结果是

。A）n=10const:n=20 B）const:n=10const:n=20C）const:n=10n=20 D）n=10n=20解析：根据const修饰符选择对应的构造函数，objl为常对象，调用常成员函数，输出“const:n=10”，obj2为一般对象，调用优先调用非常成员函数，输出“n=20”。答案：C编辑ppt二、填空题1．在面向对象方法中，

描述的是具有相同属性与操作的一组对象。解析：在面向对象设计中，一个对象是由一些属性和操作构成的。对象的属性描述了对象的内部细节。类是具有相同属性和操作的一组对象的集合，它为属于该类的所有对象提供统一的抽象描述。答案：类编辑ppt2．非成员函数应声明为类的

函数才能访问这个类的private成员。。解析：类具有数据封装和隐藏的特性，通常只有类的成员函数才能访问类的私有成员，外部函数只能访问类的公有成员。但在某些情况下，需要在类的外部访问类的私有成员，这时必须依靠引入友元来实现。答案：友元编辑ppt3．下列程序的输出结果为：01试将程序补充完整。classPoint{private: intx,y; //坐标 staticintcount; //静态数据成员public: Point(intm=0,intn=0):x(m),y(n){count++;}//构造函数 ~Point(){count--;} //析构函数 intGetX()const{returnx;} //返回x intGetY()const{returny;} //返回y staticvoidShowCount(){cout<<count<<endl;}//输出count};

//静态数据成员的初始化intmain() //主函数main(){ Point::ShowCount(); //输出count Pointa(6,8); //定义对象 Point::ShowCount(); //输出count system(“PAUSE”);//调用库函数system()，输出提示信息 return0; //返回值0,返回操作系统}。解析：由第一次调用GetCount()函数输出count的值为0可知，应将其初始化为0，再根据静态数据成员的初始化格式：类型类名::静态成员名字=值;可得横线处填写的语句。答案：intPoint::count=0;编辑ppt4．有以下类声明：classMyClass{ inti;private: intj;protected: intk;public: intm,n;};其中私有成员的数量是

。解析：在用class声明类的成员声明中，如果没有标识成员的访问权限，则默认为私有的访问权限，故i为私有访问权限。答案：2编辑ppt5．有以下程序：classInteger{private: intn; //数据成员public: Integer(intn=0){

=n;} //构造函数 voidShow()const{cout<<n<<endl;} //输出n};intmain() //主函数main(){ Integeri; //定义对象i i.Show(); //输出信息

system("PAUSE"); //调用库函数system()，输出系统提示 return0; //返回值0,返回操作系统}解析：在构造函数函数中，变量n是函数的形参，由于与Integer的数据成员同名，用函数参数n给Integer的数据成员n赋值时，需要this指针或作用域运算符进行区分。答案：this->n或

Integer::n编辑ppt6．有以下程序：classA{public: A(){cout<<"A";} //构造函数 ~A(){cout<<"~A";} //析构函数};intmain() //主函数main(){ A*p=newA; //定义指针 deletep; //释放动态空间 cout<<endl; //换行 system("PAUSE"); //调用库函数system()，输出系统提示 return0; //返回值0,返回操作系统}程序的输出结果是

。解析：创建动态对象时需调用A的构造函数，输出“A”；释放动态对象时，调用A的析构函数，输出“~A”。答案：A~A编辑ppt三、编程题1．定义一个满足如下要求的Date类。（1）用下面的格式输出日期：年-月-日（2）设置日期。并编出应用程序，定义日期对象，设置日期，输出该对象提供的日期。参考程序:#include<iostream> //编译预处理命令usingnamespacestd; //使用命名空间stdclassDate{private://数据成员

intyear; //年

intmonth; //月

intday; //日……编辑ppt1．定义一个满足如下要求的Date类。（1）用下面的格式输出日期：年-月-日（2）设置日期。并编出应用程序，定义日期对象，设置日期，输出该对象提供的日期。参考程序:……public://公有函数

Date(inty=2010,intm=1,intd=1): year(y),month(m),day(d){} //构造函数

voidSet(inty,intm,intd) //设置日期

{year=y;month=m;day=d;} voidShow()const //显示日期

{cout<<year<<"-"<<month<<"-"<<day<<endl;}};intmain() //主函数main(){ Dated; //定义对象

d.Show(); //显示日期

d.Set(2016,6,18); //设置日期

d.Show(); //显示日期

system("PAUSE"); //调用库函数system()，输出提示信息

return0; //返回值,返回操作系统}编辑ppt2．定义一个时间类Time，能提供和设置由时、分、秒组成的时间，并编出应用程序，定义时间对象，设置时间，输出该对象提供的时间。参考程序:#include<iostream> //编译预处理命令usingnamespacestd; //使用命名空间stdclassTime{private://数据成员

inthour; //时

intminute; //分

intsecond; //秒public://公有函数

Time(inth=0,intm=0,ints=0): //构造函数

hour(h),minute(m),second(s){}

voidSet(inth,intm,ints) //设置日期

{hour=h;minute=m;second=s;} voidShow()const //显示日期

{cout<<hour<<":"<<minute<<":"<<second<<endl;}};intmain() //主函数main(){ Timet; //定义对象

t.Show(); //显示时间

t.Set(8,6,18); //设置时间

t.Show(); //显示时间

system("PAUSE"); //调用库函数system()，输出提示信息

return0; //返回值,返回操作系统}编辑ppt*3．编写设计一个People（人）类。该类的数据成员有姓名(name)、年龄(age)、身高(height)、体重(weight)和人数(num)，其中人数为静态数据成员，成员函数有构造函数(People)、进食(Eatting)、运动(Sporting)、显示(Show)和显示人数(ShowNum)。其中构造函数由已知参数姓名(nm)、年龄(a)、身高(h)和体重(w)构造对象，进食函数使体重加1，运动函数使身高加1，显示函数用于显示人的姓名、年龄、身高、体重，显示人数函数为静态成员函数，用于显示人数。假设年龄的单位为岁，身高的单位为厘米，体重的单位为市斤，要求所有数据成员为private访问权限，所有成员函数为public访问权限，在主函数中定义若干个对象，通过对象直接访问类的所有非静态成员函数，通过类访问静态成员函数。参考程序:#include<iostream> //编译预处理命令usingnamespacestd; //使用命名空间stdclassPeople{private://数据成员 charname[9]; //姓名 intage; //年龄 intheight; //身高 doubleweight; //体重 staticintnum; //人数……编辑ppt……public://公有函数 People(charnm[]="无名氏",inta=16,inth=168,intw=118): age(a),height(h),weight(w){strcpy(name,nm);num++;} voidEatting(){weight++;} //进食 voidSporting(){height++;} //运动 voidShow() const //显示信息 { cout<<"个人信息:"<<endl; cout<<"姓名:"<<name<<endl; cout<<"年龄:"<<age<<"岁"<<endl; cout<<"身高:"<<height<<"厘米"<<endl; cout<<"体重:"<<weight<<"市斤"<<endl<<endl; } staticvoidShowNum() //显示人数 {cout<<"人数:"<<num<<endl;}};intPeople::num=0; //初始化静态数据成员num……编辑ppt……intmain() //主函数main(){ Peoplep1; //定义对象 p1.Show(); //显示信息

Peoplep2("李敏",18,170,108); //定义对象 p2.Eatting(); //进食 p2.Sporting(); //运动 p2.Show(); //显示信息

People::ShowNum(); //显示人数 system("PAUSE"); //调用库函数system()，输出提示信息 return0; //返回值,返回操作系统}编辑ppt*4．定义一个描述员工(Employee)基本情况的类，数据成员包括编号(num)、姓名(name)、性别(sex)、工资（wage）、人数(count)、总工资(totalWage)。其中姓名定义为长度为18的字符数组，性别为为长度为3的字符数组，其它数据成员类型为整型，总工资和人数为静态数据成员，函数成员包括构造函数、显示基本数据函数(ShowBase)和显示静态数据函数(ShowStatic)，其中构造函数由已知参数编号(nu)、姓名(nm)、性别(sx)和工资(wg)构造对象，显示基本数据函数用于显示学生的编号、姓名、性别和工资，显示静态数据函数为静态成员函数，用于显示人数和总工资；要求所有数据成员为protected访问权限，所有成员函数为public访问权限，在主函数中定义若干个员工对象，分别显示员工基本信息，以及显示员工人数和总工资。参考程序：#include<iostream> //编译预处理命令usingnamespacestd; //使用命名空间stdclassEmployee{protected://数据成员

intnum; //编号

charname[18]; //姓名

charsex[3]; //姓名

intwage; //工资

staticintcount; //人数

staticinttotalWage; //总工资……编辑ppt……public://公有函数

Employee(intnu,charnm[],charsx[],intwg):num(nu),wage(wg)

{strcpy(name,nm);strcpy(sex,sx);count++;totalWage+=wg;}; voidShowBase() //显示基本数据

{ cout<<"个人基本信息:"<<endl; cout<<"学号:"<<num<<endl; cout<<"姓名:"<<name<<endl; cout<<"性别:"<<sex<<endl; cout<<"工资:"<<wage<<"元"<<endl<<endl; } staticvoidShowStatic() //显示静态数据

{ cout<<"人数:"<<count<<endl; cout<<"总工资:"<<totalWage<<"元"<<endl; }};intEmployee::count=0; //初始化静态数据成员countintEmployee::totalWage=0; /初始化静态数据成员totalWage……编辑ppt……intmain() //主函数main(){ Employeee1(1008,"李杰","男",2680); //定义对象

e1.ShowBase(); //显示基本数据

Employeee2(1009,"李敏","女",2860); //定义对象

e2.ShowBase(); //显示基本数据

e2.ShowStatic(); //显示静态数据

system("PAUSE"); //调用库函数system()，输出系统提示信息

return0; //返回值,返回操作系统}编辑pptC++面向对象程序设计教程第3章模板习题解答编辑ppt一、选择题1．下列关于模板的叙述中，错误的是

。A）模板声明中的第一个符号总是关键字templateB）在模板声明中用“＜”和“＞”括起来的部分是模板的类型形参表C）类模板不能有数据成员D）在一定条件下函数模板的类型实参可以省略解析：由模板声明的格式可知选项A、B正确。在调用模板函数时，如果编译系统从模板函数的类型实参表中得到的信息已经能够判断部分或全部虚拟类型参数所对应的实际类型，而且它们又正好是模板形参中最后的若干个参数，则在模板类型实参表中可以省略这几个参数，选项D正确。类模板中可以有数据成员，数据成员的类型可以是虚拟类型，也可以是具体类型，选项C错误。答案：C编辑ppt2．有以下函数模板定义：template<classElemType>ElemTypeFun(constElemType&x,constElemType&y){returnx*x+y*y;}在下列对Fun()的调用中，错误的是

。A）Fun(3,5); B）Fun(3.0,5.5); C）Fun(3,5.5); D）Fun<int>(3,5.5);解析：当从模板函数类型实参表获得的信息有矛盾时，模板类型实参不能省略。例如选项C中，编译系统从第一个参数3获得的信息是ElemType对应于int，而从第二个参数5.5处获得的信息是ElemType对应于double，两者相互矛盾，因此，编译时将产生错误。解决的方法之一是显式给出虚拟类型参数ElemType对应的模板类型实参，强制ElemType对应于int。答案：C编辑ppt3．关于关键字class和typename，下列表述中正确的是

。A）程序中typename都可以替换为classB）程序中的class都可以替换为typenameC）在模板类型形参表中只能用typename来声明参数的类型D）在模板类型形参表中只能用class或typename来声明参数的类型解析：程序中的typename都可以替换为class，但程序中的class不可以全部替换为typename。例如：在“模板类型形参表”中，关键字typename和class是可以互换的；但是在“类模板名”前的关键字class代表的含义是类，不可以用typename代替，选项B错误。在模板类型形参表中除了typename和class以外也可以用常规类型来声明参数的类型，选项C、D错误。答案：A编辑ppt4．有以下函数模板：template<classElemType>ElemTypeSquare(constElemType&x){returnx*x;}其中ElemType是

。A）函数形参 B）函数实参 C）模板类型形参 D）模板类型实参解析：由函数模板的定义可知ElemType为模板类型形参。答案：C编辑ppt5．C++中的模板包括

。A）对象模板和函数模板 B）对象模板和类模板C）函数模板和类模板 D）变量模板和对象模板解析：C++语言通过模板提供了一种将类型参数化的机制，其中包括函数模板和类模板。答案：C编辑ppt二、填空题1．已知一个函数模板的声明如下：template<typenameT1,typenameT2>T1Fun(T2n){returnn*5.0;}若要求以int型数7为函数实参调用该模板函数，并返回一个double型数，则该调用应表示为

。解析：当虚拟类型类型参数作为函数的返回值类型，而函数的返回值类型与函数参数的类型可以不同时，不管函数类型实参的类型是什么，均不能省略模板类型实参，此题的模板类型实参应为<double,int>。答案：Fun<double,int>(7)编辑ppt2．已知intdbl(intn){returnn+n;}和longdbl(longn){returnn+n;}是一个函数模板的两个实例，则该函数模板的声明是template<typenameElemType>

解析：将类型int和long参数化，用模板类型参数ElemType代替，可得该函数模板。答案：ElemTypeDbl(ElemTypen){returnn+n;}编辑ppt3．下面程序的运行结果是

。template<classElemType>ElemTypeMin(constElemType&a,constElemType&b)//求a,b的最小值{ if(a<b)returna; //a更小

elsereturnb; //b更小}intmain() //主函数main(){ intn1=4,n2=5; //定义整型变量

doubled1=0.35,d2=4.4; //定义实型变量

cout<<"最小整数="<<Min(n1,n2)<<"," <<"最小实型="<<Min(d1,d2)<<endl; //输出信息

system("PAUSE"); //调用库函数system()，输出系统提示 return0; //返回值0,返回操作系统}

解析：模板函数Min()根据调用它的实参类型的不同，生成不同的函数版本，例如，返回两个int型数的最小值或返回两个double型数的最小值。答案：最小整数=4,最小实型=0.35编辑ppt三、编程题1．试使用函数模板实现输出一个数组各元素的值，要求编写测试程序。参考程序:#include<iostream> //编译预处理命令usingnamespacestd; //使用命名空间stdtemplate<classElemType>voidDisplay(ElemTypea[],intn) //输出数组a各元素之值{ for(inti=0;i<n;i++) cout<<a[i]<<""; //输出a[i] cout<<endl; //换行}intmain() //主函数main(){ inta[]={1,2,3,4,5,6,7,8,9}; //定义数组

Display(a,9); //输出a system("PAUSE"); //调用库函数system()，输出系统信息

return0; //返回值,返回操作系统}编辑ppt2．编写一个复数类模板Complex，其数据成员real和image的类型未知，定义相应的成员函数，包括构造函数、输出复数值的函数、求复数和的函数和求复数差的函数，主函数中定义模板类对象，分别以int和double实例化类型参数。参考程序:#include<iostream> //编译预处理命令usingnamespacestd; //使用命名空间std//声明复数类模板template<classElemType>classComplex{private://数据成员 ElemTypereal; //实部 ElemTypeimage; //虚部public://公有函数 Complex(ElemTyper=0,ElemTypei=0):real(r),image(i){} voidShow()const; //输出复数 staticComplexAdd(constComplex&z1,constComplex&z2); staticComplexSub(constComplex&z1,constComplex&z2);};……编辑ppt……template<classElemType>voidComplex<ElemType>::Show()const //输出复数{ if(image<0)cout<<real<<image<<"i"<<endl;//虚部为负,例如-5i elseif(image==0)cout<<real<<endl; //虚部为0,例如3 elsecout<<real<<“+”<<image<<“i”<<endl;//虚部为正,例如+5i}template<classElemType>Complex<ElemType>Complex<ElemType>::Add(constComplex&z1, constComplex&z2) //复数加法{ Complexz(z1.real+z2.real,z1.image+z2.image);//定义复数对象 returnz; //返回复数}template<classElemType>Complex<ElemType>Complex<ElemType>::Sub(constComplex&z1, constComplex&z2) //复数减法{ Complexz(z1.real-z2.real,z1.image-z2.image);//定义复数对象 returnz; //返回复数}……编辑ppt……intmain() //主函数main(){ Complex<int>z1(2,3),z2(6,-5),z3; //定义复数对象 z1.Show(); //输出z1 z2.Show(); //输出z2 z3=Complex<int>::Add(z1,z2); //z3=z1+z2 z3.Show(); //输出z3 z3=Complex<int>::Sub(z1,z2); //z3=z1-z2 z3.Show(); //输出z3 Complex<double>z4(2.1,3.8),z5(6.8,-5.1),z6;//定义复数对象 z4.Show(); //输出z4 z5.Show(); //输出z5 z6=Complex<double>::Add(z4,z5); //z6=z4+z5 z6.Show(); //输出z3 z6=Complex<double>::Sub(z4,z5); //z6=z4-z5 z6.Show(); //输出z6 system("PAUSE"); //调用库函数system()，输出系统提示信息 return0; //返回值,返回操作系统}编辑ppt*3．编写一个使用数组类模板Array对数组求最大值和求元素和的程序，要求编写出测试程序。参考程序：#include<iostream> //编译预处理命令usingnamespacestd; //使用命名空间std//声明数组类模板template<classElemType>classArray{private://数据成员

ElemType*elem; //存储数据元素值

intsize; //数组元素个数public://公有函数

Array(intsz):size(sz){elem=newElemType[size];} //构造函数

~Array(){deleteelem;} //析构函数

voidSetElem(ElemTypee,inti); //设置元素值

ElemTypeGetElem(inti)const; //求元素值

ElemTypeMax()const; //求最大值

ElemTypeSum()const; //求元素之和};……编辑ppt……template<classElemType>voidArray<ElemType>::SetElem(ElemTypee,inti) //设置元素值{ if(i<0||i>=size) { cout<<"元素位置错!"<<endl; exit(1); //退出程序的运行,返回到操作系统

} elem[i]=e; //设置元素值为e} template<classElemType>ElemTypeArray<ElemType>::GetElem(inti)const //求元素值{ if(i<0||i>=size) { cout<<"元素位置错!"<<endl; exit(2); //退出程序的运行,返回到操作系统

} returnelem[i]; //返回元素值elem[i]} ……编辑ppt……template<classElemType>ElemTypeArray<ElemType>::Max()const //求最大值{ ElemTypem=elem[0]; //设elem[0]最大

for(inti=1;i<size;i++) if(elem[i]>m)m=elem[i]; //依次比较求最大值

returnm; //返回最大值}template<classElemType>ElemTypeArray<ElemType>::Sum()const //求元素之和{ ElemTypes=0; //定义变量

for(inti=1;i<size;i++) s=s+elem[i]; //依次求和

returns; //返回和}……编辑ppt……intmain() //主函数main(){ inta[]={1,9,7,5,6,3}; //定义数组a intn=6; //数组元素个数

Array<int>obj(n); //定义数组对象

inti; //定义变量

for(i=0;i<n;i++) obj.SetElem(a[i],i); //设置数组元素值

for(i=0;i<n;i++) cout<<obj.GetElem(i)<<""; //输出元素值

cout<<endl; //换行

cout<<"最大值为:"<<obj.Max()<<endl; //输出最大值

cout<<"各元素和为:"<<obj.Sum()<<endl; //输出各元素之和

system("PAUSE"); //调用库函数system()，输出系统提示信息

return0; //返回值,返回操作系统}编辑ppt*4．对数组求最大值和求元素和的算法都编写为函数模板，要求编写出测试程序。参考程序：#include<iostream> //编译预处理命令usingnamespacestd; //使用命名空间stdtemplate<classElemType>ElemTypeMax(ElemTypea[],intn) //求最大值{ ElemTypem=a[0]; //设a[0]最大

for(inti=1;i<n;i++) if(a[i]>m)m=a[i]; //依次比较求最大值

returnm; //返回最大值}template<classElemType>ElemTypeSum(ElemTypea[],intn) //求元素之和{ ElemTypes=0; //定义变量

for(inti=1;i<n;i++) s=s+a[i]; //依次求和

returns; //返回和}……编辑ppt*4．对数组求最大值和求元素和的算法都编写为函数模板，要求编写出测试程序。参考程序：……intmain() //主函数main(){ inta[]={1,9,7,5,6,3}; //定义数组a intn=6; //数组元素个数

for(inti=0;i<n;i++) cout<<a[i]<<""; //输出元素值

cout<<endl; //换行

cout<<"最大值为:"<<Max(a,n)<<endl; //输出最大值

cout<<"各元素和为:"<<Sum(a,n)<<endl; //输出各元素之和

system("PAUSE"); //调用库函数system()，输出系统提示信息

return0; //返回值,返回操作系统}编辑ppt**5．对数组求最大值和求元素和的函数采用静态成员函数的方式封装成数组算法类模板ArrayAlg，要求编写出测试程序。参考程序：#include<iostream> //编译预处理命令usingnamespacestd; //使用命名空间std//声明数组类模板template<classElemType>classArrayAlg{public://公有函数 staticElemTypeMax(ElemTypea[],intn) //求最大值 { ElemTypem=a[0]; //设a[0]最大 for(inti=1;i<n;i++) if(a[i]>m)m=a[i]; //依次比较求最大值 returnm; //返回最大值 } staticElemTypeSum(ElemTypea[],intn) //求元素之和 { ElemTypes=0; //定义变量 for(inti=1;i<n;i++) s=s+a[i]; //依次求和 returns; //返回和 }};……编辑ppt**5．对数组求最大值和求元素和的函数采用静态成员函数的方式封装成数组算法类模板ArrayAlg，要求编写出测试程序。参考程序：……intmain() //主函数main(){ inta[]={1,9,7,5,6,3}; //定义数组a intn=6; //数组元素个数 for(inti=0;i<n;i++) cout<<a[i]<<""; //输出元素值 cout<<endl; //换行 cout<<"最大值为:"<<ArrayAlg<int>::Max(a,n)<<endl; cout<<"各元素和为:"<<ArrayAlg<int>::Sum(a,n)<<endl; system("PAUSE"); //调用库函数system()，输出系统提示信息 return0; //返回值,返回操作系统}编辑pptC++面向对象程序设计教程第4章运算符重载习题解答

编辑ppt一、选择题1．通过运算符重载，可以改变运算符原有的

。A）操作数类型 B）操作数个数 C）优先级 D）结合性解析：通过运算符重载可以改变运算符原有的操作数类型，但是不能改变运算符操作数的个数以及优先级和结合性。答案：A编辑ppt2．运算符重载是对已有的运算符赋予多重含义，因此

。A）可以对基本类型（如int类型）的数据，重新定义“+”运算符的含义B）可以改变一个已有运算符的优先级和操作数个数C）只能重载C++中已经有的运算符，不能定义新运算符D）C++中已经有的所有运算符都可以重载解析：重载运算符的函数的参数不能全部是C++的标准类型，例如，不能改变运算符“+”作用于两个int型数的含义，即运算符函数的参数中至少存在一个用户自定义对象，故选项A错误。运算符重载不能改变运