面向对象程序设计(C--)-大作业.doc

华北科技学院计算机学院综合性实验报告

华北科技学院计算机系综合性实验

实 验 报 告

课程名称 《面向对象程序设计(C++)》
实验学期 2012 至 2013 学年 第 一 学期
学生所在院部 计算机学院
年级 2011 专业班级 计科B11-1
学生姓名 学号
任课教师
实验成绩

计算机系制
《面向对象程序设计(C++)》课程综合性实验报告
开课实验室：软件工程实验室 2013年1月4日
实验题目
复数类的设计
一、实验目的
(1)掌握类的概念及构造方法；
(2)掌握构造函数的定义与使用；
(3)掌握友元的定义与使用；
(4)掌握运算符的重载定义与使用。
二、设备与环境
Visual c++ 6.0
三、实验内容
设计复数类，重载+，-，*，/，<<，>>等运算符。编程设计实现下列函数：
MyComplex();
MyComplex(int a);
MyComplex(int a,int b);
MyComplex(const MyComplex& v);
MyComplex& operator=(const MyComplex& rhs);
MyComplex& operator+=(const MyComplex& rhs);
MyComplex& operator-=(const MyComplex& rhs);
MyComplex& operator*=(const MyComplex& rhs);
MyComplex& operator/=(const MyComplex& rhs);
friend MyComplex operator+(const MyComplex& m,const MyComplex& n);
friend MyComplex operator-(const MyComplex& m,const MyComplex& n);
friend MyComplex operator*(const MyComplex& m,const MyComplex& n);
friend MyComplex operator/(const MyComplex& m,const MyComplex& n);
friend bool operator==(const MyComplex&,const MyComplex&);
friend bool operator!=(const MyComplex&,const MyComplex&);
friend ostream& operator<<(ostream& s,MyComplex t);
friend istream& operator>>(istream& s,MyComplex& t);

四、实验结果及分析
实验结果：

实验分析：
首先，用class定义复数类Complex,在类声明中设置访问限定符private、public。将只能让类内部访问的数据成员设置为private权限，即int rem,imp；将需要让类的外部函数（非本类定义的函数）访问的成员函数设置为public权限。类的数据成员可以是任何数据类型，如整型、浮点型，字符型，数组，指针、引用等，但不能指定为auto、register、extern存储类型。在类域的函数原型前加上关键字friend，将该函数指定为Complex类的友元，使该函数可以直接访问Complex类的私有成员。类的友元函数是一种特殊的普通函数，可以直接访问类的私有成员。关键字friend用于声明友元，它只能出现在类的声明中。友元函数并非类的成员函数，所以它不受public，private的限定，无论将它放在public区，或者private区，都是完全相同的。
然后，再定义成员函数。类的成员函数有两种定义方式：一种是在声明类时就给出成员函数的定义，以这种方式定义的成员函数若符合内联函数的条件就会被处理为内联函数；另一种是在声明类时只声名成员函数的原型，然后在类的外部定义成员函数。本实验采用的第二种方法，类声明中成员函数原型中的形参名可以省略，只声明各个形参的类型，如MyComplex(int,int)；成员函数的返回类型、函数名称、参数表必须与成员函数原型的声明完全相同，而且必须指出每个形参的名字，必须在成员函数名前面加上类名，并且在类名与成员函数之间用∷间隔，如MyComplex::MyComplex(int a,int b)。
接下来，是二元运算符的重载。二元运算符既可以作为类的成员函数重载，也可以作为类的友元或普通该函数重载。它们的区别是：作为类成员重载时只需要一个参数，作为类的友元或普通函数重载时需要两个参数；调用类的重载运算符时，作为类成员函数运算符的左参数必须是一个类对象，而作为友元或普通函数重载的运算符则无此限制。本实验采用的是第二种方式，作为类的友元函数重载。重载的运算符有+、-、*、/，还有赋值运算符=，输入输出运算符<<、>>。用const限制函数的参数能够保证函数不对参数做任何修改，既高效又安全。
还有，字符穿的相等和不等比较。
最后，是主函数的构造。
通过编写复数类，使我更进一步加深了对类和对象的了解，类是对象的抽象数据类型，是对象的特性和操作，对象是类的实例化，是具体的；清楚了重载运算符的功能、如何重载、如何运用重载的过程，利用函数对运算符重载，在主函数直接按照整形或浮点型进行运算的格式写即可。
此次课程设计试验过程的不足，没有认真学习复数类设计的知识，对很多东西都认识不足，还有待提高。在实际操作中犯了一些错误却让我意外收获了不少，所学C++理论知识得到了巩固，通过实际操作，我学会了C++语言编程的基本步骤、基本方法，开发了自己的逻辑思维能力，培养了分析问题、解决问题的能力。
教 师 评 价
评定项目
A
B
C
D
评定项目
A
B
C
D
算法正确

