实验11 运算符重载

11章运算符重载

考虑用普通函数实现两个复数相加
Complex complex_add(Complex &c1， Complex &c2) { Complex c; c.real=c1.real+c2.real; c.imag=c1.imag+c2.imag; return c; }
将其声明为Complex 类的友元函数
int operator + (int a, int b) {return (a－b);}
（8）用于类对象的运算符一般必须重载，但有两个例外，运算符“=”和“&”不必用户重载。 ① 赋值运算符(=)可以用于每一个类对象，可以利用它在同类对象之间相互赋值（系统已经为每一个新声明的类重载了一个赋值运算符，他的作用是逐个复制类的数据成员）。 ② 地址运算符&也不必重载，它能返回类对象在内存中的起始地址。（9）应当使重载运算符的功能类似于该运算符作用于标准类型数据时所实现的功能。（10）运算符重载函数可以是类的成员函数，也可以是类的友元函数，还可以是既非类的成员函数也不是友元函数的普通函数。
后自增
在自增(自减)运算符重载函数中，增加一个int型形参，就是后置自增(自减)运算符函数。
#include <iostream> Complex Complex::operator ++ (int) using namespace std; { //对象复制，保存修改前对象状态 class Complex Complex temp(*this); {public: real++; imag++; //对象自增 Complex( ) return temp; //返回的是自加前的对象 {real=0; imag=0;} } Complex(double r,double i) {real=r; imag=i;} void Complex∷display( ) //重载后自增++函数 cout<<″(″<<real<<″,″<<imag<<″i) Complex operator + { +(int); void display( ); ″<<endl;} private: int main( ) double real; { Complex c1(3,4),c2; double imag; c2=c1++; // c1. operator ++ (0) }; cout<<″c1=″; c1.display( ); cout<<″c2=″; c2.display( ); }

运算符重载的规则

运算符重载的规则运算符重载是C++中一种强大的特性，它允许我们使用现有的运算符进行不同类型的操作。

运算符重载规则很重要，因为它们确保使用该特性时代码的正确性和可靠性。

本文章将为大家详细介绍C++中运算符重载的规则。

1.运算符重载必须与至少一个类或枚举类型相关联。

这意味着，您不能像重载运算符“+”来增加任意两个变量的值，而需要将其放置在自定义类中。

2.运算符重载通常是作为一个成员函数实现的，但也可以作为全局函数实现。

当作为成员函数进行实现时，第一个参数必须是对象本身，而全局函数的对应参数则更灵活。

3.与其他函数一样，每个重载运算符必须有一个唯一的函数签名。

这意味着，您不能定义两个具有相同函数签名的重载运算符（例如，您不能同时实现运算符“+”和“++”）。

4.调用运算符重载函数的语法与调用运算符本身的语法相同。

例如，如果您已经编写了一个重载运算符“+”，则可以使用它来添加两个对象，并使用以下语法来调用它:obj1+obj2。

5.在重载运算符时，应尽量保持运算符的原始功能。

例如，与重载运算符“+”相关联的类中的对象应该具有通常使用加法运算符时对象具有的行为。

否则，将会导致代码的错误，从而使其不可靠。

6.可以重载以下运算符：+，-，*，/，％，^，＆，|，~，！，=，<，>，++，--，<<，>>，&&，||，==，！=，<=和>=。

7.如果您在自定义类中定义了运算符重载函数，则应该考虑所有涉及该类的场景，包括复制构造函数、析构函数和其他默认函数。

8.当您在自定义类中实现运算符重载时，应注意函数的返回类型。

如果重载运算符“+”，则返回的结果应该是一个新的对象，而不是直接修改现有对象的值。

总之，正确使用运算符重载规则是确保代码正确性和可靠性的关键因素。

这些规则有助于保持代码的一致性、可读性和可维护性，并有助于提高生产率和代码重用性。

因此，当您在编写代码时使用运算符重载时，请始终牢记这些规则，以确保代码的正确完成和可靠性。

c++ 运算符重载的写法

c++ 运算符重载的写法
在C++中，运算符重载允许我们重新定义已有的运算符，使其适用于自定义的数据类型。

这样可以使得我们的自定义类型具有与内置类型相似的行为。

运算符重载的写法如下：
1. 成员函数形式：
返回类型 operator运算符(参数列表) {。

// 实现运算符重载的逻辑。

}。

这里的operator运算符是要重载的运算符，参数列表是运算符操作的参数。

