实验五 运算符重载 完成
实验五运算符重载的应用
班级：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
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 // 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<<(ostream & output,Point & a); }; int Point::count=0; //注意赋值时没有static," int static Point::count=0; " wrong!! void Point::Input() { cout<<"******输入******"< cout<<"请输入点坐标（x,y）"; 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<<(ostream & output,Point & a) //重载流插入运算符{ output<<"("< return output; } int main() //主函数 { Point a,b; a.Input(); a.Display(); b.Input(); b.Display(); a=a+b; cout<<"Overload'+'----a=a+b:"< a=a-b; cout<<"Overload'-'----a=a-b:"< cout<<"重新用'<<','>>'输入输出："< cout<<"输入a的坐标："; cin>>a; cout<<"显示< cout< cout<<"输入b的坐标："; cin>>b; cout<<"显示< cout< cout<<"********Overload '==' and '!='"< if(a==b) cout<<"a==b"< else if(a!=b) cout<<"a!=b"< 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<<(istream & output,Matrix &c); 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<<(istream & output,Matrix *c) { 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; cout<<"Display(a):"< cout<<"Display:(b)"< cout<<"Overload + and -:"< c[M][N]=a[M][N]+[M][N]; cout<<"Display(a):"< c[M][N]=a[M][N]-[M][N]; cout<<"Display:(b)"< cout<<"Overload == and !=:"< if(a[M][N]==b[M][N]) cout<<"a[M][N]==b[M][N]"< cout<<"a[M][N]!=b[M][N]"< cout<<"a[M][N]!=b[M][N]"< else cout<<"a[M][N]==b[M][N]"< 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<<(ostream & Output,Time & t); friend int operator<(Time &a,Time &b); 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.hour<0||t.minute>60||t.minute<0||t.second>60||t.second<0) { cout<<"Wrong!! Please enter again!!"< Input>>t.hour>>t.minute>>t.second; } if(t.hour<24&&t.hour>0&&t.minute<60&&t.minute>0&&t.second<60||t.second>0) break; } return Input; } ostream & operator<<(ostream & Output,Time & t) //Overload " << " { 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) //Overload " - " { Time t; t.minute=minute-n; t.hour=hour; t.second=second; return t; } Time Time::operator++() //Overload " ++ " { Time t; t.minute=minute; t.second=second; ++hour; t.hour=hour; return t; } Time Time::operator--() //Overload " -- " { Time t; t.minute=minute; t.second=second; --hour; t.hour=hour; return t; } int operator<(Time &a,Time &b) //Overload " < " { if(a.hour return 1; else if(a.hour==b.hour&&a.minute return 1; else if(a.hour==b.hour&&a.minute==b.minute&&a.second 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<<"Please enter Time t（hour，minute，second）："; cin>>t; cout<<"*******Display********"< cout<<"Time: "< cout<<"*******Operator*******"< cout<<"Add 20 minutes: "; t=t+20; cout< cout<<"Minus 10 minutes: "; t=t-10; cout< cout<<"Add 1 hour: "; ++t; cout< cout<<"Minus 1 hour: "; --t; cout< cout<<"Please enter Time t0（hour，minute，second）："; cin>>t0; cout<<"*******Display********"< cout<<"Time: "< cout<<"*******Compare********"< if(t==t0) cout<<"t==t0"< else if(t>t0) cout<<"t>t0"< else cout<<"t 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<<(ostream & output,Complex & a); 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<<(ostream & output,Complex &a) //重载“<<”{ output< return output; } istream & operator>>(istream & input,Complex &a) //重载“>>”{ input>>a.real>>a.imag; return input; } int main() // 主函数 { Complex s; double a,d1; cout<<"Complex: "< cout<<"Please enter a double number(>>a):"; cin>>a; d1=s+a; cout<<"d1= "< s=d1; cout<<"After s=d1 : "< 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<<"对学生信息进行输入（学号、姓名、性别(f 或m)）："; cin>>num>>name>>sex; } void Student::Display() { cout<<"对学生信息进行输出:"< cout< cout< } void Teacher::Input() { cout<<"对教师信息进行输入（学号、姓名、性别(f 或m)）："; cin>>number>>na>>s; } void Teacher::Display() { cout<<"对教师信息进行输出:"< cout< cout< } Teacher Teacher::operator=(Student &s) { number=s.num; na=https://www.wendangku.net/doc/fc14516957.html,; s=s.sex; } int main() { Student s; Teacher t; s.Input(); s.Display(); t=s; t.Display(); return 0; } 五．实验总结 C++习题参考答案 第1章面向对象程序设计概论 一、名词解释 抽象封装消息 【问题解答】 面向对象方法中的抽象是指对具体问题（对象）进行概括，抽出一类对象的公共性质并加以描述的过程。 面向对象方法中的封装就是把抽象出来的对象的属性和行为结合成一个独立的单位，并尽可能隐蔽对象的内部细节。 消息是面向对象程序设计用来描述对象之间通信的机制。一个消息就是一个对象要求另一个对象实施某种制作的一个请求。 二、填空题 （1）目前有面向过程的结构化程序设计方法和面向对象的程序设计方法两种重要的程序设计方法。 （2）结构化程序设计方法中的模块由顺序、选择和循环3种基本结构组成。（3）在结构化程序设计方法中，程序可表示为程序=数据结构+算法。而面向对象的程序设计方法，程序可表示为程序=对象+消息。 （4）结构化程序设计方法中的基本模块是过程。而面向对象程序设计方法中的基本模块是类。 （5）面向对象程序设计方法具有抽象性、封装性、继承性和多态性等特点。 三、选择题（至少选一个，可以多选） （1）面向对象程序设计着重于（ B ）的设计。 A. 对象 B. 类 C. 算法 D. 数据 （2）面向对象程序设计中，把对象的属性和行为组织在同一个模块内的机制叫做（ C ）。 A. 抽象 B. 继承 C. 封装 D. 多态 （3）在面向对象程序设计中，类通过（ D ）与外界发生关系。 A. 对象 B. 类 C. 消息 D. 接口 （4）面向对象程序设计中，对象与对象之间的通信机制是（ C ）。 A. 对象 B. 类 C. 消息 D. 接口 （5）关于C++与C语言的关系的描述中，（ D ）是不对的。 A. C语言是C++的一个子集 B. C语言与C++是兼容的 C. C++对C语言进行了一些改进 D. C++和C语言都是面向对象的 【结果分析】 C语言是面向过程的。C++语言是一种经过改进的更为优化的C语言，是一种混合型语言，既面向过程也面向对象。 （6）面向对象的程序设计将数据结构与（ A ）放在一起，作为一个相互依存、不可分割的整体来处理。 A. 算法 B. 信息 C. 数据隐藏 D. 数据抽象 （7）下面（ A ）不是面向对象系统所包含的要素。 A. 重载 B. 对象 C. 类 D. 继承 【结果分析】 运算符重载基础概念练习题 1、下列运算符中, （）运算符在C++中不能重载。 A = B () C :: D delete 2、下列运算符中, （）运算符在C++中不能重载。 A ?: B [] C new D && 3、下列关于C++运算符函数的返回类型的描述中,错误的是（）。 A 可以是类类型 B 可以是int类型 C 可以是void类型 D 可以是float类型 4、下列运算符不能用友元函数重载的是（）。 A + B = C * D << 5、在重载运算符函数时,下面（）运算符必须重载为类成员函数形式。 A + B - C ++ D -> 6、下列关于运算符重载的描述中,正确的是（）。 A 运算符重载可以改变运算符的操作数的个数 B 运算符重载可以改变优先级 C 运算符重载可以改变结合性 D 运算符重载不可以改变语法结构 7、友元运算符obj>obj2被C++编译器解释为（）。 A operator>(obj1,obj2) B >(obj1,obj2) C obj2.operator>(obj1) D obj1.oprator>(obj2) 8、在表达式x+y*z中，+是作为成员函数重载的运算符，*是作为非成员函数重载的运算符。下列叙述中正确的是（）。 A operator+有两个参数，operator*有两个参数 B operator+有两个参数，operator*有一个参数 C operator+有一个参数，operator*有两个参数 D operator+有一个参数，operator*有一个参数 9、重载赋值操作符时,应声明为（）函数。 A 友元 B 虚 C 成员 D 多态 10、在一个类中可以对一个操作符进行（）重载。 A 1种 B 2种以下 C 3种以下 D 多种 11、在重载一个运算符时，其参数表中没有任何参数，这表明该运算符是（）。 实验十三 1．实验目的 通过本次实验 （1）理解友元函数与运算符重载函数的概念； （2）学会友元函数的定义与使用方法； （3）掌握运算符重载函数的定义与使用方法； 2．实验要求 （1）编写实验程序 （2）在VC++运行环境中，输入源程序 （3）编译运行源程序 （4）输入测试数据进行程序测试； （5）写出运行结果。 3．实验内容 （1）定义一个复数类，重载“-=”运算符，使这个运算符能直接完成复数的“-=”运算。分别用成员函数与友元函数编写运算符重载函数。在主函数中定义复数对象c1(10,20)、c2(15,30)，进行c2-=c1的复数运算，并输出c1、c2的复数值。 参考资料： （1）成员函数 # include 实验五运算符重载 【实验目的】 1.进一步了解运算符重载的概念和使用方法。 2.掌握几种常用的运算符重载的方法。 3.了解转换构造函数的使用方法。 4.了解在Visual C++6.0环境下进行运算符重载要注意的问题. 【实验要求】 1.硬件基本配置：Intel PentiumIII以上级别的CPU，大于64MB的内存。 2.软件要求：Window 2000操作系统，Visual Studio 6.0或更高版本开发环境。 3.实验学时：2学时 4.实现实验内容中的题目。 5.写实验报告 【实验内容】 (1)声明一个复数类Complex，重载运算符“+’’，“一”，“*”，“/”使之能用于复数的加、减、乘、除.运算符重载函数作为Complex类的成员函数，重载流提取运算符实现对复数的输出。编程序，分别求两个复数之和、差、积和商并用重载后的流运算符进行输出。 请思考:你编的程序能否用于一个整数与一个复数的算术运算?如4+ (5-2i). (2)声明一个复数类Complex,重载运算符“+“，使之能用于复数的加法运算。 参加运算的两个运算量可以都是类对象.也可以其中有一个是整数，顺序任意。例如， cl+c2， i+cl，cl+i均合法(设i为整数，c1, c2为复数)。 运行程序.分别求两个复数之和、整数和复数之和。 (3)有两个矩阵a和b，均为2行3列。求两个矩阵之和。重载运算符“+”，使之能用于矩阵相加。如c=a+b。重载流提取运算符实现对矩阵的输出如：cout< Task8-1 /* 1. 定义一个复数类Complex，重载运算符“+”，使之能用于复数的加法运算。将运算符函数重载为非成员、非友元的普通函数。编写程序，求两个复数之和*/ #include 运行结果为： 30,30 Press any key to continue 2）分析下面程序,指出程序运行的结果: #include . 《面向对象程序设计》习题 班级：学号：姓名：名单序号：成绩： 第7章运算符重载和多态性 一、选择题（共30分，每题1分） 1．下列运算符中，（）运算符在C++中不能重载。 A.?: B.[] C. new D.++ 2．友元重载运算符obj1>obj2被C++编译器解释为（）。 A．operator >(obj1,obj2) B．>(obj1,obj2) C．obj2.operator >(obj1) D．obj1.operator >(obj2) 3．重载赋值操作符时，应声明为（）函数。 A．友元B．虚C．成员D．多态 4．在重载一个运算符时，其参数表中没有任何参数，这表明该运算符是（）。 A. 作为友元函数重载的1元运算符 B. 作为成员函数重载的1元运算符 C. 作为友元函数重载的2元运算符 D. 作为成员函数重载的2元运算符5．在重载一运算符时，若运算符函数的形参表中没有参数，则不可能的情况是（）。 A. 该运算符是一个单目运算符。 B. 该运算符函数有一个隐含的参数this。 C. 该运算符函数是类的成员函数。 D. 该运算符函数是类的友元函数。 6. 关于运输符重载，下列表述中正确的是（）。 A．C++已有的任何运算符都可以重载 B．运算符函数的返回类型不能声明为基本数据类型 . C．在类型转换符函数的定义中不需要声明返回类型 D．可以通过运算符重载来创建C++中原来没有的运算符 7. C ++流中重载的运算符>>是一个（）。 A. 用于输出操作的非成员函数 B. 用于输出操作的成员函数 C. 用于输入操作的非成员函数 D. 用于输入操作的成员函数 8. 若要对Data类中重载的加法运算符成员函数进行声明，下列选项中正确的是（）。 A. Data +(Data); B. Data operator+(Data); C. Data +operator(Data); D. operator +(Data, Data); 9. 下列运算符中哪些是不能够被重载的（）。 A. .，.*，sizeof，：：，?: B. ++，--，new，= = C. new，delete，>=，[ ] D. +，-，=，delete 10. 在名为BigNumber类的类体中对运算符函数double进行如下声明： operator double(BigNumbe); 函数声明中有一个明显的错误，这个错误就是（）。 A．参数表中不应该有任何参数 B．缺少对函数返回类型的说明 C．参数声明中缺少参数变量 D．函数声明中缺少函数体 11. 下列关于运算符重载的描述中，正确的是（）。 A. 运算符重载成为成员函数时，若参数表中无参数，重载是一元运算符 B. 一元运算符只能作为成员函数重载 C. 二元运算符重载成为非成员函数时，参数表中有一个参数 实验五运算符重载、继承 ●实验目的 1、了解类的两种使用方式。 2、学习从现有类派生出新类的方式。 3、了解在派生类中如何使用基类的成员。 4、了解基类成员在派生类中的访问控制。 5、掌握运算符重载的方法。 ●实验内容 1、从类Person中派生出一个教师类，新增的属性有专业（Specialty）、职称（Position）和主讲课程（MajorCourse，一门），并为这些属性定义相应的方法。 [实现要求] Person类的设计如下，请将空白处补充完整。 class Person { string Name; int Age; string Sex; public: void Register(char *name,int age,char *sex) { ; Age=age; Sex=sex; } string GetName() { } string GetSex() { return Sex; } int GetAge() { } void ShowMe() { cout< //带参数的构造函数去初始化各个成员的值，使其显示运行结果的第一行t.TeacherRegister("张三",40, "f","计算机","副教授","C++"); t.ShowMe(); return 0; } 运行结果如下： XXX m 0 XXX XXX XXX 张三 f 40 计算机副教授C++ [思考问题] ①在Teacher类中是否要需要重新定义ShowMe成员函数？不重新定义ShowMe成员函数能否得到上述要求的运行结果？为什么？ 2、从Point类中派生出一个Line类。Line类增加一个数据成员EndPoint，计算线的长度。 [实现提示] Point类可以按下面方式进行设计： class Point{ int x,y; public: Point(int a=0,int b=0){SetPoint(a,b);} void SetPoint(int a,int b); //设置点的坐标值 int GetX(){return x;} int GetY(){return y;} void Print(); //显示点的坐标值 }; Line类增加一个数据成员EndPoint为Point类对象，注意在设计Line类的构造函数时应为其基类和对象成员EndPoint提供形参。 为了检验Line类的功能，主函数按如下方式设计： int main(){ Line line(1,1,10,10); cout<<"Line line:"; line.Print(); cout<<"\n线line的长度："; cout< 实验十六运算符重载 一、实验目的 1、理解运算符重载作用和意义； 2、掌握类运算符和友元运算符重载的定义和使用； 3、掌握常用运算符(++、--、+、-、*、/、=、+=、-=、*=、/=、<<（插入）、>>（提取）)的重载。 二、实验内容 1、下列程序定义了一个复数类，重载"+"运算符以实现复数的加法运算。 #include 运算符重载复习题 1. 重载赋值操作符时,应声明为( ) A. 友元函数 B. 虚函数 C. 成员函数 D. 多态函数 2.关于重载的描述，正确的是( ) A.函数重载只能在成员函数之间进行 B.函数重载只能在全局函数之间进行 C.函数重载可以在基类和派生类之间进行 D.函数重载必须要求同名的函数的形参类型和个数都完全一致，返回值类型无所谓 3．下列运算符中不能重载的是( )。 A．∷(域运算符) B.+ （正） C.++ （自增） D.*（指针） 4. 派生类的对象对它的基类成员中（） A. 公有继承的公有成员是可以访问的 B. 公有继承的私有成员是可以访问的 C. 公有继承的保护成员是可以访问的 D. 私有继承的公有成员是可以访问的 5 不能重载的运算符是（） A. ?: B. [ ] C. new D. && 6. C++中不能重载的运算符是( ) A. new B. += C. sizeof D. && 7.重载函数是( ) A.以函数参数来区分，而不用函数的返回值来区分不同的函数 B.以函数的返回值来区分，而不用函数参数来区分不同的函数 C.参数表完全相同而返回值类型不同的两个或多个同名函数 D.参数表和返回值类型中至少有一个不同的两个或多个同名函数 8.对于运算符重载，说法正确的是( ) A.运算符如果被重载为非成员函数，那么对象就不能利用这个运算符重载函数进行操作 B.运算符重载函数可能既不是成员函数，也不是友元函数 C.用户每定义一个类，系统会自动提供一个赋值运算符重载函数，所以完全不 必考虑重载赋值运算符函数 D.一个类的虚函数不能调用运算符重载函数 9. C++中不能重载的运算符是( ) 实验5 运算符重载 1．实验目的 通过本次实验 （1）理解运算符重载函数的概念； （2）掌握运算符重载函数的定义与使用方法； 2．实验要求 （1）编写实验程序 （2）在运行环境中，输入源程序 （3）编译运行源程序 （4）输入测试数据进行程序测试； （5）写出运行结果。 3．实验内容 （1）定义一个复数类，重载“-=”运算符，使这个运算符能直接完成复数的“-=”运算。分别用成员函数与友元函数编写运算符重载函数。在主函数中定义复数对象c1(10,20)、c2(15,30)，进行c2-=c1的复数运算，并输出c1、c2的复数值。 （2）定义一个数组类Array，其私有数据成员为整型一维数组a[10]。通过构造函数给a[10]赋初值。用Show函数显示a[10]的元素值。用成员函数重载运算符“+”，直接实现两个一维数组对应元素相加的运算。在主函数中定义数组a、b分别为： int a[10]={1,2,3,4,5,6,7,8,9,10}; int b[10]={4,5,6,7,8,9,10,11,12,13}; 用Array定义三个数组对象arr1(a)、arr2(b)、arr3，执行arr3=arr1+arr2运算，输出arr3的数组元素值。 （3）定义一个人民币类Money，类中数据成员为元、角、分。用成员函数与友元函数重载“――”运算符，实现人民币对象的减1运算。在主函数中定义人民币对象m1=10元8角5分及对象m2、m3。对m1作前置“――”并赋给m2。对m1作后置“――”并赋给m3。显示m1、m2、m3的结果。 （4）定义描述字符串的类String，编写字符串运算符“+=”的重载函数，使运算符“+=”用于两个字符串联接操作，即用str1+=str2实现字符串函数strcat(str1,str2)的操作功能。要求分别用成员函数与友元函数编写运算符重载函数。在主函数中定义字符串对象s1("software and ")与s2("hardware")，进行s1+=s2的字符串联接，并输出s1、s2的值。 《面向对象程序设计》习题 班级：学号：姓名：名单序号：成绩： 第7章运算符重载和多态性 一、选择题（共30分，每题1分） 1．下列运算符中，（）运算符在C++中不能重载。 A.?: B.[] C. new D.++ 2．友元重载运算符obj1>obj2被C++编译器解释为（）。 A．operator >(obj1,obj2) B．>(obj1,obj2) C．obj2.operator >(obj1) D．obj1.operator >(obj2) 3．重载赋值操作符时，应声明为（）函数。 A．友元B．虚C．成员D．多态 4．在重载一个运算符时，其参数表中没有任何参数，这表明该运算符是（）。 A. 作为友元函数重载的1元运算符 B. 作为成员函数重载的1元运算符 C. 作为友元函数重载的2元运算符 D. 作为成员函数重载的2元运算符5．在重载一运算符时，若运算符函数的形参表中没有参数，则不可能的情况是（）。 A. 该运算符是一个单目运算符。 B. 该运算符函数有一个隐含的参数this。 C. 该运算符函数是类的成员函数。 D. 该运算符函数是类的友元函数。 6. 关于运输符重载，下列表述中正确的是（）。 A．C++已有的任何运算符都可以重载 B．运算符函数的返回类型不能声明为基本数据类型 C．在类型转换符函数的定义中不需要声明返回类型 D．可以通过运算符重载来创建C++中原来没有的运算符 7. C ++流中重载的运算符>>是一个（）。 A. 用于输出操作的非成员函数 B. 用于输出操作的成员函数 C. 用于输入操作的非成员函数 D. 用于输入操作的成员函数 8. 若要对Data类中重载的加法运算符成员函数进行声明，下列选项中正确的是（）。 A. Data +(Data); B. Data operator+(Data); C. Data +operator(Data); D. operator +(Data, Data); 9. 下列运算符中哪些是不能够被重载的（）。 A. .，.*，sizeof，：：，?: B. ++，--，new，= = C. new，delete，>=，[ ] D. +，-，=，delete 10. 在名为BigNumber类的类体中对运算符函数double进行如下声明： operator double(BigNumbe); 函数声明中有一个明显的错误，这个错误就是（）。 A．参数表中不应该有任何参数 B．缺少对函数返回类型的说明 C．参数声明中缺少参数变量 D．函数声明中缺少函数体 11. 下列关于运算符重载的描述中，正确的是（）。 运算符重载的应用 【实验目的】 1、理解重载运算符的意义。 2、掌握用成员函数、友元函数重载运算符的特点。 3、掌握重载运算符函数的调用方法。 【实验内容】 1.定义一个复数类，通过重载运算符：*，/，直接实现二个复数之间的乘除运算。编写 一个完整的程序，测试重载运算符的正确性。要求乘法“*”用友元函数实现重载，除法“/” 用成员函数实现重载。 ⑴分析 两复数相乘的计算公式为：(a+b i)*(c+d i)=(ac–bd )+(ad+bc) i 两复数相除的计算公式为：(a+b i)/(c+d i)=(ac+bd)/(c*c+d*d)+(bc-ad)/(c*c+d*d) i 复数类及运算符重载函数可定义为： 2.根据下面描述定义完整的日期类: class Date{ //成员变量 void IneDay();//日期增加1天 int DayCalc()const;//距基准日期的天数 static const int day[];//每月的天数 public: Date(int y,int m,int d); Date(int m, int d); Date(); void SystmDate();//读取系统当前时间 void SetDate(int yy,int mm,int dd);//设置日期 void SetDate(int mm,int dd); bool IsLeapYear(int yy) const;//是否闰年 bool IsEndofMonth()const ；//是否月末 //重载cout<<,cout>>完成读入和输出日期工作 //重载+，+=，-，-=，++，--，等运算符，完成日期的运算符操作。 //成员函数：判读一个日期是否是系统的当前日期 C+＋习题参考答案 第１章面向对象程序设计概论 一、名词解释 抽象封装消息 【问题解答】 面向对象方法中得抽象就是指对具体问题(对象)进行概括,抽出一类对象得公共性质并加 以描述得过程、 面向对象方法中得封装就就是把抽象出来得对象得属性与行为结合成一个独立得单位,并 尽可能隐蔽对象得内部细节。 消息就是面向对象程序设计用来描述对象之间通信得机制。一个消息就就是一个对象要求另一个对象实施某种操作得一个请求。 二、填空题 (１) 目前有面向过程得结构化程序设计方法与面向对象得程序设计方法两种重要得程序设计方法。 (2) 结构化程序设计方法中得模块由顺序、选择与循环3种基本结构组成。 (3) 在结构化程序设计方法中,程序可表示为程序＝数据结构+算法; 而面向对象得程序设计 方法,程序可表示为程序＝对象＋消息。 (4) 结构化程序设计方法中得基本模块就是过程; 而面向对象程序设计方法中得基本模块就是类。 (５) 面向对象程序设计方法具有抽象性、封装性、继承性与多态性等特点、 三、选择题(至少选一个,可以多选) (1) 面向对象程序设计着重于( B )得设计。 Ａ。对象B。类C、算法D、数据 (2) 面向对象程序设计中,把对象得属性与行为组织在同一个模块内得机制叫做( C )。Ａ、抽象 B。继承 C。封装Ｄ. 多态 (3) 在面向对象程序设计中,类通过( Ｄ )与外界发生关系。 A、对象 B. 类Ｃ、消息D。接口 (４) 面向对象程序设计中,对象与对象之间得通信机制就是( Ｃ )。 A、对象 B。类 C. 消息 D、接口 (5) 关于C++与C语言得关系得描述中,( D )就是错误得、 Ａ、 C语言就是C++得一个子集Ｂ、Ｃ语言与Ｃ++就是兼容得 C. C＋+对C语言进行了一些改进 D. C++与C语言都就是面向对象得 【结果分析】 C语言就是面向过程得。C＋＋语言就是一种经过改进得更为优化得C语言,就是一种混合型语言,既面向过程也面向对象、 (6) 面向对象得程序设计将数据结构与( A )放在一起,作为一个相互依存、不可分割得整体来处理。 A、算法 B。信息C、数据隐藏 D、数据抽象 (7) 下面( Ａ )不就是面向对象系统所包含得要素。 A。重载 B、对象 C. 类 D。继承 【结果分析】 面向对象＝对象+类+继承＋消息+多态 (8) 下面说法正确得就是( BＣ )。 A。将数据结构与算法置于同一个函数内,即为数据封装 B。一个类通过继承可以获得另一个类得特性 Ｃ。面向对象要求程序员集中于事物得本质特征,用抽象得观点瞧待程序 D。同一消息为不同得对象接受时,产生得行为就是一样得,这称为一致性 【结果分析】 运算符重载(operator overload) 是c++的一个重要的新特性,它使得程序员把c++运算符定义扩展到操作数是对象的情况.运算符重载的目的是使c++程序更加直观,更易懂. 运算符重载和普通的重载一样: 作用域相同,函数名字相同,但参数不同(参数个数,参数的类型) , 注意如果函数名字相同,参数相同但函数的返回值类型不同这不是重载,这是错误! 返回值类型operator 被重载的运算符(参数...){函数的实现} 具体的例子网上有很多, 我的重点是一些我们在写重载中易忽略的一些小问题. 有时候我们的程序在多数情况下是对的但有时也总有一些出乎我们意料的情况: 请看下面这个程序: #include 运算符重载 一．单项选择题 1．下列运算符中，运算符在C++中不能重载。 A．?：B．+C．D．<= 解：C++中不能被重载的运算符有：·，一，：：，?：。本题答案为A。 2．下列运算符中，运算符在C++中不能重载。 A．&&B．[]C．：：D．new 解：c++中不能被重载的运算符有：·，·+，：：，?：。本题答案为c。 3 ． 下列关于运算符重载的描述中， 是正确的。 A ．运算符重载可以改变操作数的个数 B ．运算符重载可以改变优先级 C ．运算符重载可以改变结合性 D ．运算符重载不可以改变语法结构 解： 运算符重载不能改变操作数的个数、运算符的优先级、 运算符的结合性和运算程的语 法结构。本题答案为 D 。 4 ．友元运算符 objl>obj2 被 C++ 编译器解释为 。 A ． operator>(objl ， obj2) B ． >(obj1 ， obj2) C ． obj2 ． operator ： >(obj1) D ． objl ． operator>(obj2) 解：重载为友元函数的运算符的调用形式如下： operator< 运算符 >(< 参数 ， < 参数 2>) 等价于： < 参数 1>< 运算符 >< 参数 2> 本题答案为 A 。 5 ．现需要对 list 类对象使用的逻辑运算符“== ”重载，以下函数声明 是正确的。 A 、 list&list ： ： operator==(const list&a) ； B 、 list list ： ： operator==(const list&a) ； C 、 bool&list ： ： 实验5 运算符重载与多态性 班级学号姓名成绩 一．实验目的 1．掌握用成员函数重载运算符的方法 2．掌握用友元函数重载运算符的方法 3．理解并掌握利用虚函数实现动态多态性和编写通用程序的方法 4．掌握纯虚函数和抽象类的使用 二．实验内容 1.复数类加减法乘除运算(用成员函数定义运算符重载)。 复数类的定义： class complex //复数类声明 { public: //外部接口 complex(double r=0.0,double i=0.0) //构造函数 {real=r,imag=i;} complex operator +(complex c2); //运算符"+"重载成员函数 complex operator - (complex c2); //运算符"-"重载成员函数 complex operator *(complex c2 ); //运算符"*"重载成员函数 complex operator /(complex c2); //运算符"/"重载成员函数 complex operator =(complex c2); //运算符"="重载成员函数 void display(); //输出复数 private: //私有数据成员 double real; //复数实部 double imag; //复数虚部 }; 2．复数类比较运算(用友元函数定义运算重载)。 注意： 1）复数类比较运算按复数的模比较两个复数的大小。 2）复数相等判断当两个复数的实部和虚部都相等，两个复数才相等，否则不相等。 类的定义 class complex //复数类声明 { public: complex(double r=0.0,double i=0.0) {real=r;imag=i;} //构造函数 friend int operator> (complex c1,complex c2); //运算符">"重载友元函数 friend int operator>=(complex c1,complex c2); //运算符">="重载友元函数 实验六运算符重载 一、实验目的 1．掌握运算符重载的概念； 2．握使用friend重载运算符的方法； 二、实验要求 1．独立完成程序的编辑、编译、调试及运行； 2．对于程序编译及运行中出现的错误，能够进行改正； 三、实验内容 1、重载加、减、乘、除运算符，实现复数类complex的四则运算。 程序分析： 程序中对于复数的四则运算——加，减，乘，除符号进行重载，采用的是成员函数的方法： Complex operator+(const Complex &c) Complex operator-(const Complex &c) Complex operator*(const Complex &c) Complex operator/(const Complex &c) 当c1+c2时，程序将运算符（+）认为是重载的复数加法运算符，因运算符的两个操作数都是复数，被解释为：c1.operator+(c2)，其中，c1为第一操作数，作为调用重载运算符成员函数的对象，c2是第二操作数，作为重载运算符函数的实参，c1和c2都是类的Complex的对象。 #include 运算符重载综合实例 class MyComplex{ double Real;double Imag; public: //构造函数 MyComplex(const double &r=0.0,const double &i=0.0){Real=r;Imag=i;cout<<"Constructor !"<【g】c++第13章答案
运算符重载基础概念练习题
实验8--友元函数与运算符重载函数
实验五 运算符重载
c++运算符重载习题
运算符重载知识题
实验5-运算符重载、继承 ( 1 )
实验十六运算符重载解读
第十章 运算符重载 复习题
实验5 运算符重载
第7章 运算符重载-习题
运算符重载实验
C++第13章答案
运算符重载注意
C++运算符重载题库及答案
实验5 运算符重载和多态性
C++实验六运算符重载
运算符重载综合实例