面向对象作业

以下题目中一、三题为下周四上机实验内容，第三题同时是下周日前需网上提交的作业；
二、四题即为再下一周（即第九周）上机内容，同时也是再下一周日前网上需提交的作业。

一。定义一个包含两个纯虚函数的抽象类shape:
class shape
{
public:
virtual float Area()=0;
virtual void SetData(float,float=0)=0;
};
成员函数SetData用于设置几何图形的属性值。成员函数Area()用于求出几何图形的面积。由shape派生出四种几何图形，分别是：三角形、矩形、正方形和圆形。
例如三角形类的定义如下：
class triangle:public shape
{
float w,h;
public:
triangle(float ww=0,float hh=0){w=ww;h=hh;}
float Area(){return w*h/2;}
void SetData(float ww,float hh=0){w=ww;h=hh;}
};
其它图形的派生类请自行编写。派生类的类名和属性如下：
1）类名 triangle 属性：三角形的一边长w和此边上的高h
2）类名 rectangle 属性：矩形的长w和宽h
3）类名 square 属性：正方形边长s
4）类名 circle 属性：圆的半径r
要求利用虚函数实现多态，编写一个求几何图形面积的普通函数CaclArea(shape *),其参数为抽象类shape的指针
在主函数中定义四种几何图形的对象，调用CaclArea()求四种几何图形对象的面积之和。


二。设计一个抽象类Vehicle，含有的数据属性为：油箱容量、100公里平均耗油量以及满油量的行使距离。从它派生出Car和Truck类。
派生的类包含下面的成员函数：1）获取用户车辆数据（油箱容量和平均耗油量）函数
2）计算并且返回车辆的满油量行驶距离的函数
3）计算并且返回行驶给定距离车辆所需要的加油次数。这些函数均为Vehicle类中的纯虚函数，并且由派生类重新定义。
设计main()函数来定义一个Vehicle类型的指针，一个Car和一个Truck对象。指针用来调用合适的成员函数来获取和处理小轿车和卡车的数据。
程序应该输出每种车辆行使用户输入的距离需要加油次数，以及每辆车满油量的行驶距离。


三。复数类运算符示例程序：
#include
using namespace std;
class Complex{
double Real,Image ;
public :
Complex(double r=0.0, double i=0.0):Real(r),Image(i){}
Complex(Complex &com)
{
Real=com.Real ; Image=com.Image ;
}
void Print()
{cout<<"Real="<<<"Image="<}
Complex operator+(Complex); //重载+运算符函数
Complex operator+(double); //重载+运算符函数
Complex operator=(Complex); //重载=运算符函数
Complex operator+=(Complex); //重载+=运算符函数
double abs(void); //求绝对值函数
Complex operator*(Comple

x); //重载*运算符函数
Complex operator/(Complex); }; //重载/运算符函数
Complex Complex::operator+(Complex c)
{//重载+
Complex Temp(Real+c.Real , Image+c.Image) ;
return Temp ;
}
Complex Complex::operator+(double d)
{ //重载+
return Complex(Real+d , Image);
}
Complex Complex::operator+=(Complex c)
{//重载+ =
Complex temp; //为了返回Complex类型的值，使+=可以连续使用
temp.Real=Real+c.Real; temp.Image=Image+c.Image;
Real=temp.Real; Image=temp.Image;
return temp;
}
Complex Complex::operator=(Complex c)
{//重载=
Complex temp; //定义temp为可返回Complex类型值，使=可连续使用
temp.Real=c.Real; temp.Image=c.Image;
Real=temp.Real; Image=temp.Image;
return temp;
}
double Complex::abs(void)
{//求绝对值函数
return sqrt(Real*Real+Image*Image);
}
Complex Complex::operator*(Complex c)
{//重载*
return Complex(Real*c.Real-Image*c.Image ,Real*c.Image+c.Real*Image);
}

Complex Complex::operator/(Complex c)
{ //重载/
double d=c.Real*c.Real+c.Image*c.Image ;
return Complex((Real*c.Real+Image*c.Image)/d , (Image*c.Real-Real*c.Image)/d) ;
}
int main(void)
{
Complex c1(1.0,1.0) , c2(2.0,2.0) , c3(4.0,4.0) , c;
double d=0.5 ;
c1.Print();
c=c2+c3 ; c.Print() ;
c+=c1 ; c.Print() ;
c=c+d ; c.Print() ; //可用0.5代替d
c=c3*c2 ; c.Print() ;
c=c3/c1 ; c.Print() ;
cout<<"c3的模为："<c=c3=c2=c1; c.Print(); //连续赋值
c+=c3+=c2+=c1; c.Print(); //连续加赋值
return 0;
}