返回类型是运算符操作的结果类型。

2. 友元函数形式：
friend 返回类型 operator运算符(参数列表) {。

// 实现运算符重载的逻辑。

}。

在这种形式下，operator关键字后面紧跟要重载的运算符，然后是参数列表和实现运算符重载的逻辑。

需要注意的是，不是所有的运算符都可以被重载，也不是所有
的运算符都可以以成员函数的形式进行重载。

例如，赋值运算符`=`, 成员访问运算符`->`和作用域解析运算符`::`不能被重载。

此外，在进行运算符重载时，需要注意避免对运算符的本质含
义进行过度改变，以免造成混淆。

另外，为了避免歧义，建议仅重
载已有含义的运算符，不要创建新的运算符。

最后，在实现运算符
重载时，需要考虑重载后的运算符操作是否符合常规的语义，以及
是否符合预期的行为。

总之，C++中的运算符重载为我们提供了一种非常灵活的方式，
可以使得自定义类型具有与内置类型相似的行为，但是在使用时需
要谨慎考虑，避免造成混淆和歧义。

[C++]运算符重载实验报告

+operator+(const COMPLEX &other): COMPLEX+operator-(const COMPLEX &other) : COMPLEX+operator-(): COMPLEX+operator=(const COMPLEX &other) : COMPLEX运行结果2. 程序的类结构图为：Tx,y:int+T(int a,int b)+&operator<<(ostream &os,T &a):friend ostream运行结果3. 程序的类结构图为：Shape+Area():virtual double const+PrintShapeName():virtual void const +Print():virtual void constPointx,y:int+Point(int=0,int=0)+SetPoint(int a,int b):void+GetX():int const+GetY():int const+PointShapeName():virtual void const +Print():virtual void constCircleradius:double+Circle(int x=0,int y=0,double r=0.0) +SetRadius(double r):void+GetRadius():double const+Area():virtual double const+Print():virtual void const+PrintShapeName():virtual void const 运行结果{cout<<'['<<x_size<<","<<y_size<<']'<<", "<<'['<<i_size<<","<<j_size<<']'; }int main(){Circle1 circle(0.0,0.0,3.0);circle.area();circle.perimeter();circle.print();cout<<"\n";Square1 square(0.0,0.0,3.0,3.0);square.area();square.perimeter();square.print();cout<<"\n";cout<<"圆的面积为："<<circle.area()<<endl;cout<<"圆的周长为："<<circle.perimeter()<<endl;cout<<"圆的圆心坐标和半径为：";circle.print();cout<<"\n\n";cout<<"正方形的面积为："<<square.area()<<endl;cout<<"正方形的周长为："<<square.perimeter()<<endl;cout<<"正方形的中心坐标和一个顶点坐标分别为：";square.print();cout<<"\n";return 0;}运行结果【实例编程】运行结果。

简述运算符重载的规则。

运算符重载是指可以为自定义的类类型或枚举类型定义新的含义和功能。

在
C++中，运算符重载遵循以下一般规则：
1. 运算符重载必须至少有一个操作数是用户自定义的类类型或枚举类型的对象，否则将无法重载。

2. 运算符重载可以作为成员函数或非成员函数来实现。

3. 对于成员函数的运算符重载，操作数的数量为运算符的操作数减去1。

例如，重载双目运算符时（如+、-、*等），成员函数需要接受一个参数，用于表示另一个操作数。

4. 对于非成员函数的运算符重载，所有操作数都作为参数传递给函数。

可以通过将重载运算符函数声明为友元函数来访问类的私有成员。

5. 对于重载一元运算符（如++、），如果是成员函数，则返回一个修改后的对象；如果是非成员函数，则返回一个新的对象。

6. 对于重载二元运算符（如+、-、*等），如果是成员函数，则一个对象被修改，另一个对象不变；如果是非成员函数，则返回一个新的对象。

7. 运算符重载不能改变原有运算符的优先顺序和结合性。

8. 运算符重载遵循函数重载的规则，即可以根据参数类型和参数数量进行重载，实现不同的功能。

需要注意的是，运算符重载应该遵循语义上的合理性并不滥用。

第11讲运算符重载和string类

