实验五 运算符重载的应用
班级：B135A2学号： 201322688 姓名： 杨弘 成绩：
一． 实验目的
1、理解运算符重载的作用；
2、掌握运算符重载的两种方法；
3、掌握单目、双目运算符的重载；
二． 使用的设备和仪器
计算机+Windows XP +Visual C++6.0
三． 实验内容及要求
1、定义一个复数类Complex ，重载运算符“-”，使之能用于复数与实数的减法运算。参加运算的两个操作数一个是类的对象，一个是实数，顺序任意。例如：i-c ，c-i 均合法（其中，c 为复数类的对象，i 为实数）。
减法规则：复数实部与实数相减，复数虚部不变。
2、定义点类Point ，重载运算符“＋”、“－”、“＝＝”、“！=”、“++”、“--”、“>>”、“
3、定义一个矩阵类Matrix ，均为M 行N 列，通过重载运算符“+”、“-”，“>”, “++”, “--”，“==”，“！=”来实现矩阵的相加、相减、输出、输入、自增、自减以及相等、不等的判断。
4、定义时间类Time ，时间的表示采用24小时制。重载运算符“>”实现时间的输出和输入；重载运算符“+”和“-”实现时间推后和提前若干分钟；重载运算符“++”和“--”实现当前时间推后和提前1小时；重载“>”、“
注意：输入时需对数据合法性进行判断。
5、编写一个程序，处理一个复数与一个double 型数相加的运算，结果存放在一个double 型的变量d1中，输出d1的值，再以复数形式输出此值。定义复数（Complex ）类，在成员函数中包含重载类型转换运算符：
Operator double（）{ return real；}
6、定义一个教师类和一个学生类，二者有一部分数据成员是相同的，例如num ，name ，sex 。请编程，将一个学生类对象转换为教师类，只将以上3个相同的数据成员移植过去。可以设想为：一位学生大学毕业了，留校担任教师，他原有的部分数据对现在的教师身份来说仍然是有用的，应当保留并成为其教师的数据的一部分。
四． 实验步骤
1. 程序代码：/*1、定义一个复数类Complex ，重载运算符"-" ，使之能用于复数与实数的减
法运算。参加运算的两个操作数一个是类的对象，一个是实数，顺序任意。
例如：i-c ，c-i 均合法（其中，c 为复数类的对象，i 为实数）。
减法规则：复数实部与实数相减，复数虚部不变。*/
#include //#include
using std::cin;
using std::cout;
using std::endl;
//using namespace std;
class Complex //定义复数类
{
private:
double real,imag;
public:
Complex()
{
real=0;
imag=0;
}
Complex(double a,double b)
{
real=a;
imag=b;
}
void Display();
void Input();
friend Complex operator-(Complex &a,double b);
friend Complex operator-(double b,Complex &a);
};
Complex operator-(Complex &a,double b) //定义“-”重载函数
{
return Complex(a.real-=b,a.imag);
}
Complex operator-(double b,Complex &a)
{
return Complex(a.real-=b,a.imag);
}
void Complex::Input()
{
cout
cout
cin>>real>>imag;
}
void Complex::Display()
{
cout
cout
}
int main() //主函数
{
Complex c(1,1),c1;
double m;
c.Display();
cout
cin>>m;
c=c-m;
c.Display();
return 0;
}
运行结果：
2. 程序代码：
/*2、定义点类Point ，重载运算符" ＋" 、" －" 、" ＝＝" 、" ！="、"++"、"--" 、">>"、"
//#include
#include
//using std::cin; //用#include加上Using std::cin;using
// std::cout;using std::endl;对重载流插入、流提取运算符错误
//using std::cout;
//using std::endl;
//using namespace std;
class Point //定义point 类
{
private:
double x;
double y;
static int count;
public:
Point()
{
x=0;y=0;
}
void Input();
void Display();
Point operator+(Point &b);
Point operator-(Point &b);
friend int operator==(Point &a,Point &b);
friend int operator!=(Point &a,Point &b);
friend Point operator++(Point &a);
friend Point operator++(Point &a,int);
friend Point operator--(Point &a);
friend Point operator--(Point &a,int);
friend istream & operator>>(istream & input,Point & a);
friend ostream & operator
};
int Point::count=0; //注意赋值时没有static," int static Point::count=0; " wrong!!
void Point::Input()
{
cout
cout
cin>>x>>y;
count++;
}
void Point::Display()
{
cout
cout
}
Point Point::operator+(Point &b) //重载“+”为成员函数
{
Point p;
p.x=x+b.x;
p.y=y+b.y;
return p;
}
Point Point::operator-(Point &b) //重载“-”为成员函数
{
Point p;
p.x=x-b.x;
p.y=y-b.y;
return p;
}
int operator==(Point &a,Point &b) //重载“==”为友员函数
{
if(a.x!=b.x)
return 0;
else if(a.y!=b.y)
return 0;
else
return 1;
}
int operator!=(Point &a,Point &b) //重载“!=”为友员函数
{
if(a.x==b.x&&a.y==b.y)
return 0;
else return 1;
}
Point operator++(Point &a)
{
Point p;
p.x=++a.x;
p.y=++a.y;
return p;
}
Point operator++(Point &a,int)
{
Point c;
c.x=a.x;
c.y=a.y;
a.x++;
a.y++;
return c;
}
Point operator--(Point &a)
{
Point p;
p.x=-a.x;
p.y=--a.y;
return p;
}
Point operator--(Point &a,int)
{
Point c;
c.x=a.x;
c.y=a.y;
a.x--;
a.y--; //重载“++”为友员函数 //重载“++”为友员函数 //重载“--”为友员函数 //重载“--”为友员函数
return c;
}
istream & operator>>(istream & input,Point & a) //重载流插入运算符
{
input>>a.x>>a.y;
return input;
}
ostream & operator
{
outputreturn output;
}
int main()
{
Point a,b;
a.Input();
a.Display();
b.Input();
b.Display();
a=a+b;
couta=a-b;
coutcout>'输入输出："
cout
cin>>a;
coutcoutcout
cin>>b;
cout
cout
cout
if(a==b)
cout
else if(a!=b)
cout
return 0;
}
运行结果： //主函数
程序代码：/*3、定义一个矩阵类Matrix ，均为M 行N 列，通过重载运算符"+"、"-" ，">","++","--"，
"=="，" ！="来实现矩阵的相加、相减、输出、输入、自增、自减以及相等、不等的判断。*/
#include
using namespace std;
const int M=3;
const int N=3;
class Matrix
{
private:
int X[M][N];
public:
friend Matrix operator+(Matrix a[][N],Matrix b[][N]);
friend Matrix operator-(Matrix &a,Matrix &b);
friend istream & operator>>(istream & input,Matrix &c);
friend ostream & operator
friend Matrix operator++(Matrix &c);
friend Matrix operator--(Matrix &c);
friend int operator==(Matrix &a,Matrix &b);
friend int operator!=(Matrix &a,Matrix &b);
};
Matrix operator+(Matrix a[][N],Matrix b[][N])
{
int i,j;
Matrix c[M][N];
for(i=0;i
for(j=0;j
{
c[i][j]=a[i][j]+b[i][j];
}
return c[M][N];
}
Matrix operator-(Matrix *a,Matrix *b)
{
int i,j;
Matrix c[M][N];
for(i=0;i
for(j=0;j
{
c[i][j]=a[i][j]-b[i][j];
}
return c[M][N];
}
istream & operator>>(istream & input,Matrix *c)
{
int i,j;
for(i=0;i
for(j=0;j
input>>c[i][j];
}
ostream & operator
{
int i,j;
for(i=0;i
for(j=0;j
output
}
Matrix operator++(Matrix *c)
{
int i,j;
for(i=0;i
for(j=0;j
++c[i][j];
return c[M][N];
}
Matrix operator--(Matrix *c)
{
int i,j;
for(i=0;i
for(j=0;j
--c[i][j];
return c[M][N];
}
int operator==(Matrix *a,Matrix *b)
{
int i,j;
for(i=0;i
for(j=0;j
{
if(a[i][j]!=b[i][j])
return 0;
}
return 1;
}
int operator!=(Matrix *a,Matrix *b)
{
int i,j;
for(i=0;i
for(j=0;j
{
if(a[i][j]!=b[i][j])
return 1;
}
return 0;
}
int main()
{
Matrix a[M][N],b[M][N],c[M][N];
cout>"
cin>>a;
cin>>b;
coutcout
cout
c[M][N]=a[M][N]+[M][N];
cout
c[M][N]=a[M][N]-[M][N];
cout
cout
if(a[M][N]==b[M][N])
cout
else
cout
if(a[M][N]!=b[M][N])
cout
else
cout
return 0;
}
4. 程序代码：/*4、定义时间类Time ，时间的表示采用24小时制。重载运算符">"实现时间的输出和输入；
重载运算符"+"和"-" 实现时间推后和提前若干分钟；重载运算符"++"和"--" 实现当前时间推后和提前1小时；
重载">"、"
#include
//using namespace std;
class Time //Define class Time
{
private:
int hour,minute,second;
public:
Time operator--();
Time operator++();
Time operator+(int n);
Time operator-(int n);
friend istream & operator>>(istream & Input,Time & t);
friend ostream & operator
friend int operator
friend int operator>(Time &a,Time &b);
friend int operator==(Time &a,Time &b);
};
istream & operator>>(istream & Input,Time & t) //Overload " >> "
{
//Make sure hour,minute,second right.
Input>>t.hour>>t.minute>>t.second;
while(1)
{
if(t.hour>24||t.hour60||t.minute60||t.second
{
cout
Input>>t.hour>>t.minute>>t.second;
}
if(t.hour0&&t.minute0&&t.second0) break;
}
return Input;
}
ostream & operator
{
Output
return Output;
}
Time Time::operator+(int n) //Overload " + "
{
Time t;
t.hour=hour;
t.minute=minute+n;
t.second=second;
return t;
}
Time Time::operator-(int n)
{
Time t;
t.minute=minute-n;
t.hour=hour;
t.second=second;
return t;
}
Time Time::operator++()
{
Time t;
t.minute=minute;
t.second=second;
++hour;
t.hour=hour;
return t;
}
Time Time::operator--()
{
Time t;
t.minute=minute;
t.second=second;
--hour;
t.hour=hour;
return t;
}
int operator
{
if(a.hour
return 1; //Overload " - " //Overload " ++ " //Overload " -- " //Overload "
else if(a.hour==b.hour&&a.minute
return 1;
else if(a.hour==b.hour&&a.minute==b.minute&&a.second
return 1;
else
return 0;
}
int operator>(Time &a,Time &b) //Overload " > "
{
if(a.hour>b.hour)
return 1;
else if(a.hour==b.hour&&a.minute>b.minute)
return 1;
else if(a.hour==b.hour&&a.minute==b.minute&&a.second>b.second)
return 1;
else
return 0;
}
int operator==(Time &a,Time &b) //Overload " == "
{
if(a.hour!=b.hour)
return 0;
else
if(a.minute!=b.minute)
return 0;
else
if(a.second!=b.second)
return 0;
else return 1;
}
int main()
{
Time t,t0;
cout
cin>>t;
cout
cout
cout
cout
t=t+20;
cout
cout
t=t-10;
cout
cout
++t;
cout
cout
--t;
cout
cout
cin>>t0;
cout
cout
cout
if(t==t0)
cout
else
if(t>t0)
coutt0"
else
cout
return 0;
}
运行结果：
程序代码：/*5、编写一个程序，处理一个复数与一个double 型数相加的运算，结果存放在一个double 型的变量d1中，
输出d1的值，再以复数形式输出此值。定义复数（Complex ）类，在成员函数中包含重载类型转换运算符：
Operator double（）{ return real；}*/
#include
//using namespace std;
class Complex //Define class Complex
{
private:
double real,imag;
public:
double Complex::operator+(double a);
friend ostream & operator
friend istream & operator>>(istream & input,Complex & a);
Complex() //构造函数
{
real=10;
imag=10;
}
Complex(double a) //定义转换构造函数
{
real=a;imag=0;
}
};
double Complex::operator+(double a) // 重载类型转换符“+”
{
double b;
b=a+real;
return b;
}
ostream & operator
{
outputreturn output;
}
istream & operator>>(istream & input,Complex &a) //重载“ >>”
{
input>>a.real>>a.imag;
return input;
}
int main() // 主函数
{
Complex s;
double a,d1;
cout
cout>a):";
cin>>a;
d1=s+a;
cout
s=d1;
cout
return 0;
}
运行结果：
程序代码：/*6、定义一个教师类和一个学生类，二者有一部分数据成员是相同的，例如num ，name ，sex 。
请编程，将一个学生类对象转换为教师类，只将以上3个相同的数据成员移植过去。可以设想为：
一位学生大学毕业了，留校担任教师，他原有的部分数据对现在的教师身份来说仍然是有用的，
应当保留并成为其教师的数据的一部分。*/
#include
#include
#include
using namespace std;
class Teacher;
class Student //定义学生类
{
private:
string num,name;
string sex;
public:
void Input();
void Display();
friend class Teacher;
friend Teacher Teacher::operator=(Student & s);
};
class Teacher //定义教师类
{
private:
string number,na;
string s;
public:
void Input();
void Display();
Teacher operator=(Student & s);
};
void Student::Input()
{
cout
cin>>num>>name>>sex;
}
void Student::Display()
{
cout
cout
void Teacher::Input()
{
cout>number>>na>>s;
}
void Teacher::Display()
{
cout
cout
Teacher Teacher::operator=(Student &s)
{
number=s.num;
na=s.name;
s=s.sex;
}
int main()
{
Student s;
Teacher t;
s.Input();
s.Display();
t=s;
t.Display();
return 0;
}
五． 实验总结
实验五 运算符重载的应用
班级：B135A2学号： 201322688 姓名： 杨弘 成绩：
一． 实验目的
1、理解运算符重载的作用；
2、掌握运算符重载的两种方法；
3、掌握单目、双目运算符的重载；
二． 使用的设备和仪器
计算机+Windows XP +Visual C++6.0
三． 实验内容及要求
1、定义一个复数类Complex ，重载运算符“-”，使之能用于复数与实数的减法运算。参加运算的两个操作数一个是类的对象，一个是实数，顺序任意。例如：i-c ，c-i 均合法（其中，c 为复数类的对象，i 为实数）。
减法规则：复数实部与实数相减，复数虚部不变。
2、定义点类Point ，重载运算符“＋”、“－”、“＝＝”、“！=”、“++”、“--”、“>>”、“
3、定义一个矩阵类Matrix ，均为M 行N 列，通过重载运算符“+”、“-”，“>”, “++”, “--”，“==”，“！=”来实现矩阵的相加、相减、输出、输入、自增、自减以及相等、不等的判断。
4、定义时间类Time ，时间的表示采用24小时制。重载运算符“>”实现时间的输出和输入；重载运算符“+”和“-”实现时间推后和提前若干分钟；重载运算符“++”和“--”实现当前时间推后和提前1小时；重载“>”、“
注意：输入时需对数据合法性进行判断。
5、编写一个程序，处理一个复数与一个double 型数相加的运算，结果存放在一个double 型的变量d1中，输出d1的值，再以复数形式输出此值。定义复数（Complex ）类，在成员函数中包含重载类型转换运算符：
Operator double（）{ return real；}
6、定义一个教师类和一个学生类，二者有一部分数据成员是相同的，例如num ，name ，sex 。请编程，将一个学生类对象转换为教师类，只将以上3个相同的数据成员移植过去。可以设想为：一位学生大学毕业了，留校担任教师，他原有的部分数据对现在的教师身份来说仍然是有用的，应当保留并成为其教师的数据的一部分。
四． 实验步骤
1. 程序代码：/*1、定义一个复数类Complex ，重载运算符"-" ，使之能用于复数与实数的减
法运算。参加运算的两个操作数一个是类的对象，一个是实数，顺序任意。
例如：i-c ，c-i 均合法（其中，c 为复数类的对象，i 为实数）。
减法规则：复数实部与实数相减，复数虚部不变。*/
#include //#include
using std::cin;
using std::cout;
using std::endl;
//using namespace std;
class Complex //定义复数类
{
private:
double real,imag;
public:
Complex()
{
real=0;
imag=0;
}
Complex(double a,double b)
{
real=a;
imag=b;
}
void Display();
void Input();
friend Complex operator-(Complex &a,double b);
friend Complex operator-(double b,Complex &a);
};
Complex operator-(Complex &a,double b) //定义“-”重载函数
{
return Complex(a.real-=b,a.imag);
}
Complex operator-(double b,Complex &a)
{
return Complex(a.real-=b,a.imag);
}
void Complex::Input()
{
cout
cout
cin>>real>>imag;
}
void Complex::Display()
{
cout
cout
}
int main() //主函数
{
Complex c(1,1),c1;
double m;
c.Display();
cout
cin>>m;
c=c-m;
c.Display();
return 0;
}
运行结果：
2. 程序代码：
/*2、定义点类Point ，重载运算符" ＋" 、" －" 、" ＝＝" 、" ！="、"++"、"--" 、">>"、"
//#include
#include
//using std::cin; //用#include加上Using std::cin;using
// std::cout;using std::endl;对重载流插入、流提取运算符错误
//using std::cout;
//using std::endl;
//using namespace std;
class Point //定义point 类
{
private:
double x;
double y;
static int count;
public:
Point()
{
x=0;y=0;
}
void Input();
void Display();
Point operator+(Point &b);
Point operator-(Point &b);
friend int operator==(Point &a,Point &b);
friend int operator!=(Point &a,Point &b);
friend Point operator++(Point &a);
friend Point operator++(Point &a,int);
friend Point operator--(Point &a);
friend Point operator--(Point &a,int);
friend istream & operator>>(istream & input,Point & a);
friend ostream & operator
};
int Point::count=0; //注意赋值时没有static," int static Point::count=0; " wrong!!
void Point::Input()
{
cout
cout
cin>>x>>y;
count++;
}
void Point::Display()
{
cout
cout
}
Point Point::operator+(Point &b) //重载“+”为成员函数
{
Point p;
p.x=x+b.x;
p.y=y+b.y;
return p;
}
Point Point::operator-(Point &b) //重载“-”为成员函数
{
Point p;
p.x=x-b.x;
p.y=y-b.y;
return p;
}
int operator==(Point &a,Point &b) //重载“==”为友员函数
{
if(a.x!=b.x)
return 0;
else if(a.y!=b.y)
return 0;
else
return 1;
}
int operator!=(Point &a,Point &b) //重载“!=”为友员函数
{
if(a.x==b.x&&a.y==b.y)
return 0;
else return 1;
}
Point operator++(Point &a)
{
Point p;
p.x=++a.x;
p.y=++a.y;
return p;
}
Point operator++(Point &a,int)
{
Point c;
c.x=a.x;
c.y=a.y;
a.x++;
a.y++;
return c;
}
Point operator--(Point &a)
{
Point p;
p.x=-a.x;
p.y=--a.y;
return p;
}
Point operator--(Point &a,int)
{
Point c;
c.x=a.x;
c.y=a.y;
a.x--;
a.y--; //重载“++”为友员函数 //重载“++”为友员函数 //重载“--”为友员函数 //重载“--”为友员函数
return c;
}
istream & operator>>(istream & input,Point & a) //重载流插入运算符
{
input>>a.x>>a.y;
return input;
}
ostream & operator
{
outputreturn output;
}
int main()
{
Point a,b;
a.Input();
a.Display();
b.Input();
b.Display();
a=a+b;
couta=a-b;
coutcout>'输入输出："
cout
cin>>a;
coutcoutcout
cin>>b;
cout
cout
cout
if(a==b)
cout
else if(a!=b)
cout
return 0;
}
运行结果： //主函数
程序代码：/*3、定义一个矩阵类Matrix ，均为M 行N 列，通过重载运算符"+"、"-" ，">","++","--"，
"=="，" ！="来实现矩阵的相加、相减、输出、输入、自增、自减以及相等、不等的判断。*/
#include
using namespace std;
const int M=3;
const int N=3;
class Matrix
{
private:
int X[M][N];
public:
friend Matrix operator+(Matrix a[][N],Matrix b[][N]);
friend Matrix operator-(Matrix &a,Matrix &b);
friend istream & operator>>(istream & input,Matrix &c);
friend ostream & operator
friend Matrix operator++(Matrix &c);
friend Matrix operator--(Matrix &c);
friend int operator==(Matrix &a,Matrix &b);
friend int operator!=(Matrix &a,Matrix &b);
};
Matrix operator+(Matrix a[][N],Matrix b[][N])
{
int i,j;
Matrix c[M][N];
for(i=0;i
for(j=0;j
{
c[i][j]=a[i][j]+b[i][j];
}
return c[M][N];
}
Matrix operator-(Matrix *a,Matrix *b)
{
int i,j;
Matrix c[M][N];
for(i=0;i
for(j=0;j
{
c[i][j]=a[i][j]-b[i][j];
}
return c[M][N];
}
istream & operator>>(istream & input,Matrix *c)
{
int i,j;
for(i=0;i
for(j=0;j
input>>c[i][j];
}
ostream & operator
{
int i,j;
for(i=0;i
for(j=0;j
output
}
Matrix operator++(Matrix *c)
{
int i,j;
for(i=0;i
for(j=0;j
++c[i][j];
return c[M][N];
}
Matrix operator--(Matrix *c)
{
int i,j;
for(i=0;i
for(j=0;j
--c[i][j];
return c[M][N];
}
int operator==(Matrix *a,Matrix *b)
{
int i,j;
for(i=0;i
for(j=0;j
{
if(a[i][j]!=b[i][j])
return 0;
}
return 1;
}
int operator!=(Matrix *a,Matrix *b)
{
int i,j;
for(i=0;i
for(j=0;j
{
if(a[i][j]!=b[i][j])
return 1;
}
return 0;
}
int main()
{
Matrix a[M][N],b[M][N],c[M][N];
cout>"
cin>>a;
cin>>b;
coutcout
cout
c[M][N]=a[M][N]+[M][N];
cout
c[M][N]=a[M][N]-[M][N];
cout
cout
if(a[M][N]==b[M][N])
cout
else
cout
if(a[M][N]!=b[M][N])
cout
else
cout
return 0;
}
4. 程序代码：/*4、定义时间类Time ，时间的表示采用24小时制。重载运算符">"实现时间的输出和输入；
重载运算符"+"和"-" 实现时间推后和提前若干分钟；重载运算符"++"和"--" 实现当前时间推后和提前1小时；
重载">"、"
#include
//using namespace std;
class Time //Define class Time
{
private:
int hour,minute,second;
public:
Time operator--();
Time operator++();
Time operator+(int n);
Time operator-(int n);
friend istream & operator>>(istream & Input,Time & t);
friend ostream & operator
friend int operator
friend int operator>(Time &a,Time &b);
friend int operator==(Time &a,Time &b);
};
istream & operator>>(istream & Input,Time & t) //Overload " >> "
{
//Make sure hour,minute,second right.
Input>>t.hour>>t.minute>>t.second;
while(1)
{
if(t.hour>24||t.hour60||t.minute60||t.second
{
cout
Input>>t.hour>>t.minute>>t.second;
}
if(t.hour0&&t.minute0&&t.second0) break;
}
return Input;
}
ostream & operator
{
Output
return Output;
}
Time Time::operator+(int n) //Overload " + "
{
Time t;
t.hour=hour;
t.minute=minute+n;
t.second=second;
return t;
}
Time Time::operator-(int n)
{
Time t;
t.minute=minute-n;
t.hour=hour;
t.second=second;
return t;
}
Time Time::operator++()
{
Time t;
t.minute=minute;
t.second=second;
++hour;
t.hour=hour;
return t;
}
Time Time::operator--()
{
Time t;
t.minute=minute;
t.second=second;
--hour;
t.hour=hour;
return t;
}
int operator
{
if(a.hour
return 1; //Overload " - " //Overload " ++ " //Overload " -- " //Overload "
else if(a.hour==b.hour&&a.minute
return 1;
else if(a.hour==b.hour&&a.minute==b.minute&&a.second
return 1;
else
return 0;
}
int operator>(Time &a,Time &b) //Overload " > "
{
if(a.hour>b.hour)
return 1;
else if(a.hour==b.hour&&a.minute>b.minute)
return 1;
else if(a.hour==b.hour&&a.minute==b.minute&&a.second>b.second)
return 1;
else
return 0;
}
int operator==(Time &a,Time &b) //Overload " == "
{
if(a.hour!=b.hour)
return 0;
else
if(a.minute!=b.minute)
return 0;
else
if(a.second!=b.second)
return 0;
else return 1;
}
int main()
{
Time t,t0;
cout
cin>>t;
cout
cout
cout
cout
t=t+20;
cout
cout
t=t-10;
cout
cout
++t;
cout
cout
--t;
cout
cout
cin>>t0;
cout
cout
cout
if(t==t0)
cout
else
if(t>t0)
coutt0"
else
cout
return 0;
}
运行结果：
程序代码：/*5、编写一个程序，处理一个复数与一个double 型数相加的运算，结果存放在一个double 型的变量d1中，
输出d1的值，再以复数形式输出此值。定义复数（Complex ）类，在成员函数中包含重载类型转换运算符：
Operator double（）{ return real；}*/
#include
//using namespace std;
class Complex //Define class Complex
{
private:
double real,imag;
public:
double Complex::operator+(double a);
friend ostream & operator
friend istream & operator>>(istream & input,Complex & a);
Complex() //构造函数
{
real=10;
imag=10;
}
Complex(double a) //定义转换构造函数
{
real=a;imag=0;
}
};
double Complex::operator+(double a) // 重载类型转换符“+”
{
double b;
b=a+real;
return b;
}
ostream & operator
{
outputreturn output;
}
istream & operator>>(istream & input,Complex &a) //重载“ >>”
{
input>>a.real>>a.imag;
return input;
}
int main() // 主函数
{
Complex s;
double a,d1;
cout
cout>a):";
cin>>a;
d1=s+a;
cout
s=d1;
cout
return 0;
}
运行结果：
程序代码：/*6、定义一个教师类和一个学生类，二者有一部分数据成员是相同的，例如num ，name ，sex 。
请编程，将一个学生类对象转换为教师类，只将以上3个相同的数据成员移植过去。可以设想为：
一位学生大学毕业了，留校担任教师，他原有的部分数据对现在的教师身份来说仍然是有用的，
应当保留并成为其教师的数据的一部分。*/
#include
#include
#include
using namespace std;
class Teacher;
class Student //定义学生类
{
private:
string num,name;
string sex;
public:
void Input();
void Display();
friend class Teacher;
friend Teacher Teacher::operator=(Student & s);
};
class Teacher //定义教师类
{
private:
string number,na;
string s;
public:
void Input();
void Display();
Teacher operator=(Student & s);
};
void Student::Input()
{
cout
cin>>num>>name>>sex;
}
void Student::Display()
{
cout
cout
void Teacher::Input()
{
cout>number>>na>>s;
}
void Teacher::Display()
{
cout
cout
Teacher Teacher::operator=(Student &s)
{
number=s.num;
na=s.name;
s=s.sex;
}
int main()
{
Student s;
Teacher t;
s.Input();
s.Display();
t=s;
t.Display();
return 0;
}
五． 实验总结