C++面向对象程序设计》doc.docx
《C++面向对象程序设计》doc.docx》由会员分享，可在线阅读，更多相关《C++面向对象程序设计》doc.docx（37页珍藏版）》请在冰豆网上搜索。
C++面向对象程序设计》doc
第2章C++的初步知识
【2.3】【解】B【2.4】【解】C【2.5】【解】C【2.6】【解】C【2.7】【解】C
【2.8】【解】A【2.9】【解】B
【2.10】【解】D【2.11】【解】D【2.12】解】C【2.13】【解】D
说明:
“int*p=newint（5）;”表示动态分配1个整型内存空间,初值为5;
“int*p=newint[5];”表示动态分配5个整型内存空间;
“int*p=newint;”表示动态分配1个整型内存空间;
“int*p=newint[5]（0）”想给一个数组分配内存空间时,对数组进行初始化,这是不允许的。
【2.14】
【解】D
说明:
name被定义为指向常量的常指针,这个指针变量所指的地址不能改变,它所指向的地址中的数据也不能改变。
“name[3]=′a′;”修改了name所指向的地址中的数据,“name="lin";”和“name=newchar[5];”修改了name所指的地址,只有D输出一个字符是正确的。
【2.15】
【解】A
说明:
name被定义常指针,它所指向的地址中的数据能改变,但它所指的地址不能改变。
“name[3]=′q′;”修改了name所指向的地址中的数据,是正确的。
而“name="lin";”、“name=newchar[5];”和“name=newchar（′q′）;”以不同的方法修改了name所指的地址,都是错误的。
【2.16】
【解】A
说明:
name被定义指向常量的指针,它所指向的地址中的数据不能改变,但它所指的地址可以修改,而“name[3]='q';”修改了name所指向的地址中的数据,是错误的。
“name=="lin";”、“name=newchar[5];”和“name=newchar（′q′）”以不同的方法修改了name所指的地址,都是正确的。
【2.17】
【解】C
【2.18】
【解】D
说明:
C++中不能建立引用数组和指向引用的指针,也不能建立引用的引用。
所以A、B、C是错误的,D是正确的。
【2.19】
【解】A
【2.20】
【解】B
【2.21】
【解】
（1）这两个函数原型是等价的,因为函数原型中的参数名可以缺省。
（2）这两个函数的第一行是不等价的,函数的第一行中必须包含参数名。
【2.23】
【解】本程序的运行结果如下:
x+y=65
【2.24】
【解】本程序的运行结果如下:
101
说明:
在语句“:
:
i=i+1;”中赋值号左边“:
:
i”的中i是全局变量,赋值号右边的i是局部变量。
所以执行该语句的结果是将局部变量i的值加1（即101）后赋值给全局变量i。
【2.25】
【解】本程序的运行结果如下:
1010
说明:
函数f（&m,n）中第1个参数是引用参数,引用参数是一种按地址传递参数的方法,对其的调用是传地址调用;而第2个参数是变量参数,对它的调用是传值调用。
所以调用函数f后,实参a的值被改为10,实参b的值不变,仍为10。
【2.26】
【解】本程序的运行结果如下:
10
20
说明:
函数f的参数是变量的引用,对它的调用是传地址调用,所以函数f调用后,主函数中k的值变为10。
又由于m是对函数f的引用,当m被赋值为20时,k的值也变为20。
【2.27】
【解】程序的作用是：
输入3个整数，然后输出其中值最大的数。
在主函数中输入3个整数，然后调用f函数，在f函数中实现找最小的整数，用if语句比较两个数，将大者存放在变量m中，经过两个if语句的比较，m中存放的是3个整数中最大的数。
运行情况如下：
247↙（输入3个整数）
7（输出其中最大的数）
【2.28】
【解】实现本题功能的程序如下:
#include
#include
usingnamespacestd;
intmain（）
{
floatx,y;
cout<<"pleaseinput2floatstox,y：
";
cin>>x>>y;
floatz=pow（x,y）;
cout<<"pow（"<return0;
}
本程序的运行结果是:
pleaseinput2floatstox,y：
2.13↙
pow（2.1,3）=9.261
说明:
由于要用到系统函数pow（x，y），所以要包含头文件cmath。
【2.29】
【解】实现本题功能的程序如下:
#include
usingnamespacestd;
intmain（）
{int*p=newint[20];//动态分配20个整型内存空间
*p=1;
*（p+1）=1;//对前面2个内存空间赋值1
cout<<*p<<"\t"<<*（p+1）<<"\t";
p=p+2;//p指向第3个内存空间
for（inti=3;i<=20;i++）
{*p=*（p-1）+*（p-2）;
cout<<*p<<"\t";
if（i%5==0）cout<p++;//p指向下一个内存空间;
}
return0;
}
本程序的运行结果是:
11235
813213455
89144233377610
9871597258441816765
【2.30】
【解】实现本题功能的程序如下:
#include
#include
usingnamespacestd;
doublesroot（inti）
{returnsqrt（i）;
}
doublesroot（longl）
{returnsqrt（l）;
}
doublesroot（doubled）
{returnsqrt（d）;
}
intmain（）
{inti=12;
longl=1234;
doubled=12.34;
cout<<"i的二次方根是：
"<cout<<"l的二次方根是：
"<cout<<"d的二次方根是：
"<return0;
}
本程序的运行结果是:
i的二次方根是：
3.4641
l的二次方根是：
35.1283
d的二次方根是：
3.51283
第3章类和对象
3.1习题参考解答
【3.1】
【解】
类声明的一般格式如下:
class类名{
public:
公有数据成员;
公有成员函数;
private:
私有数据成员;
私有成员函数;
};
类的声明由关键字class打头,后跟类名,花括号中是类体,最后以一个分号“;”结束。
【3.2】【解】C【3.3】【解】B【3.4】【解】B【3.5】【解】D【3.6】【解】B
说明:
C++中对构造函数有一些规定:
不能带返回值;可以不带参数;也可以缺省定义;但构造函数的名字与类名必须完全相同。
【3.7】【解】B【3.8】【解】C【3.9】【解】C【3.10】【解】B【3.11】【解】C
说明:
C++中对析构函数也有一些规定:
没有参数;不能重载;析造函数的名字与是在类名前加“~”;析构函数不能指定返回类型。
【3.12】【解】C【3.13】【解】C【3.14】【解】B【3.15】【解】D【3.16】【解】
语句
（1）使用带默认参数的构造函数,或不带参数的构造函数,定义了point类的两个对象p2和p3;
语句
（2）在建立新对象p2时,用已经存在的对象P1去初始化新对象p2,在这个过程中用“赋值法”调用了拷贝构造函数。
语句（3）在建立新对象p2时,用已经存在的对象P1去初始化新对象p2,在这个过程中用“代入法”调用了拷贝构造函数。
语句（4）将对象p1数据成员的值拷贝到对象p4中,这个过程是通过默认赋值运算符函数实现的。
【3.17】
【解】本程序的运行结果如下:
Exitmain
dst55
【3.18】
【解】本程序的运行结果如下:
Countingat0
Countingat1
Countingat2
Countingat3
Countingat4
Countingat5
Couhtingat6
Countingat7
Countingat8
Countingat9
说明:
在本程序中主函数main只包括了一个return语句,但竟然有内容输出！
什么时候调用了构造函数？
我们知道,构造函数在对象被定义时调用。
那么对象anObject是何时被调用的呢？
在主函数main之前,语句“testanObject”处。
【3.19】
【解】本程序的运行结果如下:
Con.
Copycon.
default.
【3.20】
【解】
第1个错误:
printStu（）和setSno两个成员函数没有用public定义,不允许外部函数对对象进行操作。
第2个错误:
成员函数在类外定义,应加上类名“Student:
:
”。
第3个错误:
setAge应在类中说明,并且在类外定义时,应加上类名“Student:
:
”。
【3.21】
【解】
构造函数Point是私有的,语句“Pointcpoint;”执行时出现错误。
【3.22】
【解】实现本题功能的程序如下:
#include
usingnamespacestd;
classCircle{
public:
Circle（floatr）{radius=r;}
floatarea（）{return3.14*radius*radius;}
private:
floatradius;
};
intmain（）
{floatr;
cout<<"请输入圆的半径:
";
cin>>r;
Circlep（r）;
cout<<"半径为"<"<return0;
}
程序的运行结果是:
请输入圆的半径:
3
半径为3的圆的面积为:
28.26
【3.23】
【解】实现本题功能的程序如下:
#include
usingnamespacestd;
classcylinder{
public:
cylinder（doublea,doubleb）;
voidvol（）;
private:
doubler,h;
doublevolume;
};
cylinder:
:
cylinder（doublea,doubleb）
{r=a;h=b;
volume=3.141592*r*r*h;
}
voidcylinder:
:
vol（）
{cout<<"volumeis:
"<}
intmain（）
{cylinderx（2.2,8.09）;
x.vol（）;
return0;
}
程序的运行结果是:
volumeis:
123.011
【3.24】
【解】实现本题功能的程序如下:
#include
usingnamespacestd;
classDate{
public:
Date（）{}
Date（inty,intm,intd）
{year=y;
mon=m;
day=d;
}
Date（Date&d）
{year=d.year;
mon=d.mon;
day=d.day;
}
voidSetDate（intY,intm,intd）
{year=Y;
mon=m;
day=d;
}
voidprintDate（）
{cout<<"日期是:
"<}
intGetYear（）
{returnyear;
}
intGetMonth（）
{returnmon;
}
intGetDay（）
{returnday;
}
private:
intday,mon,year;
};
voidmain（）
{Dated1（2010,6,8）;
cout<<"日期是:
"<<<"月"<Dated2;
d2.SetDate（2010,8,1）;
d2.printDate（）;
Dated3（d1）;
d3.printDate（）;
}
程序的运行结果是:
日期是:
2010年6月8日
日期是:
2010年8月1日
日期是:
2010年6月8日
第4章类和对象的进一步讨论
4.1习题参考解答
【4.1】
【解】
所谓对象数组是指每一数组元素都是对象的数组,也就是说,若一个类有若干个对象,我们把这一系列的对象用一个数组来存放。
对象数组的元素是对象,不仅具有数据成员,而且还有函数成员。
【4.2】
【解】对象指针就是用于存放对象地址的变量。
声明对象指针的一般语法形式为:
类名*对象指针名;
【4.3】【解】B【4.4】【解】C【4.5】【解】B
说明:
C++中规定,在建立对象前就可以为静态数据成员赋值。
同时规定在静态成员函数中不能使用this指针;静态成员函数在类外定义时,不需要用static前缀;静态成员函数既可以在类内定义也可以在类外定义。
【4.6】【解】D【4.7】【解】C【4.8】【解】D【4.9】【解】A【4.10】【解】A
说明:
由于友元函数可以直接访问对象的私有成员,所以友元的作用是提高程序运行的效率。
【4.11】【解】A【4.12】【解】B【4.13】【解】B
如果一个对象说明为常对象,则通过该对象只能调用它的常成员函数。
题中,对象a被定义成类Sample的常对象,所以通过对象a只能调用其常成员函数disp。
所以程序最后输出disp2。
【4.17】
【解】实现本题功能的程序如下:
#include
usingnamespacestd;
classStudent{
public:
Student（intn,floats）:
num（n）,score（s）
{}
voiddisplay（）;
private:
intnum;
floatscore;
};
voidStudent:
:
display（）
{cout<<"学号:
"<"<intmain（）
{Studentstu[6]={
Student（1001,88.5）,Student（1002,75.5）,Student（1003,68.5）,
Student（1004,99.0）,Student（1005,93.5）,Student（1006,86.0）
};
Student*p=stu;
p=p+1;
for（inti=1;i<=3;p=p+2,i++）
p->display（）;
return0;
}
本程序的运行结果如下：
学号:
1002成绩:
75.5
学号:
1004成绩:
99
学号:
1006成绩:
86
【4.18】
【解】实现本题功能的程序如下:
#include
usingnamespacestd;
classStudent{
public:
Student（intn,floats）:
num（n）,score（s）
{}
intnum;
floatscore;
};
intmain（）
{Studentstu[6]={
Student（1001,88.5）,Student（1002,75.5）,Student（1003,68.5）,
Student（1004,99.0）,Student（1005,93.5）,Student（1006,86.0）
};
voidmax（Student*）;
Student*p=&stu[0];
max（p）;
return0;
}
voidmax（Student*arr）
{floatmax_score=arr[0].score;
intk=0;
for（inti=1;i<6;i++）
if（arr[i].score>max_score）
{max_score=arr[i].score;k=i;
}
cout<<"学号:
"<"<}
本程序的运行结果如下：
学号:
1004成绩:
99
【4.19】
【解】实现本题功能的程序如下:
#include
usingnamespacestd;
classbook{
public:
book（inta,intb）
{qu=a;
price=b;
}
voidshow_money（）
{cout<private:
intqu,price;
};
intmain（）
{bookob[5]={
book（1,10）,book（2,20）,
book（3,30）,book（4,40）,book（5,50）
};
inti;
for（i=0;i<5;i++）ob[i].show_money（）;
return0;
}
本程序的运行结果如下：
10
40
90
160
250
【4.21】
【解】实现本题功能的程序如下:
#include
#include
usingnamespacestd;
classStudent{
public:
Student（intn,stringna,doubled）
{no=n;
deg=d;
name=na;
sum+=d;
num++;
}
staticdoubleavg（）
{returnsum/num;
}
staticinttotal（）
{returnnum;
}
voiddisp（）
{cout<}
private:
intno;//学号
stringname;//姓名
doubledeg;//成绩
staticdoublesum;//总成绩
staticintnum;//学生人数
};
doubleStudent:
:
sum=0;
intStudent:
:
num=0;
intmain（）
{Students1（1001,"Zhou",97）,s2（1002,"Zhan",65）,s3（1003,"Chen",88）;
cout<<"学号姓名成绩\n";
s1.disp（）;
s2.disp（）;
s3.disp（）;
cout<<"学生人数="<:
total（）<cout<<"平均成绩="<:
avg（）;
return0;
}
本程序的运行结果如下:
学号姓名成绩
1001Zhou97
1002Zhan65
1003Chen88
学生人数=3
平均成绩=83.3333
第5章继承与派生
5.1习题参考解答
【5.1】
【解】
派生类可以继承基类中除了构造函数与析构函数之外的成员,但是这些成员的访问属性在派生过程中是可以调整的。
从基类继承来的成员在派生类中的访问属性是由继承方式控制的。
类的继承方式有public（公有继承）、protected（保护继承）和private（私有继承）3种,不同的继承方式导致不同访问属性的基类成员在派生类中的访问属性也有所不同。
在派生类中,从基类继承来的成员可以按访问属性划分为4种:
不可直接访问、公有（public）、保护（protected）和私有（private）。
表5.1列出了基类成员在派生类中的访问属性。
表5.1基类成员在派生类中的访问属性
基类中的成员
继承方式
基类成员在派生类中的访问属性
私有成员（private）
公有继承（public）
不可直接访问
私有成员（private）
私有继承（private）
不可直接访问
私有成员（private）
保护继承（protected）
不可直接访问
公有成员（public）
公有继承（public）
公有（public）
公有成员（public）
私有继承（private）
私有（private）
公有成员（public）
保护继承（protected）
保护（protected）
保护成员（protected）
公有继承（public）
保护（protected）
保护成员（protected）
私有继承（private）
私有（private）
保护成员（protected）
保护继承（protected）
保护（protected）
【5.2】
【解】
派生类不能直接访问基类的私有成员,但是可以通过基类提供的公有成员函数间接地访问基类的私有成员。
【5.3】
【解】
当类的继承方式为公有继承时,基类中的所有保护成员在派生类中仍以保护成员的身份出现,在派生类内可以访问这些成员,但派生类外部不能访问它们,而在下一层派生类内可以访问它们。
当类的继承方式为私有继承时,基类中的所有保护成员在派生类中都以私有成员的身份出现,在派生类内可以访问这些成员,但派生类外部不能访问它们。
【5.4】
【解】
通常情况下,当创建派生类对象时,首先调用基类的构造函数,随后再调用派生类的构造函数;当撤销派生类对象时,则先调用派生类的析构函数,随后再调用基类的析构函数。
【5.5】
【解】
当一个派生类具有多个基类时,这种派生方法称为多继承。
多重继承的构造函数的执行顺序与单继承构造函数的执行顺序相同,也是遵循先调用基类的构造函数,再调用对象成员的构造函数,最后调用派生类构造函数体的原则。
处于同一层次的各个基类构造函数的调用顺序,取决于声明派生类时所指定的各个基类的顺序,与派生类构造函数中所定义的成员初始化列表的各项顺序没有关系。
析构函数的调用顺序则刚好与构造函数的执行顺序相反。
【5.6】
【解】B
说明:
通过派生类的使用,可以通过增加少量代码的方法得到新的的类,从而解决
升级会员 