运算符的重载既不会改变原运算符的优先级和结合性，运算符的重载既不会改变原运算符的优先级和结合性，也不会改变使用运算符的语法和参数个数。不会改变使用运算符的语法和参数个数。当重载为类的成员函数时，当重载为类的成员函数时，运算符重载函数的形参个数要比运算符操作数个数少一个；若重载为友元函数，比运算符操作数个数少一个；若重载为友元函数，则参数个数与操作数个数相同。个数与操作数个数相同。下面的运算符只能通过成员函数重载。下面的运算符只能通过成员函数重载。
2008年02月张华武汉大学
7
运算符重载
运算符重载
案例分析：案例分析：运算符重载为类的成员函数
类中定义重载运算符+的函数在Complex类中定义重载运算符的函数。（cw1102）类中定义重载运算符的函数。）
#include <iostream.h> class Complex { private: double r; //实部实部 double i; //虚部虚部 public: Complex operator+(const Complex &c); Complex operator+(double d); …… };
成员函数
string &append(const char *s) string &append(const char *s, unsigned n) unsigned find(const string &s, unsigned pos=0) const int compare(const string &s) const unsigned length() const ……
2008年02月张华武汉大学

简述运算符重载的规则。

篇一：运算符重载是C/C++语言中一种强大的功能,允许程序员自定义函数的行为,以处理不同类型的数据。

运算符重载允许程序员在函数中重载算术、逻辑和位运算符,从而能够处理数组、结构体和指针等不同类型的数据。

以下是运算符重载的规则:1. 算术运算符重载算术运算符包括加号、减号、乘号和除号。

每个算术运算符都有一组默认的行为,可以通过运算符重载来自定义它们的行为。

例如,重载加号运算符可以使函数接受一个整数参数,并返回一个新的整数。

下面是一个简单的例子,演示了如何重载加号运算符:```c++struct MyStruct {int value;};MyStruct operator+(const MyStruct& other, int value) {return MyStruct(value + other.value);}int main() {MyStruct mystruct1 = { 10 };MyStruct mystruct2 = { 20 };int result = mystruct1 + mystruct2;std::cout << "result = " << result << std::endl;return 0;}```在上面的例子中,我们定义了一个名为`MyStruct`的结构体类型,其中包含一个整数类型。

然后,我们定义了一个重载加号运算符的函数,该函数接受一个整数类型的参数,并返回一个新的`MyStruct`对象。

在`main`函数中,我们定义了两个`MyStruct`对象`mystruct1`和`mystruct2`,并将它们相加,结果存储在`result`变量中。

2. 逻辑运算符重载逻辑运算符包括条件运算符和逻辑非运算符。

每个逻辑运算符都有一组默认的行为,可以通过运算符重载来自定义它们的行为。

c++运算符重载实验心得

c++运算符重载实验心得
在C++中，运算符重载是一种非常强大的技术，允许我们为自定义类型创建自定义操作符。

运算符重载可以使程序更加优雅和易于理解，同时还可以提高代码的可重用性和可维护性。

在本次实验中，我学习了如何在自定义类中重载运算符，并对此进行了实践。

首先，我为自定义类定义了一些常见的运算符操作，如加、减、乘、除等。

然后，我学习了如何在类中重载这些运算符，以便在程序中可以使用它们。

重载运算符的过程非常简单，只需要定义一个成员函数或友元函数，并使用运算符关键字来标识要重载的运算符。

在重载运算符时，我们可以使用现有的C++运算符及其操作数，并为它们定义自己的行为。

例如，我们可以重载“+”运算符以执行自定义操作。

我们只需要定义一个函数，它将两个对象相加，并返回一个新的对象。

这样，我们就可以使用“+”运算符来执行自定义的操作，并且可以在程序中使用它。

总之，运算符重载是一种非常强大和灵活的技术，在C++中非常有用。

通过使用它，我们可以为自定义类型定义自己的操作符，并为它们定义自己的行为。

这非常有用，可以使我们的程序更加优雅、易于理解，
同时也可以提高代码的可重用性和可维护性。

运算符重载—C++课程实验报告

