C++实验报告之静态成员、运算符重载
题目1：
定义一个复数类，通过重载运算符：*，/，直接实现二个复数之间的乘除运算。编写一个完整的程序，测试重载运算符的正确性。要求乘法“*”用友元函数实现重载，除法“/”用成员函数实现重载。
源程序1
/*******************第1题*******************/
/******************单森汉*****************/
/******************2012-5-1*****************/
#include
using std::cout;
using std::endl;
class Complex{
float Real, Image;
public:
Complex(float r=0,float i=0) { Real=r;Image=i;}
void Show()
{cout <<"Real="< friend Complex operator *(Complex &, Complex &); Complex operator /(Complex &); //重载运算符+ Complex operator +( Complex &); friend Complex operator -(Complex &, Complex &); }; Complex operator *( Complex &c1,Complex &c2) { Complex t; t.Real=c1.Real * c2.Real - c1.Image * c2.Image; t.Image = c1.Image*c2.Real +c1.Real* c2.Image; return t; } Complex Complex::operator /(Complex &c) { Complex t; t.Real =(Real *c.Real+ Image * c.Image)/(c.Real*c.Real+ c.Image * c.Image); t.Image = (Image *c.Real - Real * c.Image)/(c.Real*c.Real+ c.Image * c.Image); return t; } Complex Complex::operator + ( Complex &c) { Complex t; t.Real = Real + c.Real; t.Image = Image + c.Image; return t; } Complex operator -(Complex &c1, Complex &c2) { Complex t; t.Real=c1.Real-c2.Real; t.Image=c1.Image-c2.Image; return t; } void main() {Complex c1(1,2),c2(3,4),c3; c3=c1*c2; cout<<"两个复数的乘法c3=c1*c2:"; c3.Show(); c3=c1/c2; cout<<"两个复数的除法c3=c1/c2:"; c3.Show(); Complex c4(1,2),c5(3,4),c6,c7(1,2),c8(3,0),c9; c6=c4+c5; cout<<"两个复数的加法c6=c4+c5:"; c6.Show(); c6=c4-c5; cout<<"两个复数的减法c6=c4-c5:"; c6.Show(); c9=c7+c8; cout<<"一个复数与一个实数的加法c9=c7+c8:"; c9.Show(); c9=c7-c8; cout<<"一个复数与一个实数的减法c9=c7-c8:"; c9.Show(); } 运行结果截图 题目2： 定义一个向量（一维数组）类，通过重载运算符实现向量之间的加法和减法。加法用成员函数重载，减法用友元函数重载。 源程序2 /*******************第2题*******************/ /******************单森汉*****************/ /******************2012-5-1*****************/ #include using std::cout; using std::endl; class Vect {private: float *p; int n; int x; int y; public :Vect(int x1,int y1,int num) { x = x1; y = y1; n = num; } Vect(){} ~Vect() {} public: friend Vect &operator - (Vect &a, Vect &b); Vect operator + (Vect &a) { if(a.n == n) { return Vect(a.x+x, a.y+y, n); } return a; } void show(){ cout<<"x="< } }; Vect &operator - (Vect &a, Vect &b) { if(a.n == b.n) { return Vect(a.x-b.x, a.y-b.y, a.n); } return a; } int main() { Vect a(4,2,6),b(3,7,6),c; c=a-b; c.show (); return 0; } 运行结果截图 题目3： 为数组类重载下标运算符“[]”、“+”加运算符和“=”赋值运算符。源程序3 /*******************第3题*******************/ /******************单森汉*****************/ /******************2012-5-6*****************/ #include using namespace std; class array { int *a; int lenth; public: array(int lenth=5) { a=new int[lenth]; this->lenth=lenth; } int & operator [](int i) { if(i return a[i]; else cout<<"输入有误"< array operator + (array b) { array c; for(int i=0;i c.a[i]=a[i]+b[i]; return c; } array operator = (array b) { for(int i=0;i a[i]=b[i]; return *this; } void show() { for(int i=0;i cout< cout< } }; int main() { array a,b,c; int i; cout<<"输入数组a（5个元素）："< for(i=0;i<5;i++) cin>>a[i]; cout<<"输入数组b（5个元素）："< for(i=0;i<5;i++) cin>>b[i]; c=a+b; a=b; cout<<"数组a和数组b对应列相加后的新数组："< c.show(); return 0; } 运行结果截图 题目4： 编写程序，统计某旅馆住宿客人的总数。要求输入客人的姓名，输出客人编号（按先后顺序自动生成）、姓名以及总人数。 总人数用静态成员。 其他的三个用普通的数据成员就好了。 源程序4 /*******************第4题*******************/ /******************单森汉*****************/ /******************2012-5-10*****************/ #include using namespace std; class Hotel{ private: static int m_TotalCustNum; char* m_CustomerName; int m_CustomerNum; //通过m_TotalCustNum来定义每个顾客的编号 public: Hotel(char* a_Customer){ m_CustomerName=a_Customer; m_TotalCustNum++; //增加顾客 m_CustomerNum=m_TotalCustNum; } //记得，m_TotalCustNum++ 和m_CustomerNum按照m_TotalCustNum来生成~Hotel() { //delete m_CustomerName; } //记得m_CudeletestomerName void Display() { cout<<"姓名："< } //相应输出客人姓名、编号和总人数 }; int Hotel::m_TotalCustNum=0; int main() { Hotel a("张三"),b("李四"),c("王五"),d("赵六"),e("刘七"); a.Display(); b.Display(); c.Display(); d.Display(); e.Display(); return 0; } 运行结果截图 题目5： 读下列4个程序，给出80%的注释，调试并写出运行结果源程序5 1）Sy3_1.cpp #include using namespace std; //使用命名空间 class My //定义一个My类 { public: //定义My类的公共接口 My(int aa) //定义一个构造函数 { A=aa; //把aa的值赋给A B-=aa; //B-aa的结果赋给B } static void fun(My m); //声明静态函数fun private: //定义My类的私有数据 int A; //定义整型变量A static int B; //定义静态整型变量B }; void My::fun(My m) //定义My类中空类型的fun函数{ cout<<"A="< cout<<"B="< } int My::B=100; //设定B的值为100 int main() //主函数 { My P(6),Q(8);//构造函数初始化列表 My::fun(P); Q.fun(Q); return 0; //函数执行完毕返回0值 } 2）Sy3_2.cpp #include #include using namespace std; //使用命名空间 class My //定义一个My类 { public: //定义My类的公共接口 My(double i=0){x=y=i;} //定义构造函数My My(double i,double j){x=i;y=j;} //构造函数My重载 My(My&m){x=m.x;y=m.y;} //构造函数My重载 friend double dist(My&a,My&b); //声明友元函数dist private: //定义My类的私有数据 double x,y; //定义两个双精度浮点型变量 }; double dist(My&a,My&b) //定义dist函数 { double dx=a.x-b.x; //两点之间横坐标相减 double dy=a.y-b.y; //两点之间纵坐标相减 return sqrt(dx*dx+dy*dy); //返回两个点的距离值 } int main() //主函数 { My m1,m2(15),m3(13,14); //构造函数初始化列表 My m4(m3); //构造函数初始化列表 cout<<"distance1:"< return 0; //函数执行完毕返回0值 } 3）Sy3_3.cpp #include using namespace std; //使用命名空间 class Student //定义一个Student类 { public: //定义类的公共接口 void scoretotalcount(float s); //声明函数 static float sum(); //声明一个静态单精度浮点型函数 static float average(); //声明一个静态单精度浮点型函数 private: //定义类的私有数据 static float total; //定义静态单精度浮点型变量total static float count; //定义静态单精度浮点型变量count float score; //定义单精度浮点型变量score }; void Student::scoretotalcount(float s) //定义类中scoretotalcount函数用来统计学生总分 { score=s; //把s的值赋给score count++; //人数自增 total+=score; //统计总分 } float Student::sum()//返回总分 { return total; //返回总分的值 } float Student::average() //求学生平均分 { return total/count; //返回总分除以总人数的值 } float Student::total=0; //使总分初始值为0 float Student::count=0; //使总人数初始值为0 int main() //主函数 { Student stud[20]; //定义一个存放学生数据的一维数组 int n; //定义一个整型变量n float s; //定义一个单精度浮点型变量s cout<<"input number of students:"; //提示输入学生人数 cin>>n; //输入学生人数 for (int i = 0; i < n; i++)//用for循环求学生总分 { cout<<"input score of No."< stud[i].scoretotalcount(s); //统计总分 } cout<<"total score :"< cout<<"average score:"< return 0; //函数执行完毕返回0值 } 4） #include #include using namespace std; //使用命名空间 class Ruler; class Book //创建一个Book类 { public: //定义Book类的公共接口 Book(float j) {weight =j;} //定义构造函数Book friend float totalWeight(Book &abook,Ruler &aruler); //声明友元函数 private: //定义Book类的私有数据 float weight;//定义一个单精度浮点型的变量weight }; class Ruler //创建一个Ruler类 { public: //定义Ruler类的公共接口 Ruler(float j ){ weight=j;} //定义构造函数Ruler friend float totalWeight(Book &abook ,Ruler &aruler); //声明友元函数 private: //定义Ruler类的私有数据 float weight; //定义一个单精度浮点型的变量weight }; float totalWeight (Book &abook ,Ruler &aruler) //定义友元函数totalWeight { return abook.weight+aruler.weight; //返回书质量加上尺子质量的值 } int main() //主函数 { float w; //定义一个单精度浮点型的变量w cout<<"input weight of book"< cin>>w; //输入书的质量 Book b(w); //调用Book函数 cout<<"input weight of ruler"< cin>>w;//输入尺子的质量 Ruler r(w); //调用Ruler函数 cout<<"Totalweight of the book and ruler is"< return 0; //函数执行完毕返回0值 } 运行结果截图 1） 2） 3） 4） 运算符重载 一．单项选择题 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<运算符>(<参数1>，<参数2>) 等价于：<参数1><运算符><参数2> 本题答案为A。 5．现需要对list类对象使用的逻辑运算符“==”重载，以下函数声明是正确的。 A、list & list：：operator==(const list &a)； B、list list：：operator==(const list &a)； C、bool & list：：operator==(const list &a)； D、bool list：：operator==(const list &a)； 6. 以下类中分别说明了“+=”和“++”运算符重载函数的原型。如果主函数中有定义： fun m,c,d;，那么，执行语句c=m++; 时，编译器把m++解释为： (33) A) c.operator++(m); B) m=operator++(m); C) m.operator++(m); D) operator++(m); class fun { public: .. .. .. fun operator +=(fun ); friend fun operator ++(fun &,int); }; 答案：D 7. 在第33题中，当执行语句d+=m; 时，C++编译器对语句作如下解释： (34) A. d=operator+=(m); B. m=operator+=(d); C. d.operator+=(m); D. m.operator+=(d); 答案：C 8. 设有以下类定义，其中说明了“+”运算符重载函数的原型。这是一个友元函数，当类 实验十三 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 运算符重载就是对一个已有的运算符赋予新的含义，使之实现新功能。下面将通过简单的几个例程阐叙其用法。 例10.1 通过函数来实现复数相加。 #include int main( ) {Complex c1(3,4),c2(5,-10),c3; //定义3个复数对象c3=https://www.wendangku.net/doc/bf13916260.html,plex_add(c2); //调用复数相加函数cout<<″c1=″; c1.display( ); //输出c1的值cout<<″c2=″; c2.display( ); //输出c2的值 cout<<″c1+c2=″; c3.display( ); //输出c3的值 return 0; } 例10.2 改写例10.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 实验五运算符重载、继承 ●实验目的 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< 走进3D的世界 -- C++中用运算符重载实现矩阵运算 作者：周军 矩阵(Matrix)无处不在，我们的生活中到处都能找到矩阵的身影，然而此处我不想把这个定义放大，我们只讨论线性代数中的矩阵，我们要用它们来完成我们的3D变换。为什么矩阵可以完成3D变换呢？下面，我们就来介绍矩阵是如何变换坐标的： 设空间中有一坐标(x,y,z)，如果我们想把它变换成另一坐标(x,’y’,z’)，我们可以进行如下操作： = (x’,y’,z’,1) 这就是矩阵的妙用了。它在复杂处理变换的时候表现得尤为突出。假设我们想要把一个物体先沿z轴旋转角thetaZ，再沿x轴旋转角thetaX，我们可以进行如下操作(pseudo-code): obj*=rotX(thetaX)*rotZ(thetaZ); 注意：矩阵的乘法是不可逆的，而且我们要按变化顺序的逆序进行乘法，具体推导见计算几何相关书籍。 下面，我们进入正题：如何再C++中用重载运算符的方法来进行矩阵运算以完成线性变换呢？我们需要变换坐标，所以很自然地，我们需要一个向量(Vector)类；同时我们要进行 为直观、人性化，我选用了运算符重载这以技巧而不是简单地调用函数，下面请看我的具体实现： 以上便是CVector类的具体实现，我想对C++和线性代数有所了解的读者都能很清楚地理解这段代码，在次不累述。 上述代码的成员函数实在类外定义的，如果读者在实践中为了提高速度可以把这些成员函数定义在类内以起到内联函数的作用，可以省去参数压栈、出栈时的时间。 下面是CMatrix类的具体实现： 是不是也很好理解呢？哈哈，这就是用运算符重载的好处。不过这种方法也确实有它的不足，而且这个不足在游戏编程中是致命的，那就是效率不高，这也正是为什么Microsoft 在DirectX中也使用难看的一般函数调用来完成矩阵运算的原因。影响速度的主要原因是在使用运算符+、-、*、/等时，程序会在每次运算时创建临时对象再将临时对象返回，对于重复多次的矩阵运算来说，这无疑成为了一笔庞大的额外开销（好在现在的计算机的处理速度还算快）。但注意：在使用+=、-=、*=、/=时不会有上述问题，因为在使用这些运算符时程序只需要修改第一个对象不需要创建并返回临时对象。所以在能使用+=、-=、*=、/=时尽量不要使用单一的=、-、*、/运算符。 好了，这两个类我们已经封装好了，下面还有什么呢？是的，忘了向大家交代旋转矩阵了： 实验十六运算符重载 一、实验目的 1、理解运算符重载作用和意义； 2、掌握类运算符和友元运算符重载的定义和使用； 3、掌握常用运算符(++、--、+、-、*、/、=、+=、-=、*=、/=、<<（插入）、>>（提取）)的重载。 二、实验内容 1、下列程序定义了一个复数类，重载"+"运算符以实现复数的加法运算。 #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. 二元运算符重载成为非成员函数时，参数表中有一个参数 Problem A: Counter类（运算符重载练习） Time Limit: 1 Sec Memory Limit: 128 MB Submit: 739 Solved: 516 [Submit][Status][Web Board] Description 编写一个计算器Counter类，对其重载运算符“+”。用下面的主程序测试，使测试结果正确。 int main() { Counter varOne(2), varTwo(4), varThree; varThree = varOne + varTwo; cout << "varOne: " << varOne.getValue()<< endl; cout << "varTwo: " << varTwo.getValue() << endl; cout << "varThree: " << varThree.getValue() << endl; return 0; } Input Output varOne: 2 varTwo: 4 varThree: 6 源代码： #include double getValue()const { return itsVal; } Counter operator+ (const Counter &v) { return Counter(itsVal + v.getValue()); } private: double itsVal; }; int main() { Counter varOne(2), varTwo(4), varThree; varThree = varOne + varTwo; cout << "varOne: " << varOne.getValue()<< endl; cout << "varTwo: " << varTwo.getV alue() << endl; cout << "varThree: " << varThree.getValue() << endl; return 0; } 实验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的值。 实验：定义一个时间类Time(时，分，秒)，通过操作符重载实现： 时间的比较（==、!=、>、>=、<、<=）、时间增加/减少若干秒（+=、-=） 由题意，我定义了一个时间类Time，并且定义时(shi),分(fen),秒(miao)这些私有数据成员。 然后在main函数那里就可以通过构造函数定义一个时间了。如下图所示： 由上图可知，我还对（==、!=、>、>=、<、<=）这些运算符进行了重载，返回bool类型的值。而且，对于时间增加/减少若干秒，我用友元函数方式让一个时间类Time和int类型的数值（秒）相加。下面我将对各种运算符重载做详细说明。 1：首先，我们来看“==”这个运算符重载。 它在Cpp文件里的定义如下： 由上可知，只有两个时间类的时，分，秒分别相等，才能返回一个true值，否则返回一个false值。具体程序是通过条件语句构造而成，一目了然。而我们在main函数里先定义两个时间类time0，time1。分别让它们相等和不相等运行一次，实验结果如下： 2：我们来看“！=”这个运算符重载。 它在Cpp文件里定义如下： 由上可知，它就是把“==”运算符重载函数里的true和false互换而已，却起到了相反的效 果。实验结果如下： 3：我们来看“>”这个运算符重载。 它在Cpp文件里定义如下： 由上可知，程序有点复杂了，不过思路还是很清晰的。首先，通过比较两个时间类的时，看它们是否符合大于等于关系，如果没有则返回false值。然后比较时是否相等，如果不相等则说明第一个类的时一定大于第二个类的时，则返回true值。比较完时，如果在时相等的情况下，再来比较分，与比较时的程序相同，能轻松得出两个类的分的大小。在分也相等的情况下，再来比较秒，如果大于则返回true值，否则返回false值。至此，两类的时间大小可比较出来是否存在大于关系。鉴于有多种情况，我就其中3种进行截图。实验结果如下： 运算符重载的应用 【实验目的】 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>>完成读入和输出日期工作 //重载+，+=，-，-=，++，--，等运算符，完成日期的运算符操作。 //成员函数：判读一个日期是否是系统的当前日期 二、运算符重载（运算符重载的基本概念、运算符重载方法、运算符重载规则、特殊运算符重载和类型转换） 单选题10道： 1、假定要对类AB定义加号操作符重载成员函数，实现两个AB类对象的加法，并返回相加结果，则该成员函数的声明语句为（ B ）。 A. AB operator+(AB& a,AB& b) B. AB operator+(AB& a) C. operator+(AB a) D. AB &operator+( ) 2、关于运算符重载，下面的叙述错误的是（）。 A．运算符预定义的操作数个数不能改变 B．重载不能改变运算符的优先级顺序 C．参数的类型没有限制 D．尽量使其与原意保持一致 3、在一个类中可以对一个操作符进行（D ）重载。 A. 1种 B. 2种以下 C. 3种以下 D. 多种 4、重载赋值操作符时，应声明为（C ）函数。 A. 友元 B. 虚 C. 成员 D. 多态 5、要在类对象使用运算符，以下不必被重载的运算符是（ A ）。 A. [] B. = C. ++ D. -- 6、下列运算符中，不能重载的是（C ） A．new B．() C．::D．&& 7、在表达式x+y*z中，+ 是作为成员函数重载的运算符，*是作为非成员函数重载的运算符。下列叙述中正确的是（ A ）。 A）operator+有两个参数，operator*有两个参数 B）operator+有两个参数，operator*有一个参数 C）operator+有一个参数，operator*有两个参数 D）operator+有一个参数，operator*有一个参数 8、友元运算符obj1>obj2被C++编译器解释为（）。 A) operator>(obj1,obj2) B) >(obj1,obj2) C) obj1.operator>(obj2) D) obj2.operator>(obj1) 9、已知某个类的友元函数重载了+=和-，a，b，c是该类的对象，则“a+=b-c”被C++编译器解释为（）。 A) operator+=(a,operator-(b,c)) B) a.operator+=(b.operator-(c)) C) operator+=(a,b.operator-(c)) D) a.operator+=(operator-(b,c)) 10、下列运算符中，必须使用成员函数进行重载的是（）。 A) == B) = C) >> D) ++ 填空题10道： 1、多数运算符既能作为类的成员函数重载，也能作为类的非成员函数重载，但运算符“[]”只能作为类的函数重载。 2、加法运算符“+”和赋值运算符“=”都重载之后，“+=”也被重载了。 3、单目运算符作为类的成员函数重载时形参。 4、利用成员函数对二元运算符重载时，其右操作数为。 5、重载运算符函数的函数名由关键字引出。 6、运算符的重载归根结底是的重载。 7、后缀自增自减运算符定义时带有一个。 /*定义复数类Complex， （1）定义私有数据成员，实部和虚部； （2）定义带默认值的构造函数，给数据成员赋值，默认值为0； （3）定义输出函数void display()，输出格式如“3+4i”或“-3-4i”； （4）定义复数与复数的加、减运算符重载；复数加实数运算符重载；赋值运算符重载；（5）定义主函数，对上述成员函数进行测试。 */ #include { real=c.real ; imag=c.imag ; return *this; } Complex operator -(Complex & c) { Complex temp; temp.real =c.real -real; temp.imag =c.imag -imag; return temp; } }; void main() { Complex a(2,3),b(4,5),c,d,f,g; cout<<"a="; a.display(); cout<<"b="; b.display(); c=a; cout<<"c=a="; c.display (); f=a+b; cout<<"f=a+b="; f.display(); d=a+4; cout<<"d=a+4="; d.display (); g=a-b; cout<<"g=a-b="; g.display(); } 结果： a=2+3i b=4+5i c=a=2+3i f=a+b=6+8i d=a+4=6+3i g=a-b=2+2i Press any key to continue 实验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); //运算符">="重载友元函数 一、运算符重载的规则 运算符重载规则如下： ①、C++中的运算符除了少数几个之外，全部可以重载，而且只能重载C++中已有的运算符。 ②、重载之后运算符的优先级和结合性都不会改变。 ③、运算符重载是针对新类型数据的实际需要，对原有运算符进行适当的改造。一般来说，重载的功能应当与原有功能相类似，不能改变原运算符的操作对象个数，同时至少要有一个操作对象是自定义类型。 不能重载的运算符只有五个，它们是：成员运算符“.”、指针运算符“*”、作用域运算符“：：”、“sizeof”、条件运算符“？：”。 运算符重载形式有两种，重载为类的成员函数和重载为类的友元函数。 运算符重载为类的成员函数的一般语法形式为： 函数类型 operator 运算符（形参表） { 函数体； } 运算符重载为类的友元函数的一般语法形式为： friend 函数类型 operator 运算符（形参表） { 函数体； } 其中，函数类型就是运算结果类型；operator是定义运算符重载函数的关键字；运算符是重载的运算符名称。 当运算符重载为类的成员函数时，函数的参数个数比原来的操作个数要少一个；当重载为类的友元函数时，参数个数与原操作数个数相同。原因是重载为类的成员函数时，如果某个对象使用重载了的成员函数，自身的数据可以直接访问，就不需要再放在参数表中进行传递，少了的操作数就是该对象本身。而重载为友元函数时，友元函数对某个对象的数据进行操作，就必须通过该对象的名称来进行，因此使用到的参数都要进行传递，操作数的个数就不会有变化。 运算符重载的主要优点就是允许改变使用于系统内部的运算符的操作方式，以适应用户自定义类型的类似运算。 一般说来，单目运算符最好被重载为成员；对双目运算符最好被重载为友元函数，双目运算符重载为友元函数比重载为成员函数更方便此，但是，有的双目运算符还是重载为成员函数为好，例如，赋值运算符。 二、运算符重载为成员函数 对于双目运算符B，如果要重载B为类的成员函数，使之能够实现表达式oprd1 B oprd2,其中oprd1为类A的对象，则应当把B重载为A类的成员函数，该函数只有一个形参，形参的类型是oprd2所属的类型。经过重载后，表达式oprd1 B oprd2 就相当于函数调用 oprd1.operator B(oprd2).运算符重载练习题.
实验8--友元函数与运算符重载函数
C++运算符重载例程详解
实验五 运算符重载
c++运算符重载习题
实验5-运算符重载、继承 ( 1 )
C中用运算符重载实现矩阵运算
实验十六运算符重载解读
运算符重载知识题
Counter类(运算符重载练习)
实验5 运算符重载
c++ 基于时间类的运算符重载实验
运算符重载实验
运算符重载题目
复数类,运算符重载(赋值运算符等)
实验5 运算符重载和多态性
C++运算符重载