完成：
1）、如何实现一个整数和一个复数的加法运算（即如:c2=d+c1,其中c1,c2是复数对象，d是一个整数变量）
提示：编写友元函数 friend Complex operator+(int x,Complex &ob);
2）、对示例程序中能够用友元函数实现的运算符，编写友元函数来替换相应的运算符成员函数。
3）、增加重载前置--运算符函数及重载后置--运算符函数，分别用成员函数和友元函数来实现，并测试之。
4）、增加重载的运算符"-"、"-="、"*="、"/="，分别用成员函数和友元函数各做一遍，并测试之。


四、自定义字符串类示例程序：
#include
using namespace std;
const int n=256;
class mystring{
char str[n]; //存放字符串的数组容器，可考虑定义指针，在构造函数中动态分配空间
int maxsize; //最大可用元素数，可防止数组出界，提高健壮性
int last; //已用元素最大下标
public:
mystring(){
last=-1;
maxsize=n;
str[0]='\0';
cout<<"缺省构造函数"<}
mystring(char *s){//当C字符串过长，初始化时采用截尾处理
last=-1;
maxsize=n;
do{
last++

;
str[last]=s[last];
}while(s[last]!='\0'&&laststr[last] ='\0'; //截尾处理时，必须加串结束符
cout<<"构造函数"<}
mystring(mystring & ms){
last=-1;
maxsize=n;
do{
last++;
str[last]=ms.str[last];
}while(lastcout<<"拷贝构造函数"<}
~mystring(){
cout<<"析构函数"<}
void show(){//如需重载<<，则参考补充课件，替代方法是用show()函数
cout<}
int strlen(){return last;}; //求字符串长度
void reverse(); //逆置字符串
int strchr(char c); //查找字符串中字符c首次出现的位置
int strstr (mystring str1); //查找主串中子串str1首次出现的位置
char & operator[](int i){ //返回引用，可读可写
if(i>last) last=i; //下标运算符，可添加长度但不查边界
return str[i];
}
mystring & operator=(mystring &);
mystring & operator=(char * ms);//这里重载的=是把C风格字符串赋给mystring
mystring operator+(mystring &); //这里返回不能用引用
mystring & operator+=(mystring &);
bool operator<(mystring &);
bool operator==(mystring &);
};
void mystring::reverse(){
int i=0,j=last-1;
char temp;
while(j>i){//注意此处，从串两头同时向中间移动，重合或交错时停止
temp=str[i]; //头尾交换
str[i]=str[j];
str[j]=temp;
i++;
j--;
}
}
int mystring::strchr(char c){
int i;
for(i=0;i!=last;i++) if(str[i]==c) return i;
return -1; //未找到返回-1
}
int mystring::strstr(mystring str1){
int i=0,k=1;
while(str[i]!='\0'){//只要主串还有字符未查，则继续
while(str[i]!=str1[0]&&str[i]!='\0') i++;
//找到主串含有子串的第一个字符,或主串查完停止
if(str[i]!='\0'){//核对子串其他字符
while(str[i+k]==str1.str[k]&&kif(k==st) return i;//找到子串返回
k=1;
i++;
}
}
return -1; //未找到返回-1
}
mystring & mystring::operator=(mystring & ms){//这里返回值改为引用，不调用拷贝构造函数
last=-1;
do{
last++;
str[last]=ms.str[last];
}while(lastreturn *this;
}
mystring & mystring::operator=(char* ms){ //这里返回值为引用，不调用拷贝构造函数
last=-1;
do{
last++;
str[last]=ms[last];
}while(ms[last]!='\0'&&laststr[last] ='\0'; //截尾处理时，必须加串结束符
return *this;
}
mystring mystring::operator+(mystring & ms){//注意+和+=的不同
mystring temp(*this);//+必须在一份拷贝上进行
int i=-1;
st--;//串的结尾是结束符，连接时要覆盖掉
do{
st++;
i++;
temp.str[st]=ms.str[i];
}while(itemp.str[st] ='\0'; //截尾处理时，必须加串结束符
return temp;//拷贝的临时变量生命期在调用它的表达式中
}
mystring & mystring::o

perator+=(mystring & ms){//+=在对象自身进行
int i=-1;
last--;//串的结尾是结束符，连接时要覆盖掉
do{
last++;
i++;
str[last]=ms.str[i];
}while(istr[last] ='\0'; //截尾处理时，必须加串结束符
return *this;
}//这里返回值改为引用，不调用拷贝构造函数
bool mystring::operator<(mystring & ms){ //重载<运算符
int i=0,k;
do{
k=str[i]-ms.str[i];
i++;
}while(k==0&&iif(k<0) return true;
if(i==last&&i!=st) return true;
return false;
}
bool mystring::operator==(mystring & ms){
int i=0,k;
if(last!=st) return false;
do{
k=str[i]-ms.str[i];
i++;
}while(k==0&&iif(k!=0) return false;
else return true;
}
int main(){
int i;
char *sp1="东南大学",*sp2="交通学院",*sp3="学生",*sp4="教师";
mystring ms1(sp1),ms2(sp2),ms3(sp3);//ms1,ms2,ms3是用构造函数生成
mystring ms4(ms3),ms5=ms3,ms6; //ms4,ms5用拷贝构造函数生成;ms6用缺省构造函数
ms6=sp4; //ms6赋值是返回引用，不用拷贝构造函数
ms1.show();
ms2.show();
ms3.show();
ms4.show();
ms5.show();
ms6.show();
ms4=ms1+ms2+ms6;//注意+中的temp和临时变量由拷贝构造函数生成
ms4.show();
ms1+=ms2+=ms3;//+=返回引用，不用拷贝构造函数
ms1.show();
if(ms1else {ms1.show();cout<<"应排在"<ms6=ms1;//ms6赋值不是返回引用，必须调用拷贝构造函数建立临时对象
if(ms1==ms6) cout<<"串ms1与串ms6相同"<ms1="C++ programming language";
i=0;
while(ms1[i]!='\0') cout<cout<ms1[i++]='.';//写入
ms1[i]='\0';
i=0;
ms1.show();
cout<cout<<"ms1串长："<cout<<"字符l在ms1中的下标为："<ms2="ing";
cout<<"ms2在ms1中的起始下标为："<ms1.reverse();
ms1.show();
return 0;
}

完成：
1）仔细阅读、理解、分析该程序，并调试运行;
2）考虑将属性char str[n] 改为char *str,如何修改相应的成员函数（尤其是构造及析构函数）。
2）对示例程序中的运算符成员函数试着用友元函数替代实现。
3）对插入运算符"<<"，析取运算符">>"运算，仿照补充课件用友元函数来实现，并测试之。


若不做特别说明，在下列编程题中成员函数均为公有的，数据成员均为私有的。

1。定义一个复述类Complex,数据成员包括实部real和虚部image。成员函数包括：
（1）设置实部函数：void SetReal(int r)
（2) 设置虚部函数：void SetImage(int ima)
（3）取实部值函数：int GetReal()
（4）取虚部值函数: int GetImage()
（5）输出复数函数：void ShowComplex()
在主函数中定义一个复数类对象

，然后对所有成员函数进行测试。

2。定义一个日期类date，数据成员有year,month,day。成员函数有：
（1）私有成员函数int isleap()判断year是否是闰年，若是返回1，否则返回0。
（2）私有成员函数int check()判断日期是否合法，若合法返回1，若不合法返回0。
（3）设置年，月，日，并检测是否为合法日期。
（4）按yyyy/mm/dd格式输出日期，若是闰年，还要输出是否是闰年的信息。
在主函数中定义一个日期类对象，任意输入年、月、日值，然后对若有成员函数进行测试。

3。为第1题复数类增加构造函数：（1）无参的构造函数 （2）带参数的构造函数，参数为实部和虚部的初值。
（3）拷贝构造函数。 在主函数中增加测试三个构造函数的语句。

要求：第1、2题是下周二、周三的上机实验题，需事先写好实验报告（电子版的），上机时检查！

第3题是作业题，最迟下周日前在“面向对象程序设计BB平台->讨论板->2013级ABC班作业提交处”
相应目录下提交加密的word电子文档作业，要给出程序运行结果！

布置日期：2014.9.11


第十章作业
若不做特别说明，在编程题中成员函数均为公有成员函数,数据成员均为私有的。

1．试设计一个类用于对整数进行判别，并根据判别的结果分别统计所判别过的正整数和负整数的个数，并能格式显示其统计结果。
(1) 建议该类可以命名为Stat;
(2) 为了存放所判别过的正、负整数个数的统计结果，该类应有两个私有整型数据成员，成员名可以命名为 positiveCount和 negativeCount。
(3) 该类需要一个无参数的构造函数，构造该类对象时必须将存放正、负整数个数的统计结果的两个私有整型数据成员的初始值设置为 0。
(4) 该类应拥有一个接口成员函数（即公有成员函数）为Check(int n)， 用于判别一个整数参数n是正整数还是负整数，并分别累计到
数据成员：positiveCount和 negativeCount。
(5) 该类还应拥有另一个接口成员函数 Show()，用于格式显示统计结果。例如，显示格式和内容可以按如下所示：
所判别的整数共 XXX 个，其中正整数 XX 个，负整数 YY 个

要求：
(1) 实现类Stat的定义和各个成员函数的定义；
(2) 定义 1 个类外的普通函数CheckInputValue，该函数的原型声明如下：
void CheckInputValue(int in[], int num, Stat &stat);
该函数的功能是使用Stat类对象 stat对具有num个元素的整型数组 in[]中的数据依次判别，并统计数组元素中的正、负数个数存放到
统计对象stat中的positiveCount和 negativeCount数据成员中。
(3) 编制主函数实现以下功能：
①

从键盘输入至少10个（正/负）整数，将它们存放在一个预先定义的整型数组中。
②创建一个Stat类对象，用于对输入的所有整数的判别统计，即将存放输入整数的数组、数组元素个数和所创建的Stat类对象为实参
调用CheckInputValue函数统计，最后显示Stat类对象对数组元素的统计结果；


2。在本题中，将一个类的对象作为另一个类的数据成员（类的组合）：定义一个平面坐标系下的“点”类point,数据成员为x,y坐标值（整数型）,
成员函数为（1）带参数的缺省构造函数。如：Point(int xx=0,int yy=0);
（2）拷贝构造函数Point(Point &p)
（3）设置x,y坐标值:void SetPoint(int xx,int yy)
（4）取x，y坐标值，参数为两个整形量的引用，分别用于获取x,y的坐标值:void Getxy(int &xx,int &&yy)

再定义一个三角形类Triangle，数据成员为三个point类的对象p1,p2,p3。
成员函数包括：（1）带参数的缺省构造函数，参数为整型x1,y1,x2,y2,x3,y3，分别是三个顶点的坐标，各参数均有缺省值:
Triangle(int x1=1,int x2=2,int x3=3,int y1=1,int y2=2,int y3=3)
（2）带参数的构造函数，参数是三个point类对象的引用:Triangle(Point &p1,Point &p2,Point &p3)
（3）设置顶点p坐标，参数为两个整型参数:void SetPoint(int xx,int yy)
（4）设置顶点p坐标，参数是一个point类对象的引用:void SetPoint(Point &p)
（5）取顶点坐标，参数为两个整型变量的指针，即将两个坐标值放入两个指针指向的变量中:
void Getxy(int *x1,int *y1)
（6）取顶点坐标，参数为两个整型变量的引用，即将两个坐标值赋值给两个引用变量:
void Getxy(int &xx,int &yy)
（7）取顶点坐标，参数是一个point类对象的引用:void Getxy(Point &p)
（8）输出三角形的三个顶点的坐标、周长和面积:void OutPut()




要求：第1题是下周四的上机实验题，需事先写好实验报告（电子版的），上机时检查！

第2题是作业题，最迟下周日前在“面向对象程序设计BB平台->讨论板->2013级ABC班作业提交处”
相应目录下提交加密的word电子文档作业，要给出程序运行结果！

布置日期：9.18


类组合知识要点如下及参见书上例题9-8：

类组合的构造函数设计：
原则：不仅要负责对本类中的基本类型成员数据赋初值，也要对对象成员初始化。
声明形式：
类名::类名(对象成员所需的形参，本类成员形参)
：对象1(参数)，对象2(参数)，......
{ 本类初始化 }

例

子如下：
class Point
{ private:
float x,y; //点的坐标
public:
Point(float h,float v); //构造函数
Point(Point &p){x=p.x;y=p.y;}; //拷贝构造函数
float GetX(void); //取X坐标
float GetY(void); //取Y坐标
void Draw(void); //在(x,y)处画点
};
//...函数的实现略
class Line
{
private:
point p1,p2; //线段的两个端点
int len; //线段长度
public:
//在组合类Line的构造函数中不仅要对其基本数据成员len赋初值，更要对其包含的point类的p1,p2
//两个对象成员初始化
Line(Point a,Point b,int d):p1(a),p2(b),len(d){}
Void Draw(void); //画出线段
};
//...函数的实现略





派生类补充题：

1.填空
a)如果类A继承了类B,则类A称为__派生____类，类B称为__基__类。

b)C#提供的_软件复用____机制允许一个派生类继承多个基类，即使这些基类是相互无关的。

c)利用继承能够实现_可重用性_________,这种实现缩短了程序的开发时间。

d)_派生_____类的对象可作为__基___类的对象处理。

e)为了将基类指针转换为派生类指针，由于编译器认为这种操作是危险的，所以要使用___强制类型转换__________.

f)三种成员访问说明符分别是__public_______,_private__________,_protected___________。

g)当用protected继承从基类派生一个类时，基类的public成员成为派生类的____protected____成员，protected成员成为派生类的__protected_______成员。

1.以点(point)类为基类，重新定义矩形类和圆类。点为直角坐标点，矩形水平放置，由左下方的顶点和长宽定义
圆有圆心和半径定义。派生类操作判断任一坐标点是在图形内，在图形的边缘上，
还是在图形外。默认初始化图形退化为点。要求包括拷贝构造函数。编程测试类是否正确。

2.用单一继承方式定义平面坐标系下的点类Point,线类Line和三角形类Triangle。Line类单一继承Point类，另外增加第2个点坐标。Triangle
类单一继承Line类，另外增加第3个点坐标。在主函数中定义一个三角形对象，调用成员函数求出并输出三角形的三个顶点坐标，三角形的周长，
面积。

以上编程题既是下周的上机题，同时也是作业题，下周日（10月5日前提交）。






1.完成程序，使它输出如下结果：
25
86
#include
class A{
int a;
public:
A(int m=0):a(m){}
A(A &t){____________;}
void show(){cout<};
class B:public A
{
int b;
public:
B(int m,int n):A(m),b(n){}
B(B &t):__________________;
void show(){A::show();cout<};
void main()
{
B b(25,86),c(b);
b.show();
}

2.完成下面程序，使它输出：58，96
#include

class test{
private:
int m,n;
public:
test(int,int);
void show();
};
test::test(int a,int b){m=a;n=b;}

void test::show(){cout<void main()
{
test obj__________;
__________________;
}


3.完成下面程序，使它输出：
3
5
a[0]=3
a[1]=5

#include
class base{
private:
int x;
public:
void setx(int a){x=a;}
int getx(){return x;}
};
void main()
{
base a[2],*p;
a[0].setx(3);
a[1].setx(5);
for(p=a;p_____________________;
for(int i=0;i<2;i++)
_____________________;
}

4.完成下面程序，使它输出：4,8
#include
class base{
private:
int x,y;
public:
void setxy(int a,int b){x=a;y=b;}
void show(____________);
};
inline void base::show(___________)
{
____________________;
}
void print(__________)
{
p.show(p);
}
void main()
{
base a;
a.setxy(4,8);
print(______);
}

5.完成下面程序，使它输出：58,98
58,98
而且在主程序中只允许显式地使用一次setxy成员函数
#include
class base{
private:
int x,y;
public:
void setxy(int a,int b){x=a;y=b;}
void show(){______________________;}
};

void main()
{
base a,b;
_________________;
a.show();
_________________;
b.show();
}

6.根据下面的主程序，补上所缺类说明文件的最小形式。
#include
#include "base.h"
void main()
{
base a,b;
a.setx(6);
b.sety(65);
cout<}


7. 下列程序段式正确的是：( )
A. class Rectangle{
private:
int width=55,length=20;
};

B.class num{
int value;
};
int num::value=56;

C.class point{
int a,b;
public: void set(int=0,int=0);
};

D.class point{
int b=0;int c=0;
public:
void set(int,int);
};


8.找出下面程序中的错误并改正,给出输出结果
#include
class point{
int x,y;
public:
void init(int a,int b){setx(a);sety(b);}
int getx(){return x;}
int gety(){return y;}
void setx(int a){x=a;}
void sety(int b){y=b;}
};
void main(){
point A.init(2,6);
point B.init(3,5);
cout<<"A.x="<cout<<"B.x="<}

9.分析下面程序，根据输出结果完善程序。要求：(1)在主函数中不可以通过对象c1访问类中的所有数据成员。
(2)程序的运行结果为：3 6 9
#include
class A
{ (1)___________________ //最合理的访问权限
int a;
public:
A(int i=0){a=i;}
};
class B
{
(2)_____________________ //最合理的访问权限
int b;
public

:
B(int i=0){b=i;}
};
class C:public A
{
int c;
B b1;
public:
(3)__________________________________ //根据运行结果定义构造函数
{(4)_____________________________}
void show()
{
(5)__________________________
}
};

int main()
{
C c1(3,6,9);
c1.show();
return 0;
}

以上题目作为作业完成，每题应给出完整程序及运行结果。