#include<iostream>
using namespace std; class AB
{
public:
AB(int xx, int yy); void ShowAB(); AB& operator ++(); AB operator ++(int);
AB& operator --();
AB operator --(int);
通过这次实验我基本掌握了通过运算符重载实现多态性的方法学会了运算符重载的成员函数法和友元函数法基本能够区分单目运算符的前置与后置
C++
学生姓
名
xxx
班级
学号
xxxxxxxxx
实验项
目
实验四运算符重载
指导教师
杜之波
实验目
的和要
求
一、实验目的
（1）掌握通过运算符重载实现多态性的方法；
（2）学会运算符重载的成员函数法和友元函数法；
运算后，
A的值为："
什+AA).ShowAB();
coutvv"
B
的值为：";
(++BB).ShowAB();
cout<v"B=A--运算后，A的值为：";
(--AA).ShowAB();
coutvv"B的值为：";
(BB--).ShowAB();
cout<<"B=--A运算后，A的值为：";
(--AA).ShowAB();
{
AB AA(0,0);
AB BB(0,0);
cout<v"A的值为:";

运算符重载-- 实验报告

南昌航空大学实验报告2011年12月1号课程名称：面向对象程序设计B 实验名称：运算符重载班级：姓名：同组人：无指导教师评定: 签名：一、实验目的理解运算符重载（非成员形式和成员形式）、学习重载几类运算符（++，=，！=，+，-，==等）。

二、实验内容应用VC++6.0的构建一个复数类Complex，试对下列几个运算符进行重载：++，=，！=，+，-，==，其中要求要有成员重载形式和友元重载形式，而且，++运算符要求实现先加和后加两种形式。

三、概要设计函数原型：class complex{private:double real;double image;public:complex(double r=0,double i=0);complex &operator+(complex &c);complex operator-(complex &c);complex operator*(complex &c);friend complex operator/(complex &c1,complex &c2);friend bool operator==(complex &c1,complex &c2);friend bool operator!=(complex &c1,complex &c2);complex operator++();complex operator++(int);void show();｝；四、详细设计重载运算符 + 的函数：complex &complex::operator+(complex &c){complex temp;temp.real=real+c.real;temp.image=image+c.image;return temp;}重载运算符 - 的函数：complex complex::operator-(complex &c){complex temp;temp.real=real-c.real;temp.image=image-c.image;return temp;}重载运算符 * 的函数：complex complex::operator*(complex &c){complex temp;temp.real=real*c.real;temp.image=image*c.image;return temp;}重载运算符 / 的函数：complex operator/(complex &c1,complex &c2){complex temp;double t;t=1/(c2.real*c2.real+c1.image*c1.image);temp.real=(c1.real*c2.real+c1.image*c2.image)*t;temp.image=(c2.real*c1.image-c1.real*c2.image)*t;return temp;}重载运算符 == 的函数：bool operator==(complex &c1,complex &c2){if(c1.real==c2.real&&c1.image==c2.image)return true;elsereturn false;重载运算符 != 的函数：bool operator!=(complex &c1,complex &c2){if(c1.real!=c2.real||c1.image!=c2.image) return true;elsereturn false;}重载运算符 ++ 的函数：complex complex::operator++(){++real;++image;return *this;}complex complex::operator++(int){real++;image++;return *this;}五、程序调试经调试无误后，运行的结果为：六、实验总结通过这次的试验，我明显的感觉到自己对这方面的知识掌握的还不够熟练，不能顺利地、流畅地运用这方面的知识，因为我没有在规定的时间内完成程序的设计，课后还是要多复习。

运算符重载实验报告

};
RMB::RMB(unsigned int d, unsigned int c)
{
yuan = d;
jf = c;
while ( jf >=100 ){ //以使构造时，确保角分值小于100
yuan ++;
jf -= 100;
}
}
RMB operator+(RMB& s1, RMB& s2) // 此处改为RMB& operator+(RMB& s1, RMB& s2)
private:
unsigned int yuan; //元
unsigned int jf; //角分
};
RMB RMB::interest(double rate)
{
return RMB((yuan + jf / 100.0) * rate);
}
RMB RMB::add(RMB d)
{
return RMB(yuan + d.yuan + jf / 100.0 + d.jf / 100.0);
expense2(x,yrate).display();
}
3.实验结果：
（二）实验题目二：
（2）将以下程序中重载运算符定义函数的返回类型更改（值返回更改为引用返回，引用
返回更改为值返回），观察程序运行结果，说明原因。
#include<iostream.h>
class RMB{
public:
RMB(unsigned int d, unsigned int c);
学号：
指导教师：
2013年11月18日

运算符重载解读

02
在重载运算符时，应明确指定运算符的参数类型和返回类型，避免与其他操作符混淆。
03
在重载运算符时，应尽量使用有意义的操作符名称，以提高代码的可读性。
考虑性能和效率
01
02
03
运算符重载时，应考虑性能和效率，避免对原有代码造成不必要的性
能损失。
在重载运算符时，应尽量减少额外的计算和内存开销，以提高代码的
一元运算符重载
一元运算符重载是指对一元运算符进行重载，使其能够应用于一个操作数。例如，在C中，我们可以重载一元减号运算符(-)来返回一个数的相反数。
常见的一元运算符有：+、-、~、!等。
二元运算符重载
二元运算符重载是指对二元运算符进行重载，使其能够应用于两个操作数。例如，在C中，我们可以重载加号运算符(+)来定义两个自定义类型的相加行为。
01
提高代码可读性
运算符重载可以使代码更易读，因为运算符的使用可以使代码更简洁、更直观。
02
03
方便函数调用
运算符重载可以使得函数调用更加方便，因为运算符的使用可以减少函数调用的开销。
04
缺点分析
易造成混淆
运算符重载可能会使得代码难以理解，因为运算符的行为可能会被改变，导致读者难以
理解代码的含义。
常见的二元运算符有：+、-、*、/、%等。
三元运算符重载
三元运算符重载是指对三元运算符进行重载，使其能够应用于三个操作数。例如，在C中，我们可以重载条件运算符(?)来定义一个自定义类型的条件判断行为。
常见的三元运算符有：?:。
03
运算符重载的常见场景
类与类之间的运算
01
两个类对象之间的加法运算，可以表示它们之间的某种关联或合并。

C++程序设计11-运算符重载(续)

如果左边操作数必须是另一个类的对象，或者是一个其他类型的对象，运算符函数必须是非成员函数，只能用友元（friend）函数。
如： cout << phone; cin >> phone; // << 和>> 运算符应属于 phone 设计运算符函数时尽量用成员函数，避免用友元函数。设计运算符函数时尽量用成员函数，避免用友元函数。
调用方式： c = add(a,b);
再如： int a, b, c, z; z = a + b + c; 如用函数表示应该是：如用函数表示应该是：如果 add(int a,int b) 没有返回值，则不能实现连加！！
z = add(add(a,b),c);
§8.2 运算符重载
2。从函数角度来看，“重载”是函数名称相同而入口参数数从函数角度来看，重载” 从函数角度来看据类型不同的。据类型不同的。
§ 运算符重载的限制
1) 不能改变运算符的优先级； 2) 不能改变运算符的结合性； 3) 不能改变运算符操作数的个数； 4) 不能建立新的运算符； 5) 运算符函数的参数至少有一个必须是类的对象或是对类的对象的引用； 6) 在重载运算符()、[]、->或者=时，运算符重载函数必须是类的成员；其它可以是友元； 7) 不能改变内部类型的运算。 8) 运算符+被重载，并不等于+=也自动被重载。
友元函数和友元类 friend
一个类的友元函数是在该类作用域之外定义的：友元不是该类的成员。一个类的友元可以访问该类的所有成员，包括私有成员和受保护成员。友元必须在类中事先声明。友元关系是不对称且不传递的。
class Man //友元的宿主类友元的宿主类 { friend class Thief; //声明友元类声明友元类 public: Man(): money(100){}; //将初始的金钱数设置为将初始的金钱数设置为100 将初始的金钱数设置为 int main() void SpendMoney() { money --; } { ReportMoney() { return money; } int Man man; private: man.SpendMoney(); int money; cout << man.ReportMoney() << endl; // 99 }; Thief thief; class thief.ThieveMoney(man); Thief //友元类的定义友元类的定义 { cout << man.ReportMoney() << endl; // 89 public: voidreturn 0; ThieveMoney(Man& haplessMan) 99 { haplessMan.money -= 10; } 89 } };