界面美观，布局合理

程序结构合理

操作熟练

语法、语义正确

解析完整

实验结果正确

文字流畅

报告规范

题解正确

其他：

评价教师签名：
年 月 日

//*******//
// 复数类的设计 //
// 2007/11/27 华北科技学院 //
//************************************************************//
#include
using namespace std;

class MyComplex;
MyComplex operator+(const MyComplex&,const MyComplex&);
MyComplex operator-(const MyComplex&,const MyComplex&);
MyComplex operator*(const MyComplex&,const MyComplex&);
MyComplex operator/(const MyComplex&,const MyComplex&);
ostream& operator<<(ostream&,MyComplex);
istream& operator>>(istream&,MyComplex&);
bool operator==(const MyComplex&,const MyComplex&);
bool operator!=(const MyComplex&,const MyComplex&);

class MyComplex
{
public:
MyComplex();
MyComplex(int);
MyComplex(int,int);
MyComplex(const MyComplex&);

MyComplex& operator=(const MyComplex&);
MyComplex& operator+=(const MyComplex&);
MyComplex& operator-=(const MyComplex&);
MyComplex& operator*=(const MyComplex&);
MyComplex& operator/=(const MyComplex&);

friend MyComplex operator+(const MyComplex&,const MyComplex&);
friend MyComplex operator-(const MyComplex&,const MyComplex&);
friend MyComplex operator*(const MyComplex&,const MyComplex&);
friend MyComplex operator/(const MyComplex&,const MyComplex&);
friend bool operator==(const MyComplex&,const MyComplex&);
friend bool operator!=(const MyComplex&,const MyComplex&);
friend ostream& operator<<(ostream&,MyComplex);
friend istream& operator>>(istream&,MyComplex&);
private:
int rem,imp;
};
//---------------------------------------------------------------

MyComplex::MyComplex()
{
rem=0;
imp=0;
}
MyComplex::MyComplex(int a)
{
rem=a;
imp=0;
}
MyComplex::MyComplex(int a,int b)
{
rem=a;
imp=b;
}
MyComplex::MyComplex(const MyComplex& v)
{
rem=v.rem;
imp=v.imp;
}
//---------------------------------------------------------------

MyComplex& MyComplex::operator=(const MyComplex& n)
{
rem=n.rem;
imp=n.imp;
return *this;
}
MyComplex& MyComplex::operator+=(const MyComplex& n)
{
rem+=n.rem;
imp+=n.imp;
return *this;
}
MyComplex& MyComplex::operator-=(const MyComplex& n)
{
rem-=n.rem;
imp-=n.imp;
return *this;
}

MyComplex& MyComplex::operator*=(const MyComplex& n)
{
return *this;
}
MyComplex& MyComplex::operator/=(const MyComplex& n)
{
return *this;
}
//------------------------------------------------------------------------------
MyComplex operator+(const MyComplex& m,const MyComplex& n)

{
MyComplex t;
t.rem=m.rem+n.rem;
t.imp=m.imp+n.imp;
return t;
}
MyComplex operator-(const MyComplex& m,const MyComplex& n)
{
MyComplex t;
t.rem=m.rem-n.rem;
t.imp=m.imp-n.imp;
return t;
}
MyComplex operator*(const MyComplex& m,const MyComplex& n)
{
MyComplex t;
t.rem=m.rem*n.rem-m.imp*n.imp;
t.imp=m.rem*n.imp+m.imp*n.rem;
return t;
}
MyComplex operator/(const MyComplex& m,const MyComplex& n)
{
MyComplex t;
t.rem=(m.rem*n.rem+m.imp*n.imp)/(n.rem*n.rem+n.imp*n.imp);
t.imp=(m.imp*n.rem-m.rem*n.imp)/(n.rem*n.rem+n.imp*n.imp);
return t;
}
//-------------------------------------------------------------------------

bool operator==(const MyComplex& m,const MyComplex& n)
{
return((m.rem==n.rem)&&(m.imp==n.imp));
}
bool operator!=(const MyComplex& m,const MyComplex& n)
{
return((m.rem!=n.rem)||(m.imp!=n.imp));
}
//-------------------------------------------------------------------------
ostream& operator<<(ostream& s,MyComplex t)
{
if(t.imp==0)
s<>(istream& s,MyComplex& t)
{
s>>t.rem>>t.imp;
return s;
}
//--------------------------------------------------------------------------
void main()
{
MyComplex a,b;
cout<<"please input the first MyComplex a:"<>a;
cout<<"please input the second MyComplex b:"<>b;
cout<<"a="<<"b="<