习题实验讲解1011章.docx
《习题实验讲解1011章.docx》由会员分享，可在线阅读，更多相关《习题实验讲解1011章.docx（12页珍藏版）》请在冰点文库上搜索。
习题实验讲解1011章
/*习题10.13：
定义一个矩形类Rect，矩形的左上角坐标（Left，Top）和右下角坐标（Right，Bottom）定义为私有数据成员，成员函数包括计算面积、计算周长、输入和输出。
定义Rect类数组，计算各个矩形的面积和周长并输出。
*/
/*#include
usingnamespacestd;
classRect{
private:
floatleft,top;
floatright,bottom;
floatlength,area;//此两成员可不用
public:
voidinput（floatle,floatto,floatri,floatbo）//输入函数，输入数据成员{left=le;top=to;right=ri;bottom=bo;}
voidinput（）//重载输入函数，用于数组输入
{cout<<"Inputleft,topandright,bottom:
";
cin>>left>>top>>right>>bottom;}//无参，直接输入数据成员的值
floatgetLength（）//无参，有返回值（也可无返回值）
{length=（（top-bottom）+（right-left））*2;
returnlength;
}
voidgetArea（）//无返回值
{area=（top-bottom）*（right-left）;}
voidOutput（）;//体内声明函数
};
voidRect:
:
Output（）//体外定义函数
{cout<<"（left,top）="<<'（'<cout<<"（right,bottom）="<<'（'<cout<<"Length="<}
intmain（void）
{Rectrect1;//定义Rect类的对象rect1
rect1.input（2,4,4,2）;//rect1的数据成员的值作为实参输入
rect1.getLength（）;//数据的输入、计算和输出均通过对象的函数成员进行
rect1.getArea（）;
rect1.Output（）;
Rectr[2];//定义Rect类的对象数组
inti;
for（i=0;i<2;i++）
{r[i].input（）;//键盘输入数组元素，此时用前一种实参的输入方式就不方便
r[i].getLength（）;
r[i].getArea（）;
r[i].Output（）;
}
return0;
}
此题中对象数组数据的输入未采用构造函数的形式，而是采用专门的输入函数。
/*习题10.17设计一大小可变的整形数组类：
classCArray{
intsize;//数组的元素个数
int*p;//指向为数组申请的动态内存
public:
CArray（int=100）;//数组缺省大小为100个元素
~CArray（）;//析构函数
int&GetElem（inti）;//取或设置数组中的第i个元素
voidInput（）;//为数组所有元素输入数据
voidPrint（）;//输出数组中的所有元素
voidSort（）//对数组元素进行排序
intSearch（int）;//在数组中查找指定值
};
首先完成CArray类中成员函数的定义，然后设计主函数，定义CArray的对象，测试所定义的类CArray。
*/
/*#include
usingnamespacestd;
classCArray{
intsize;
int*p;
public:
CArray（ints=3）//构造函数，默认值用3，为了调试方便
{size=s;
p=newint[size];//申请动态内存，注意为[]号，用（）合法，编译不会出错,
但含义不同。
cout<<"构造函数被调用\n";
}
~CArray（）
{delete[]p;//释放内存
cout<<"析构函数被调用\n";
}
int&GetElem（inti）;//取或设置指定元素，以下均为函数声明
voidInput（）;//输入数组元素
voidOutput（）;//输出数组元素
voidSort（）;//数组元素排序
intSearch（int）;//查找给定值，见例7.5，移植类似于Sort函数，此处不再重复
};
int&CArray:
:
GetElem（inti）
{return*（p+i）;}//返回值类型为整形引用，返回值为指针所指的整形元素
voidCArray:
:
Input（）
{cout<<"输入数组元素：
\n";
for（intj=0;j>p[j];//*p++不行，p会改变，影响后面p的使用及删除
}
voidCArray:
:
Output（）
{for（intj=0;jvoidCArray:
:
Sort（）//冒泡排序
{floatt;
for（inti=1;ifor（intj=0;jif（p[j]>p[j+1]）//相邻比较，若逆序则交换
{t=p[j];p[j]=p[j+1];p[j+1]=t;}
}
voidmain（void）
{intsize,k,j;
cout<<"输入数组大小：
";
cin>>size;
CArrayar1（size）;//无参则用默认值
ar1.Input（）;
ar1.Output（）;
cout<<"输入需要设置的元素的位置：
"<cin>>k;
ar1.GetElem（k）=10;//置第k个元素的值
cout<<"输入需要取的元素的位置：
"<cin>>j;
cout<ar1.Sort（）;//排序
ar1.Output（）;
}
此题要注意掌握动态数组作为类的成员，其构造函数的设计及数组元素输入的方法。
/*习题11-9：
定义矩形类Rectangle，其数据成员left和right是Point类的对象，分别表示矩形的左上角和右下角坐标。
试为Rectangle类重载运算符“<”和“>”，实现两个矩形对象面积大小的比较*/
/*#include
usingnamespacestd;
classPoint{
floatx,y;
public:
Point（floata,floatb）//构造函数初始化x、y
{x=a;y=b;Show（）;}//调用函数成员Show
floatGetx（）
{returnx;}//取x，用于间接访问私有成员
floatGety（）
{returny;}//取y，用于间接访问私有成员
voidShow（）
{cout<<"（x,y）="<<'（'<};
classRect{//定义类Rect
Pointleft,right;//Point类的对象成员
public:
//构造函数初始化对象成员
Rect（floatx1,floaty1,floatx2,floaty2）:
left（x1,y1）,right（x2,y2）
{}//函数体不可缺
floatgetArea（）//计算面积的函数，无参
{return（（left.Gety（）-right.Gety（））*（right.Getx（）-left.Getx（）））;
//用对象的成员函数访问私有成员
friendintoperator>（Rect&r1,Rect&r2）//重载“>”为友元运算符
{if（r1.getArea（）>r2.getArea（））return1;elsereturn0;}//体内定义函数体
friendintoperator<（Rect&r1,Rect&r2）;//重载“<”，体内声明
};
intoperator<（Rect&r1,Rect&r2）//体外定义函数体
{if（r1.getArea（）intmain（void）
{Rectr1（2,4,4,2）,r2（1,4,4,1）;//定义两个Rect对象，并初始化
cout<<"r1的面积：
"<<<"r2的面积：
"<if（r1>r2）cout<<"r1面积大于r2面积"<运算符
elsecout<<"r1面积小于r2面积"<if（r1elsecout<<"r1面积大于r2面积"<return0;}
/*习题11-12：
定义一个M×N的实型矩阵Matrix，重载+、-和=运算，实现矩阵的加，减和赋值运算。
*/
#include
usingnamespacestd;
//先简单点，定义一个固定的矩阵，主要练习重载的方法
classMatrix{
floatm[2][2];
public:
Matrix（floatm11=0,floatm12=0,floatm21=0,floatm22=0）//构造函数{m[0][0]=m11;m[0][1]=m12;m[1][0]=m21;m[1][1]=m22;}//初始化x、y
voidShow（）//输出矩阵元素
{for（inti=0;i<2;i++）
{for（intj=0;j<2;j++）
cout<<'\t'<cout<cout<}
Matrixoperator+（Matrix&）;//重载为类运算符，体外定义函数体
Matrix&operator=（Matrix&m2）//重载为类运算符,返回值为对象引用
{for（inti=0;i<2;i++）//体内定义函数体
for（intj=0;j<2;j++）
m[i][j]=m2.m[i][j];//第一操作数（左操作数）为当前对象
return*this;//返回当前对象，this指针指向当前对象
}
friendMatrixoperator-（Matrix&,Matrix&）;//重载为友元运算符
};
//类运算符体外定义函数体
MatrixMatrix:
:
operator+（Matrix&m2）//形参只有一个，为第二操作数
{Matrixt;//定义临时对象t，存放相加结果
for（inti=0;i<2;i++）
for（intj=0;j<2;j++）
t.m[i][j]=m[i][j]+m2.m[i][j];//第一操作数（左操作数）为当前对象
returnt;//返回结果对象
}
//友元运算符体外定义函数体
Matrixoperator-（Matrix&m1,Matrix&m2）//第一操作数需显式作为形参
{Matrixt;
for（inti=0;i<2;i++）
for（intj=0;j<2;j++）
t.m[i][j]=m1.m[i][j]-m2.m[i][j];//注意与上面比较
returnt;
}
intmain（void）
{Matrixm1（1,2,3,4）,m2（4,3,2,1）,m3;//定义Matrix对象，并初始化cout<<"m1：
";m1.Show（）;//输出各个矩阵元素
cout<<"m2：
";m2.Show（）;
cout<<"m3：
";m3.Show（）;
m3=m1+m2;//调用+运算符
m2=m1;//调用=运算符
m1=m3-m2;//调用-运算符
cout<<"m1+m2：
";m3.Show（）;//输出各个运算结果
cout<<"m2=m1：
";m2.Show（）;
cout<<"m3-m2：
";m1.Show（）;
return0;
}
//编写矩阵大小可变的程序
#include
usingnamespacestd;
classMatrix{
introws,cols;
double*t;
public:
Matrix（intr,intc）//构造函数
{rows=r,cols=c;
t=newdouble[rows*cols];
}
Matrix（Matrix&c）//拷贝构造函数，相当于重载
{rows=c.rows,cols=c.cols;
t=newdouble[rows*cols];//生成一个临时动态对象
for（inti=0;ifor（intj=0;jt[i*cols+j]=c.t[i*cols+j];
}
~Matrix（）//析构函数
{if（t）
delete[]t;
}
voidoperator=（Matrix&）;//重载=、+、-
Matrixoperator+（Matrix&）;
Matrixoperator-（Matrix&）;
};
voidMatrix:
:
operator=（Matrix&p）
{for（inti=0;ifor（intj=0;jt[i*cols+j]=p.t[i*cols+j];
}
MatrixMatrix:
:
operator+（Matrix&p）
{
Matrixm（rows,cols）;
for（inti=0;ifor（intj=0;jm.t[i*cols+j]=p.t[i*cols+j]+t[i*cols+j];
returnm;//将调用拷贝构造函数
}
MatrixMatrix:
:
operator-（Matrix&p）
{
Matrixm（p.rows,p.cols）;
for（inti=0;ifor（intj=0;jm.t[i*cols+j]=t[i*cols+j]-p.t[i*cols+j];
returnm;
}
intmain（void）
{
intx,y;
cout<<"输入矩阵行列数：
";
cin>>x>>y;
Matrixa（x,y）,b（x,y）,c（x,y）,d（x,y）,e（x,y）;
cout<<"输入第一个矩阵：
\n";
cin>>a;
cout<<"输入第二个矩阵：
\n";
cin>>b;
cout<<"赋值结果是：
\n";
c=a;
cout<cout<<"加法结果是：
\n";
d=a+b;//产生临时对象，调用拷贝构造函数
cout<cout<<"减法结果是：
\n";
e=a-b;
cout<return0;
}
升级会员 