运算符重载使得用户自定义的数据以一种更简洁的方式工作

{
// 相对于该类定义的操作
} ➢ 一个运算符被重载后，原有意义没有失去，只是定义了相对一特定类的一个新运算符
华南理工大学计算机学院周霭如 2004
#include<iostream.h> #include<stdlib.h> class Calculator { public:
Calculator() { value = 0 ; } ; void operator ++ () ; void operator -- () ; unsigned int operator() () ; private: unsigned int value; }; void main()
{ -- Counter;
cout << "\n Counter = " << Counter() ;
}
}
华南理工大学计算机学院周霭如 2004
6.1.2 运算符重载的语法形式
例6-1 设计一个安全计数器
void Calculator :: operator ++ ()
void Calculator::operator ++ ()
{ cout << "\nData overflow !" << endl ; abort() ; } } void Calculator::operator --() { if ( value > 0 ) value -- ; else { cout << "\n Data overflow !" << endl ; abort() ; } } unsigned int Calculator::operator() () { return value ; }

实验11 运算符重载与模板实验思考

实验11 运算符重载与模板三、实验思考1．定义一个描述矩阵的类Array，其数据成员为3×3实数矩阵，用Put()成员函数输入矩阵元素值，重载“+”运算符完成两个矩阵的加法。

分别用成员函数与友元函数编写运算符重载函数。

在主函数中定义矩阵对象a1、a2、a3，进行矩阵加法a3=a1+a2运算，并输出矩阵a1、a2、a3的全部元素值。

#include <iostream>using namespace std;class Array{public:Array(int m, int n);//构造函数：用于建立动态数组存放m行n列的二维数组（矩阵）元素，并将该数组元素初始化为Array(const Array &d);~Array(){delete [] Array;} //析构函数：用于释放动态数组所占用的存储空间。

friend istream & operator >> (istream &input, Array &d);//重载运算符“>>”输入二维数组，其中d为Dousry类对象；friend ostream & operator << (ostream &output, Array &d);//重载运算符“<<”以m行n列矩阵的形式输出二维数组，//其中d为Array类对象。

friend Array operator + (const Array &d1, const Array &d2);//两个矩阵相加，规则：对应位置上的元素相加private:int * Array; //Array 为动态数组指针。

int row; //row 为二维数组的行数。

int col; //col 为二维数组的列数。

};Array::Array(int m, int n){row = m, col = n;Array = new int [row*col];for (int i = 0; i < row*col; i++)Array[i] = 0;}Array::Array(const Array &d){col = d.col, row = d.row;Array = new int[row*col];for (int i = 0; i < row*col; i++)Array[i] = d.Array[i];}istream & operator >> (istream &input, Array &d){cout << "请输入元素（" << d.row << "行" << d.col <<"列）：" << endl; for (int i = 0; i < d.col*d.row; i++){input >> d.Array[i];}return input;}ostream & operator << (ostream &output, Array &d){for (int i = 0; i < d.col*d.row; i++){if (i % d.col == 0) cout << endl;output << d.Array[i] <<'\t';}cout << endl;return output;}Array operator + (const Array &d1, const Array &d2){Array D(d1);for (int i = 0; i < d1.col*d1.row; i++)D.Array[i] = d1.Array[i] + d2.Array[i];return D;}int main(){Array a1(3, 3), a2(3, 3),a3(3,3);cout << "输入a1:" << endl;cin >> a1;cout << "输入a2:" << endl;cin >> a2;cout << "a1=" ;cout << a1;cout << "a2=";cout << a2;a3=a1+a2;cout << "a1+a2=";cout << a3;return 0;}2．定义描述平面任意点坐标(X,Y)的类Point，编写“-”运算符重载函数，使该函数能求出平面上任意两点的距离。

实验11 运算符重载资料

实验11 运算符重载（1）一、实验目的1、掌握运算符重载的概念；2、掌握使用friend重载运算符的方法。

二、实验内容1、用成员函数重载运算符，使对整型的运算符=、+、-、*、/ 适用于分数运算。

要求：（1）输出结果是最简分数（可以是带分数）；（2）分母为1，只输出分子。

2、用友元函数重载运算符，使对整型的运算符=、+、-、*、/ 适用于分数运算。

3、定义如下集合类的成员函数，并用数据进行测试：class Set{int *elem; //存放集合元素的指针int count; //存放集合中的元素个数public:Set();Set(int s[],int n);int find(int x) const; //判断x是否在集合中Set operator+(const Set &); //集合的并集Set operator-(const Set &); //集合的差集Set operator*(const Set &); //集合的交集void disp(); //输出集合元素};4、定义一个人民币类 RMB，包含私有数据成员元、角、分，请用友元函数重载运算符“+”和“++”，以对类对象进行运算。

三、实验程序及结果#include<iostream>using namespace std;class Complex{public:Complex(int X=0,int Y=0) //构造函数初始化{x=X;y=Y;}void gys() //求最大公约数{int t;t=x%y;while(t!=1){x=y;y=t;t=x%y;}}void print() //输出分数值{int z;if((x<y)&&(y!=1)) //分母大于分子直接输出{cout<<x<<"/"<<y<<endl;}if((x>y)&&(y!=1)) //分母小于分子输出带分数{z=x/y;cout<<z<<"("<<x%y<<"/"<<y<<")"<<endl;}}Complex operator+(Complex c); //声明运算符重载函数Complex operator-(Complex c);Complex operator*(Complex c);Complex operator/(Complex c);private:int x,y;};Complex Complex::operator+(Complex c) //定义+重载函数{Complex temp1;if(y!=c.y)temp1.y=y*c.y;temp1.x=x*c.y+c.x*y;}return temp1;}Complex Complex::operator-(Complex c) //定义-重载函数{Complex temp1;if(y!=c.y){temp1.y=y*c.y;temp1.x=x*c.y-c.x*y;}return temp1;}Complex Complex::operator*(Complex c) //定义*重载函数{Complex temp1;if(y!=c.y){temp1.y=y*c.y;temp1.x=x*c.x;}return temp1;}Complex Complex::operator/(Complex c) //定义/重载函数{Complex temp1;if(y!=c.y){temp1.y=y*c.x;temp1.x=x*c.y;}return temp1;}int main(){Complex A1(3,2),A2(5,7),A3,A4,A5,A6; //定义六个类的对象A1.print(); //输出分数A2.print();A3=A1+A2; //分数相加A3.print();A4=A1-A2; //分数相减A4.print();A5=A1*A2; //分数相乘A5.print();A6=A1/A2; //分数相除A6.print();return 0;}2.（注释同上）#include<iostream.h>//using namespace std;class Complex{public:Complex(int X=0,int Y=0){x=X;y=Y;}void gys(){int t;t=x%y;while(t!=1){x=y;y=t;t=x%y;}}void print(){int z;if((x<y)&&(y!=1)){cout<<x<<"/"<<y<<endl;}if((x>y)&&(y!=1)){z=x/y;cout<<z<<"("<<x%y<<"/"<<y<<")"<<endl;}}friend Complex operator+(Complex& a,Complex& b); friend Complex operator-(Complex& a,Complex& b); friend Complex operator*(Complex& a,Complex& b); friend Complex operator/(Complex& a,Complex& b);private:int x,y;};Complex operator+(Complex& a,Complex& b){Complex temp1;if(a.y!=b.y){temp1.y=a.y*b.y;temp1.x=a.x*b.y+b.x*a.y;}return temp1;}Complex operator-(Complex& a,Complex& b){Complex temp1;if(a.y!=b.y){temp1.y=a.y*b.y;temp1.x=a.x*b.y-b.x*a.y;}return temp1;}Complex operator*(Complex& a,Complex& b) {Complex temp1;if(a.y!=b.y){temp1.y=a.y*b.y;temp1.x=a.x*b.x;}return temp1;}Complex operator/(Complex& a,Complex& b) {Complex temp1;if(a.y!=b.y){temp1.y=a.y*b.x;temp1.x=a.x*b.y;}return temp1;}int main(){Complex A1(3,2),A2(5,7),A3,A4,A5,A6,G; A1.print();A2.print();A3=A1+A2;A3.print();A4=A1-A2;A4.print();A5=A1*A2;A5.print();A6=A1/A2;A6.print();return 0;}3.#include<iostream>using namespace std;class Set{int *elem; //存放集合元素的指针int count; //存放集合中的元素个数public:Set(){};Set(int s[],int n);int find(int x) const; //判断x是否在集合中Set operator+(const Set &a); //集合的并集Set operator-(const Set &a); //集合的差集Set operator*(const Set &a); //集合的交集void disp(); //输出集合元素};Set::Set(int s[],int n) //构造函数初始化{elem=s;count=n;}int Set::find(int x) const //判断x是否在集合中{int n;for(n=0;n<count;n++){if(x=elem[n])cout<<"x在集合中"<<endl;return 1;}return 0;}Set Set::operator +(const Set& a) //重载运算符+求两数组的并集{Set temp;int k=0,m,n,p;int *b=new int [k];for(n=0;n<a.count;n++){b[k]=a.elem[n];k++;}for(m=0;m<count;m++) //定义一个新数组，使其等于elem[],找出另一个数组中不相等的数，放进另一个数组，两个新数组连接着输出，即为他们的并集{for(n=0;n<a.count;n++){if(elem[m]==a.elem[n]){p=1;continue;}}}for(m=0;m<count;m++){if(p!=1){b[k]=elem[m];k++;}}cout<<endl;temp.count=k;temp.elem=b;return temp;}Set Set::operator -(const Set& a) //定义重载运算符-用于计算差集{Set temp;int p=0,m,n,q;int *b=new int [p];for(m=0;m<count;m++){for(n=0;n<a.count;n++) //找出两数组不相等的数，把只是属于elem的数放进新数组中，输出即为A-B{if(elem[m]==a.elem[n]){q=1;continue;}}}for(m=0;m<count;m++){if(q!=1){b[p]=elem[m];p++;}}cout<<endl;temp.count=p;temp.elem=b;return temp;}Set Set::operator *(const Set& a) //定义重载运算符*计算两数组交集{Set temp;int k=0,m,n;int *b=new int [k];for(m=0;m<count;m++) //如果两数组的值相等，把相等的值放进新数组，输出即为交集{for(n=0;n<a.count;n++){if(elem[m]==a.elem[n]){b[k]=elem[m];k++;}}}cout<<endl;temp.count=k;temp.elem=b;return temp;}void Set::disp(){for(int i=0;i<count;i++){cout<<elem[i]<<" ";}cout<<endl;}int main(){int aa[4]={1,2,3,4};int bb[5]={3,4,5,6,7};Set A,B,C,D,E;A=Set(aa,4);B=Set(bb,5);A.find(2);A.disp();B.disp();E=A*B;cout<<"两个数组的交集为："<<endl;E.disp();C=A+B;cout<<"两个数组的并集为："<<endl;C.disp();D=A-B;cout<<"两个数组的差集为："<<endl;D.disp();return 0;}4.#include<iostream.h>//using namespace std;class Complex{public:Complex(int X=0,int Y=0,int Z=0) {x=X;y=Y;z=Z;}void print(){if(z>=10){ z=z-10;y=y+1;if(y>=10){y=y-10;x=x+1;}}cout<<x<<"元"<<y<<"角"<<z<<"分"<<endl;}Complex operator+(Complex c); //声明运算符重载函数Complex operator++(); //声明自减运算符--重载成员函数（前缀）Complex operator++(int); //声明自减运算符--重载成员函数（后缀）private:int x,y,z;};Complex Complex::operator+(Complex c) //定义+重载函数{Complex temp1;temp1.x=x+c.x;temp1.y=y+c.y;temp1.z=z+c.z;return temp1;}Complex Complex::operator++() //定义++重载函数（前缀）{++x;++y;++z;return *this;}Complex Complex::operator++(int) //定义++重载函数（后缀）{Complex temp(*this);x++;y++;z++;return temp;}int main(){Complex A(7,8,9),B(4,5,6),C; //定义四个类的对象A.print(); //输出对象A的值B.print(); //输出对象B的值C=A+B; //两对象A、B相加C.print(); //输出相加后的值++A; //执行++前缀A.print(); //输出执行后的值B++; //执行++后缀B.print(); //输出执行后的值return 0;}。

c++运算符重载原理

c++运算符重载原理
运算符重载，也称作运算符多态，是是指程序员可以重新定义C++中现有的运算符，使之能够应用到自定义的类型上（它只能用于类和结构，而不能用于其它类型）。

原理:
运算符重载是指把原来的表达式分解成不同的函数，然后根据类型参数和运算符重新组合成函数。

当执行运算符重载的表达式时，C++编译器会自动检测表达式的运算符，然后调用相关的函数进行处理。

具体过程如下：1、编译器检测运算符，分解表达式为不同的函数；2、编译器在自定义类中查找运算符函数；3、如果找到，调用函数处理表达式；4、如果没有找到，调用C++编译器默认的处理方式。

11章运算符重载

运算符重载的规则

c++ 运算符重载的写法

[C++]运算符重载实验报告

简述运算符重载的规则。

第11讲 运算符重载和string类

简述运算符重载的规则。

c++运算符重载实验心得

运算符重载—C++课程实验报告

运算符重载-- 实验报告

运算符重载实验报告

运算符重载解读

C++程序设计11-运算符重载(续)

运算符重载使得用户自定义的数据以一种更简洁的方式工作

实验11 运算符重载与模板 实验思考

实验11 运算符重载资料

c++运算符重载原理

第11讲运算符重载和string类

实验11 运算符重载与模板实验思考