第十八章 运算符的重载
C++基础系列——运算符重载
C++基础系列——运算符重载1. 运算符重载简介所谓重载，就是赋予新的含义。
函数重载（Function Overloading）可以让⼀个函数名有多种功能，在不同情况下进⾏不同的操作。
同样运算符重载（Operator Overloading）可以让同⼀个运算符可以有不同的功能。
可以对 int、float、string 等不同类型数据进⾏操作<< 既是位移运算符，⼜可以配合 cout 向控制台输出数据也可以⾃定义运算符重载：class Complex{public:Complex();Complex(double real, double imag);Complex operator+(const Complex &a) const;void display() const;private:double m_real;double m_imag;};// ...// 实现运算符重载Complex Complex::operator+(const Complex &A) const{Complex B;B.m_real = this->m_real + A.m_real;B.m_imag = this -> m_imag + A.m_imag;return B;// return Complex(this->m_real + A.m_real, this->m_imag + A.m_imag);}int main(){Complex c1(4.3, 5.8);Complex c2(2.7, 3.7);Complex c3;c3 = c1 + c2; // 运算符重载c3.display();return 0;}运算结果7 + 9.5i运算符重载其实就是定义⼀个函数，在函数体内实现想要的功能，当⽤到该运算符时，编译器会⾃动调⽤这个函数，它本质上是函数重载。
运算符重载
第八部分运算符重载第18章第18章运算符重载18.1 运算符重载的需要性1. 所谓运算符重载，就是对已有的运算符重新进行定义，赋予其另一种功能，以适应不同的数据类型。
例18.1class A{public:A(int x) {a=x;}protected:int a;};A a(5),b(10),c;c=a+b; //错误，因＋运算符不适合类对象，但我们可重载该运算符，使其适应类对象。
18.2 如何重载运算符1. 运算符重载是通过运算符重载函数完成的。
运算符重载函数可以是类的成员函数，也可以是类的友元函数。
2. 运算符重载函数定义格式。
(1)单目运算符重载函数定义类型 operator 单目运算符(参数) 函数体函数名(2)双目运算符重载函数定义类型 operator 双目运算符(参数1, 参数2) 函数体函数名(3)单目运算符重载函数调用operator 单目运算符(实参实参(3)单目运算符重载函数调用operator 双目运算符(实参1, 实参 1 双目运算符实参23．因成员函数有一个默认的参数this，故运算符重载函数是类的成员函数时，其参数可比格式中的参数少一个。
例18.2用友元函数对二维向量重载双目运算符+和单目运算符++。
#include<iostream.h>class vector{int x,y;public:vector();vector(int x1,int y1);void print();friend vector operator ++(vector& v1,int);// 单目运算符++重载函数原型friend vector operator +(vector& v1,vector& v2); // 双目运算符+重载函数原型};vector:: vector (){x=0;y=0;}vector:: vector (int x1,int y1) {x=x1;y=y1;}void vector::print(){cout<<"\n("<<x<<","<<y<<")";}vector operator ++(vector& v1,int){vector v2(v1.x,v1.y);v1.x++;v1.y++;return v2;}vector operator +( vector& v1,vector& v2){vector v0;v0.x=v1.x+v2.x;v0.y=v1.y+v2.y;return v0;}main(){vector v1(10,10);v1.print();vector v11;v11=v1++;//即v11=operator ++(v1,1);v1.print();v11.print();vector v2(20,20);(v1+v2).print();//即operator +(v1,v2).print();vector v3;v3=v1+v2;//即v3=operator +(v1,v2);v3.print();v3++.print();//即operator ++(v3,1).print();return 0;}(10,10)(11,11)(10,10)(31,31)(31,31)(31,31)例18.3用成员函数对二维向量重载双目运算符+和单目运算符++。
运算符重载(面向对象程序设计C++)
运算符重载运算符重载的本质是函数重载，它也是C++多态的一种体现，为用户提供了一个直观的接口，调用运算符操作自定义数据类型其实就是调用运算符函数。
运算符重载增强了C++的可扩充性，使得C++代码更加直观、易读，且便于对对象进行各种运算操作。
重载的运算符是具有特殊名字的函数：它们的名字由关键字operator 和其后要重载的运算符共同组成。
语法格式 返回类型 operator 运算符（参数列表）{函数体; }运算符重载规则：只能重载C++中已有的运算符，不能创建新的运算符。
重载之后的运算符不能改变其优先级和结合性，也不能改变其操作数的个数及语法结构。
避免没有目的地使用重载运算符。
类属关系运算符“.”、成员指针运算符“*”、作用域运算符“::”、sizeof 运算符和三目运算符“?:”不可以重载。
输入输出运算符的重载 IO 标准库使用“>>”和“<<”运算符执行输入输出操作，对于这两个运算符来说，IO 库定义了其基本数据类型的操作，但若要直接对类对象进行输入输出，则需要在类中重载这两个运算符。
输入运算符语法格式istream& operator>>(istream&, 类对象引用);输出运算符语法格式ostream& operator<<(ostream&,const 类对象引用); 关系运算符的设计准则关系运算符都要成对的重载。
“==”运算符应该具有传递性当成对出现运算符重载时，可以把一个运算符的工作委托给另一个运算符。
赋值运算符的重载对于赋值运算符来说，如果不重载，那么类会自动为我们提供一个赋值运算符。
这个默认的赋值运算符跟默认拷贝构造函数一样，就是把一个对象的数据成员的值复制给另一个对象对应的数据成员。
下标运算符的重载返回类型 operator[] (参数列表);重载“[]”运算符可以实现两个目的：（1）“对象[下标]”的形式类似于“数组[下标]”，更加符合习惯。
C_运算符重载_各类详细介绍
▪ 说明
运算符重载函数 operator@()可以返回任何类型，甚至可 以是 void类型，但通常返回类型与它所操作的类的类型 相同，这样可使重载运算符用在复杂的表达式中。例如， 在例7-2中，可以将几个复数连续进行加、减、乘、除的 运算。
用友元函数重载单目运算符时，需要一个显式的操作数， 例7-3中，用友元函数重载单目运算符“-”
#include<iostream.h> class nclass{ int a,b; public:
nclass(int x=0,int y=0) { a=x;b=y;} friend nclass operator -(nclass obj); void show(); };
▪ complex operator+(complex com1,complex com2) { return complex(com1.real+com2.real,com1.imag+com2.imag;}
▪ 这种方法是直接将一个无名临时对象创建到主调函数中，那么 运行效率高于前一种。
▪ 单目运算符重载
nclass operator-(nclass obj) { obj.a=-obj.a;
obj.b=-obj.b; return obj;} void nclass::show() { cout<<"a="<<a<<" b"<<b;} ▪ main() ▪{ ▪ nclass ob1(10,20),ob2; ▪ ob1.show(); ▪ ob2=-ob1; ▪ ob2.show(); ▪ return 0; ▪}
运算符重载的方法
运算符重载的方法
运算符重载是指在类中重新定义某个运算符，使其能够用于类的实例。
重载运算符可以方便地对类对象进行加、减、乘、除等基本运算，也可以定义自定义运算符，以实现类特定的功能。
运算符重载的方法如下：
1.编写运算符重载函数：将要重载的运算符的符号作为函数名，如“+”、“-”、“*”、“/”等，对于自定义运算符可以自己命名。
2.指定参数个数和类型：重载函数需要参数，这些参数有不同的类型，可以是类的成员变量或其他类型的变量。
3.重载运算符要求：
（1）操作数至少有一个是类的实例，重载函数可以定义为类的成员函数或全局函数。
（2）运算符重载不能改变原有操作数的类型或个数。
（3）运算符重载函数可以返回任何类型的值，甚至可以是类的实例。
4.使用运算符：一旦重载运算符函数定义好之后，就可以像使用普通的运算符一样使用它。
需要注意的是，运算符重载不是万能的，对于某些运算符，如“&&”、“”等，是不能够重载的。
此外，在使用运算符重载时应该避免过于复杂的实现方式，以防止代码难以理解和维护。
结构体重载运算符
结构体重载运算符
运算符重载是指在C++程序设计语言中，可以为现存的类型定义新的运算符的
功能。
运算符重载也就是给C++中的某些运算符功能上增加定义和改变其内部操作
以适应业务程序需求、提高程序开发效率而实现的技术。
运算符重载对于改善C++程序设计语言的结构表达和可读性都有着重要的作用。
它使得在C++程序设计过程中，可以利用运算符重载将复杂的算法编写简洁，更容
易理解，并且更有利于程序可维护性和可维护性。
一般来说，重载的运算符必须是类的成员函数，而且也不能对运算符的优先级
有改变，而改变其函数原型。
当某个运算符被重载时，它可以按照开发者的要求来处理数据。
例如，可能需要定义一个加法运算符“+”，但是此加法运算符可以处
理不同类型或参数的数据，以便在实际开发过程中更方便。
此外，要使用运算符重载，还需要遵循限制使用运算符的规则，例如，要使用
类中的成员函数定义运算符，且不能重载任何C++系统或类型操作符，因此必须时
刻注意自己的操作，以免搞砸整个运算符重载，对程序编写带来干扰。
总之，运算符重载的主要用途在于改善C++程序编写的优雅性和简洁性，以及
提高开发者使用程序设计语言的效率。
像一些复杂的运算符一样，重载运算符可以帮助程序员实现更有效、更简洁的算法，因此可以将难以理解和记忆的复杂混乱的算法变成一句简单的话。
运算符重载
24
运算符重载
思考:如果希望表达式i+c1有意义, 思考:如果希望表达式i+c1有意义,应该 i+c1有意义 如何定义重载运算符函数? 如何定义重载运算符函数?
friend Complex operator+(int &i,Complex &c); Complex operator+(int &i, Complex &c) {return Complex(i+c.real,c.imag);}
2
什么是运算符重载
代码分析: 代码分析: 例10.1 通过函数来实现复数 相加。 相加。
CCS E
3
运算符重载的方法
运算符重载的方法是定义一个重载运 算符的函数， 算符的函数，在需要执行被重载的运 算符时，系统就自动调用该函数， 算符时，系统就自动调用该函数，以 实现相应的运算。也就是说， 实现相应的运算。也就是说，运算符 重载是通过定义函数实现的。 重载是通过定义函数实现的。运算符 重载实质上是函数的重载。 重载实质上是函数的重载。
CCS E
21
运算符重载
如果将运算符重载函数作为成员函数， 如果将运算符重载函数作为成员函数， 它可以通过this this指针自由地访问本类 它可以通过this指针自由地访问本类 的数据成员， 的数据成员，因此可以少写一个函数 的参数。 的参数。但必须要求运算表达式第一 个参数(即运算符左侧的操作数) 个参数(即运算符左侧的操作数)是一 个类对象， 个类对象，而且与运算符函数的类型 相同。 相同。因为必须通过类的对象去调用 该类的成员函数，而且只有运算符重 该类的成员函数， 载函数返回值与该对象同类型， 载函数返回值与该对象同类型，运算 结果才有意义。 结果才有意义。
简述运算符重载的规则。
简述运算符重载的规则。
篇一：运算符重载是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. 逻辑运算符重载逻辑运算符包括条件运算符和逻辑非运算符。
每个逻辑运算符都有一组默认的行为,可以通过运算符重载来自定义它们的行为。
第18章运算符重载
运算符+重载
编译原理：将运算符+重载为类的成员函数后， C++编译系统将程序中的表达式c1+c2解释为 c1.operator+(c2) 运算符被重载后，其原有的功能仍然保留。
运算符重载将运算符和类的对象结合在一起 使用，比一般函数调用更清晰，提供了C++ 使用，比一般函数调用更清晰，提供了 的可扩展性
不能被重载的 不能被重载的运算符 . .* :: ?: sizeof
重载规律
一般将单目运算符重载为成员函数，将双目运算符 重载为友元函数。 有的运算符必须定义为类成员函数
赋值运算符、下标运算符、函数调用运算符
有的运算符必须定义为类的友元函数
流插入“<<”和流提取运算符“>>”、类型转换运算符
重载一元运算符
时间计数器 #include <iostream.h> class Time {public: Time( ){minute=0;sec=0;} Time(int m, int s):minute(m),sec(s){ } Time operator++( ); void display( ){ cout<<minute<<″:″<<sec<< endl;} private: int minute; int sec; };
1.成员函数方式
Complex Complex∷complex_add(Complex &c2) ∷ { Complex c; c.real=real+c2.real; c.imag=imag+c2.imag; return c;} void Complex∷display( ) ∷ {cout<<″(″<<real<<″,″<<imag<<″i)″<<endl;} int main( ) { Complex c1(3,4), c2(5,-10), c3; c3=plex_add(c2); cout<<″c1=″; c1.display( ); cout<<″c2=″; c2.display( ); cout<<″c1+c2=″; c3.display( ); return 0;
运算符重载——精选推荐
运算符重载运算符重载学习运算符重载，让运算符能做⼀些原来做不了的事情，⽅便它的使⽤⼀、运算符重载的概念1、什么是运算符重载1.重载：重新载⼊，就像之前学的函数重载，对⼀个已有的函数赋值⼀个新的定义，因此同⼀个函数名就可以有不同的含义。
2.运算符也是可以重载的，⽐如cout在输出⼀个变量的时候，能接受不同类型的数据并输出，他就是重载了<<运算符，这个就是运算符重载3.所以运算符重载指的是对已有的运算符重新定义新的运算规则，以适应不同的数据类型，当然重载之后之前的运算规则还是有的2、为什么要进⾏运算符重载1.运算符重载之后可以让运算符去适应不同的数据类型，对于基本数据类型，系统给出了运算符的操作规则，对于⾃定义数据类型来说，系统不知道该给出什么规则class student{int id;int age;char name[20];public:student(int id,int age,const char* name){this->id=id;this->age=age;strcpy(this->name,name);}}student stu1(1,23,"张三");student stu2(2,24,"李四");stu1+stu2;//如果是这样相加，那么应该加的是什么呢？编译器是不知道的，所以编译器就提供了运算符重载这个机制，让⽤户⾃定义运算符的运算规则⼆、运算符重载1、运算符重载类中定义1.关键字：operator，通过关键字来定义运算符重载(跟写个函数⼀样)2.定义：函数返回值类型 operator 要加载的运算符(参数列表){函数体；}这⾥把运算符的使⽤，理解为调⽤函数，只是和平时的调⽤函数有⼀点区别#include<iostream>#include<string>using namespace std;class student{int id;int age;string name;public:student(int age){this->age = age;id = 1;name = "sss ";}student(int id, int age, string name){this->id = id;this->age = age;this->name = name;}void showstudent(){cout << id << "\t" << age << "\t" << name << endl;}student operator+(student& p1)//这个函数会返回⼀个新的对象{int x=this->age + p1.age;student p(x);return p;//返回的是⼀个对象，会调⽤拷贝构造}int operator-(int x){return this->id - x;}void operator+(student&p2){cout << this->id + p2.id << endl;}};//1.操作这个运算符之后，返回值类型是什么int main(){student p1(0, 1, "yunfei");int x = p1.operator-(1);cout << x << endl;student stu1(1, 23, "张三");student stu2(2, 24, "李四");//student stu3 = stu1.operator+(stu2);//student stu3 = stu1 + stu2;stu1 + stu2;//stu3.showstudent();system("pause");return 0;}注意：因为我们这个运算符是在类中写的，所以是通过对象调⽤的，那么this指针会占⼀个参数，⽽且是第⼀个参数，也就是说我们重载⼀个运算符，是在类中，⽽这个运算符是个单⽬运算符，那么参数列表就不⽤写东西了，是双⽬运算符，那么就需要传另⼀个参数进来绝⼤部分的运算符重载都可以参照上⾯这个+号重载2、运算符重载的特点1.⼏乎所有的运算符都可以被重载，除了 . :: ()?() ) sizeof()2.运算符重载基本出现在类中和结构体中3.运算符可以理解为函数的⼀个表现3、运算符重载的注意事项1.重载运算符，这个重载的运算符还是满⾜原来的原则，但不能说重载+号，结果做的事-号的事，这样会使运算符的运⽤上增加很⼤的难度2.运算符重载的参数，类中重载调⽤对象会占⼀个参数，就是this会占⼀个参数，参数列表就是⽤来表⽰运算符的操作的3.对于运算符重载的调⽤，可以直接使⽤运算符，也可以通过对象 . 出来调⽤4.考虑返回值，不同的运算符有不同的返回值，要记得满⾜运算符原来的规则4、使⽤友元函数，实现运算符重载1.类在已经实现且部分修改的情况下下，需要进⾏运算符重载，就可以通过友元的⽅式来进⾏重载#include<iostream>#include<string>using namespace std;class person{int id;int age;string name;public:person(int id, int age, string name){this->id = id;this->age = age;this->name = name;}void showperson(){cout << id << "\t" << age << "\t" << name << endl;}friend int operator+(person&p1, person&p2);};//形参使⽤的是类对象的引⽤，在实参传对象的时候不会调⽤拷贝构造int operator+(person&p1, person&p2){return p1.id + p2.id;}//1.操作这个运算符之后，返回值类型是什么int main(){person stu1(1, 23, "张三");person stu2(2, 24, "李四");int x = operator+(stu1, stu2);//显⽰调⽤int y = stu1 + stu2;//隐式调⽤cout << x << endl << y << endl;system("pause");return 0;}容器：#include<iostream>#include<vector>using namespace std;int main(){//int 是v1这个容器存的类型vector<int> v1;for (int i = 0; i < 10; i++){//push_back()是⼀个函数，功能是尾插元素v1.push_back(i + 1);}for (int i = 0; i < 10; i++){cout << v1[i] << "\t";}system("pause");return 0;}左移右移运算符重载：#include<iostream>using namespace std;class person{int id;public:person(int id){this->id = id;}friend ostream& operator<<(ostream& os, person& p1);friend istream & operator>>(istream & in, person & p2);};//左移右移运算符重载，必须在类外重载，通过友元实现ostream& operator<<(ostream& os, person& p1)//左移运算符{os << p1.id << endl;return os;//返回的是⼀个cout,⽽且只能⽤引⽤}istream & operator>>(istream & in, person & p2)//右移运算符{in >> p2.id;return in;}int main(){person p1(10), p2(20);cin >> p1 >> p2;cout << p1 << endl << p2 << endl;system("pause");return 0;}前++，后++运算符重载：#include<iostream>using namespace std;class person{int id;public:person(int id){this->id = id;}person& operator++()//前++{this->id++;return *this;}person& operator++(int)//后++,int是⼀个占位符，⽤来区分前++和后++的{static person temp = *this;//引⽤不能返回局部变量，要⽤静态变量this->id++;return temp;}friend ostream& operator<<(ostream& os, person& p1);friend istream & operator>>(istream & in, person & p2);};//左移右移运算符重载，必须在类外重载，通过友元实现ostream& operator<<(ostream& os, person& p1)//左移运算符{os << p1.id << endl;return os;//返回的是⼀个cout,⽽且只能⽤引⽤}istream & operator>>(istream & in, person & p2)//右移运算符{in >> p2.id;return in;}int main(){person p1(10), p2(20);//cin >> p1 >> p2;//cout << p1 << endl << p2 << endl;cout << p1 ;//10cout << p1++ ;//10cout << p1 ;//11cout << ++p1 ;//12cout << p1 ;//12system("pause");return 0;}等号运算符重载：#include<iostream>using namespace std;class person{char* name;public:person(const char* name){this->name = new char[strlen(name) + 1];strcpy(this->name, name);}person& operator=(person&p1)//⽤不⽤引⽤传参，要看返回的对象会不会消失 {if (this->name != NULL){delete[]this->name;this->name = NULL;}this->name = new char[strlen() + 1];strcpy(this->name, );return *this;}void show(){cout << name << endl;}~person()//如果有申请函数，就要加上析构函数{if (name != NULL){delete[]name;name = NULL;}}};int main(){{person p1("张三"), p2("李四"), p3("王五");p1 = p2 = p3;p1.show();p2.show();p3.show();}//加上⼤括号，让对象死亡，就能调⽤析构函数system("pause");return 0;}智能指针和==号运算符重载：#include<iostream>using namespace std;class person{int id;public:person(int id){this->id = id;}void show(){cout << id << endl;}bool operator==(person& p){return this->id == p.id;}~person(){cout << "person的析构函数" << endl;}};class smartpointer{person* ps;//包含你要new出来的对象的类的指针public:smartpointer(person* p){ps = p;}//重载->person* operator->()//传回来的是地址，不是对象，不⽤引⽤{return ps;}//重载*person& operator*()//返回的是对象，会调⽤拷贝构造，所以⽤返回值⽤引⽤，就不会再调⽤拷贝构造了 {return *ps;//得到⼀个对象，}~smartpointer(){if (ps != NULL){delete ps;ps = NULL;}}};int main(){{smartpointer p(new person(5));p->show();(*p).show();person p1(1), p2(3);cout << (p1 == p2) << endl;}//有三个对象，所以析构函数执⾏了三次system("pause");return 0;}[]运算符重载：#include<iostream>using namespace std;class person{char* name;public:person(const char* name){this->name = new char[strlen(name) + 1];strcpy(this->name, name);}char& operator[](int index){return name[index];}~person(){if (name != NULL){delete[]name;name = NULL;}cout << "这是析构函数" << endl;}};int main(){person p("asdfg");cout << p[3] << endl;system("pause");return 0;}c++引⽤作为函数返回值：1.以引⽤返回函数值，定义函数时需要在函数名前加 &2.⽤引⽤返回⼀个函数值的最⼤好处是，在内存中不产⽣被返回值的副本3.返回值为引⽤的时候，返回的是⼀个地址，隐形指针4.当返回值不是引⽤时，编译器会专门给返回值分配出⼀块内存的引⽤作为返回值，必须遵守以下规则：（1）不能返回局部变量的引⽤。
《C运算符重载》PPT课件
h
4
二元运算符重载（2）
函数的返回值 返回引用 返回非常量值 返回常量值 返回值优化
重载+和+=运算符对（- -=， * *=， 等）
h
5
重载赋值p; operator=(const T&);
默认的赋值运算
限制赋值运算
重载赋值运算符
原因：成员有指针，并动态分配内存时。 检查自我赋值：
• 效率
• a=a； 的情况
h
6
一元运算符
全局函数 成员函数 增量/减量运算符（++/--）
前缀：T& operator++ (); 后缀：T operator++(int);
迭代器
h
7
重载运算符的方针
运算符 所有的一元运算符 = () [] -> ->* += -= *= /= ^=&=|=%=>>=<<= 成员 所有其他二元运算符
成员 非成员
建议使用 必须是成员
h
8
运算符重载
h
1
重载运算符
意义（例）
重载条件 自定义的类型 不可重载的运算符 :: . ->* 不可使用新的运算符
运算符重载 一元/二元运算符： 全局函数/成员函数
h
2
二元运算符重载（1）
全局函数格式： 成员函数的格式： 重载后的表达式形式(成员函数)
左结合：a+b+c; (a.operator+(b)).operator+(c)
运算符重载——精选推荐
运算符重载什么是运算符的重载?运算符与类结合，产⽣新的含义。
为什么要引⼊运算符重载？作⽤：为了实现类的多态性(多态是指⼀个函数名有多种含义)怎么实现运算符的重载？⽅式：类的成员函数或友元函数（类外的普通函数）规则：不能重载的运算符有 . 和 .* 和 ?: 和 :: 和 sizeof友元函数和成员函数的使⽤场合：⼀般情况下，建议⼀元运算符使⽤成员函数，⼆元运算符使⽤友元函数1、运算符的操作需要修改类对象的状态，则使⽤成员函数。
如需要做左值操作数的运算符（如=，+=，++）2、运算时，有数和对象的混合运算时，必须使⽤友元3、⼆元运算符中，第⼀个操作数为⾮对象时，必须使⽤友元函数。
如输⼊输出运算符<<和>>具体规则如下：运算符建议使⽤所有⼀元运算符成员函数＝ ( ) [ ] ->必须是成员函数+= -= /= *= ^= &= != %= >>= <<= , 似乎带等号的都在这⾥了成员函数所有其它⼆元运算符, 例如: –,+,*,/友元函数<< >>必须是友元函数2. 参数和返回值当参数不会被改变，⼀般按const引⽤来传递(若是使⽤成员函数重载，函数也为const).对于返回数值的决定:1) 如果返回值可能出现在=号左边, 则只能作为左值, 返回⾮const引⽤。
2) 如果返回值只能出现在=号右边, 则只需作为右值, 返回const型引⽤或者const型值。
3) 如果返回值既可能出现在=号左边或者右边, 则其返回值须作为左值, 返回⾮const引⽤。
运算符重载举例：+和 -运算符的重载:class Point{private:int x;public:Point(int x1){ x=x1;}Point(Point& p){ x=p.x;}const Point operator+(const Point& p);//使⽤成员函数重载加号运算符friend const Point operator-(const Point& p1,const Point& p2);//使⽤友元函数重载减号运算符};const Point Point::operator+(const Point& p){return Point(x+p.x);}Point const operator-(const Point& p1,const Point& p2){return Point(p1.x-p2.x);}输出：Point a(1);Point b(2);a+b; //正确，调⽤成员函数a-b; //正确，调⽤友元函数a+1; //正确，先调⽤类型转换函数，把1变成对象，之后调⽤成员函数a-1; //正确，先调⽤类型转换函数，把1变成对象，之后调⽤友元函数1+a; //错误，调⽤成员函数时，第⼀个操作数必须是对象，因为第⼀个操作数还有调⽤成员函数的功能1-a; //正确，先类型转换后调⽤友元函数总结：1、由于+ -都是出现在=号的右边，如c=a+b，即会返回⼀个右值，可以返回const型值2、后⼏个表达式讨论的就是，数和对象混合运算符的情况，⼀般出现这种情况，常使⽤友元函数3、双⽬运算符的重载：重载运算符函数名：operator@(参数表)隐式调⽤形式：obj1+obj2显式调⽤形式：obj1.operator+(OBJ obj2)---成员函数operator+(OBJ obj1，OBJ obj2)---友元函数执⾏时，隐式调⽤形式和显式调⽤形式都会调⽤函数operator+()++和--运算符的class Point{private:int x;public:Point(int x1){ x=x1;}Point operator++();//成员函数定义⾃增const Point operator++(int x); //后缀可以返回⼀个const类型的值friend Point operator--(Point& p);//友元函数定义--friend const Point operator--(Point& p,int x);//后缀可以返回⼀个const类型的值};Point Point::operator++()//++obj{x++;return *this;}const Point Point::operator++(int x)//obj++{Point temp = *this;this->x++;return temp; // 需要返回⼀个临时对象，效率不如 ++obj ⾼}Point operator--(Point& p)//--obj{p.x--;return p;//前缀形式(--obj)重载的时候没有虚参,通过引⽤返回*this 或⾃⾝引⽤,也就是返回变化之后的数值}const Point operator--(Point& p,int x)//obj--{Point temp = p;p.x--;return temp;// 后缀形式obj--重载的时候有⼀个int类型的虚参, 返回原状态的拷贝}调⽤：Point b(2);a++;//隐式调⽤成员函数operator++(0),后缀表达式++a;//隐式调⽤成员函数operator++(),前缀表达式b--;//隐式调⽤友元函数operator--(0),后缀表达式--b;//隐式调⽤友元函数operator--(),前缀表达式cout<<a.operator ++(2);//显式调⽤成员函数operator ++(2)，后缀表达式cout<<a.operator ++();//显式调⽤成员函数operator ++()，前缀表达式cout<<operator --(b,2);//显式调⽤友元函数operator --(2)，后缀表达式cout<<operator --(b);//显式调⽤友元函数operator --()，前缀表达式 </pre>总结：1、a++函数返回：temp(临时变量)函数返回是否是const类型：返回是⼀个拷贝后的临时变量)，不能出现在等号的左边(临时变量不能做左值)，函数的结果只能做右值，则要返回⼀个const类型的值++a函数返回：*this;函数返回是否是const类型：返回原状态的本⾝，返回值可以做左值，即函数的结果可以做左值，则要返回⼀个⾮const类型的值2、前后缀仅从函数名(operator++)⽆法区分，只能有参数区分，这⾥引⼊⼀个虚参数int x，x可以是任意整数。
运算符重载解读
02
在重载运算符时，应明确指定 运算符的参数类型和返回类型 ，避免与其他操作符混淆。
03
在重载运算符时，应尽量使用 有意义的操作符名称，以提高 代码的可读性。
考虑性能和效率
01
02
03
运算符重载时，应考虑 性能和效率，避免对原 有代码造成不必要的性
能损失。
在重载运算符时，应尽 量减少额外的计算和内 存开销，以提高代码的
一元运算符重载
一元运算符重载是指对一元运算符进行重载，使其能够应用于一个操作数。例如，在C中，我们可以 重载一元减号运算符(-)来返回一个数的相反数。
常见的一元运算符有：+、-、~、!等。
二元运算符重载
二元运算符重载是指对二元运算符进行重载，使其能够应用于两个操作数。例如，在C中，我们可以重载加号运算符(+)来定 义两个自定义类型的相加行为。
01
提高代码可读性
运算符重载可以使代码更易读， 因为运算符的使用可以使代码更 简洁、更直观。
02
03
方便函数调用
运算符重载可以使得函数调用更 加方便，因为运算符的使用可以 减少函数调用的开销。
04
缺点分析
易造成混淆
运算符重载可能会使得代码难以理解，因为 运算符的行为可能会被改变，导致读者难以
理解代码的含义。
常见的二元运算符有：+、-、*、/、%等。
三元运算符重载
三元运算符重载是指对三元运算符进行重载，使其能够应用于三个操作数。例如，在C中，我们可以重载条件运 算符(?)来定义一个自定义类型的条件判断行为。
常见的三元运算符有：?:。
03
运算符重载的常见场景
类与类之间的运算
01
两个类对象之间的加法运算，可以表示它们之间的某种关联或 合并。
C程序设计运算符重载资料
•
{
目的对象与源对象不是同一个对象
•
……
复制被被赋值对象
•
}
•
*;
返回目的对象
•}
*重载赋值运算符“=”
• 如用户没有为一个类重载赋值运算符，编译程序将生成一个默认赋值运算符函数。赋值运算 把源对象的数据成员逐个地复制到目的对象的相应数据成员
0;
返回值0, 返回操作系统
}
程序运行时屏幕输出如下： 6 -6 请按任意键继续. . .
用类的友元函数重载双目运算符
• 将双目运算符重载为类的友元函数时，友元函数形参表中包含有两个参数，这两个参数分别 作为运算符的左、右操作数。
例4.6 双目运算符重载为类的友元函数示例。
<>
编译预处理命令
;
使用命名空间
例4.8 双目运算符重载为普通函数示例。 声明整型类
{
:
数据成员
;
数据值
:
公有函数
( n = 0): (n){ }
构造函数
( n) { = n; }
设置数据值
() { ; } 返回数据值
};
( , ) 重载运算符"+"
{ (() + ()); }
()
主函数()
{
i(6), j(9), k;
定义整型对象
例4.5 单目运算符重载为类的友元函数示例。
<>
编译预处理命令
;
使用命名空间
声明整型类
{
: 数据成员
在 6.0下会出现的编译时错语，是 6.0的一个，在
<> ;;
编译预处理：
:
改为：
运算符重载详解
运算符重载详解1.运算符重载定义：C++中预定义的运算符的操作对象只能是基本数据类型。
但实际上，对于许多⽤户⾃定义类型（例如类），也需要类似的运算操作。
这时就必须在C++中重新定义这些运算符，赋予已有运算符新的功能，使它能够⽤于特定类型执⾏特定的操作。
运算符重载的实质是函数重载，它提供了C++的可扩展性，也是C++最吸引⼈的特性之⼀。
运算符重载是通过创建运算符函数实现的，运算符函数定义了重载的运算符将要进⾏的操作。
运算符函数的定义与其他函数的定义类似，惟⼀的区别是运算符函数的函数名是由关键字operator和其后要重载的运算符符号构成的。
运算符函数定义的⼀般格式如下：<返回类型说明符> operator <运算符符号>(<参数表>){<函数体>} 2.运算符重载时要遵循以下规则：(1) 除了类属关系运算符"."、成员指针运算符".*"、作⽤域运算符"::"、sizeof运算符和三⽬运算符"?:"以外，C++中的所有运算符都可以重载。
(2) 重载运算符限制在C++语⾔中已有的运算符范围内的允许重载的运算符之中，不能创建新的运算符。
(3) 运算符重载实质上是函数重载，因此编译程序对运算符重载的选择，遵循函数重载的选择原则。
(4) 重载之后的运算符不能改变运算符的优先级和结合性，也不能改变运算符操作数的个数及语法结构。
(5) 运算符重载不能改变该运算符⽤于内部类型对象的含义。
它只能和⽤户⾃定义类型的对象⼀起使⽤，或者⽤于⽤户⾃定义类型的对象和内部类型的对象混合使⽤时。
(6) 运算符重载是针对新类型数据的实际需要对原有运算符进⾏的适当的改造，重载的功能应当与原有功能相类似，避免没有⽬的地使⽤重载运算符。
（7）重载运算符的函数不能有默认的参数，否则就改变了运算符的参数个数，与前⾯第3点相⽭盾了；（8）重载的运算符只能是⽤户⾃定义类型，否则就不是重载⽽是改变了现有的C++标准数据类型的运算符的规则了，会引会天下⼤乱的；（9）⽤户⾃定义类的运算符⼀般都必须重载后⽅可使⽤，但两个例外，运算符“=”和“&”不必⽤户重载；（10）运算符重载可以通过成员函数的形式，也可是通过友元函数，⾮成员⾮友元的普通函数。
运算符的重载
7
运算符重载的实现
运算符的重载形式有两种：重载为类的成员函数和
重载为类的友元函数。运算符重载为类的成员函 数的语法形式如下：
<函数类型> operator <运算符>（<形参表>）
{ <函数体>;
}
运算符重载为类的友元函数的语法形式如下：
friend <函数类型> operator <运算符>（<形 参表>）
public: CComplex(double r, double i); }
temp.real = real + c.real; temp.imag = imag + c.imag; return temp;
void Print();
CComplex
CComplex Add(CComplex c); CComplex::Sub(CComplex c)
运算符的重载
2021/4/8
1
4 运算符重载
问题的提出
例复数类
CComplex
#include "iostream.h"
CComplex::Add(CComplex c)
class CComplex
{
{
CComplex temp;
private: double real; double imag;
若二个同类对象进行二元运算后的结果类型 仍为原类型，则运算符重载函数的返回类 型应为原类型。
如在上例中，由于两个复数运算的结果仍为 复数，因此上述运算符重载函数的返回类 型均为复数类型Complex。
2021/பைடு நூலகம்/8
重载运算符语法讲解
重载运算符语法讲解重载运算符这篇随笔我来讲解⼀下C++语⾔中重载运算符的相关知识。
⼀、重载运算符的⽤途这是⼀个⽐较哲学的问题：我们为什么要重载运算符？理由就是，我们C++语⾔中已经给出的运算符（包括算数运算符和逻辑运算符）只是针对C++语⾔中已经给定的数据类型进⾏运算，假如我们想要对我们的⾃定义数据类型进⾏运算的话，则需要重载运算符，我们可以把重载运算符理解成对已有的运算符的⼀种重新定义。
⽐如：double a,b,c;a=1/3;b=1/2;c=a+b;printf("%lf",c);这段程序输出的肯定不是两个分数相加的结果。
这时候我们就可以重载运算符+。
⼆、重载运算符的实现语法格式如下（⾮常重要）<返回类型> operator <运算符符号>（<参数>）{<定义>;}这⾥我们举⼀个例⼦。
在优先队列（priority_queue）中，存储的元素较⼤的会被放到堆顶。
如果存的是int或者string等类型还好办（因为他们本⾝就可以互相⽐较⼤⼩），如果是我们⾃定义的结构体类型，那就需要重载<运算符。
⽐如：struct node{int id;double x,y;}//定义结构体bool operator <(const node &a,const node &b){return a.x<b.x && a.y<b.y;}//重载运算符“<”注：这⾥的结构体保存了⼀个整型变量id，两个长浮点变量x,y,表⽰坐标。
这⾥的重载运算符先⽐横坐标后⽐纵坐标。
三、重载运算符的注意事项。
以下运算符不可重载：关系运算符"."成员指针运算符".*"作⽤域运算符"::"sizeof运算符三⽬运算符"?:"重载运算符限制在C++语⾔中已有的运算符范围内的允许重载的运算符之中，不能创建新的运算符。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
第十八章运算符的重载运算符重载就是赋予已有的运算符多重含义。
C++中通过重新定义运算符，使它能够用于特定类的对象执行特定的功能。
例如，通过对+，—，*，/ 运算符的重新定义，使它们可以完成复数、分数等不同类的对象的加减乘除运算操作。
这便增强了C++语言的处理能力。
18．1运算符重载的几个问题1、哪些运算符可以重载？几乎所有的运算符都可以重载，除了以下的几个运算符：．, ：：，?:2、运算符重载后，优先级和结合性如何？用户重新定义运算符，不改变原运算符的的优先级和结合性。
同时运算符重载后，也不改变运算符的语法结构，即单目运算符只能重载为单目运算符，双目运算符只能重载为双目运算符。
3、编译程序如何选用运算符函数？在每一种编译系统中，运算符实际上都对应一个函数，只是这种运算对用户具有透明性，使用者并不知道函数的存在。
运算符重载实际上是运算符函数的重载，所以运算符的重载实际上是函数的重载。
编译程序对运算符重载的选择，遵循着函数重载的选择原则。
当遇到不很明显的运算符时，编译程序将去寻找参数相匹配的运算符函数。
4、重载运算符有哪些限制？（1）不可臆造新的运算符（2）坚持四个不能改变。
●不能改变运算符原有的优先级●不能改变运算符原有的结合性●不能改变运算符原有的语法结构●不能改变运算符原有的操作数个数但允许改变运算符的返回类型（3）C++规定，运算符中，参数类型都是内部类型时，不允许重载。
“：：、*、->、？：”这五个运算符不能重载。
5、运算符重载必须遵循哪些原则？运算符重载可以使程序更加简洁，使表达式更加直观，增强可读性。
但是，运算符重载使用不宜过多，否则会带来一定的麻烦。
运算符重载必须遵循以下原则：（1）重载运算符含义必须清楚。
（2）重载运算符不能有二义性。
18．2 运算符重载的定义格式两种形式运算符重载的定义格式：返回类型operator 运算符号（参数说明）；例1：为A类定义一个“++”运算符重载函数class A{...;A operate ++(A&);...};例2：为A类定义一个“+”运算符重载函数class A{...;friend A operate +(A&，A&);...};18．3 运算符重载的两种形式运算符重载的函数有两种形式：成员函数形式和友元函数形式。
1、重载为成员函数例18．3．1 下面程序定义一个Time类用来保存时间（时、分、秒），通过重载操作符“+”实现两个时间的相加。
#include <iostream.h>class Time{public:Time(){ hours=0;minutes=0;seconds=0;} //无参构造函数Time(int h, int m,int s) //重载构造函数{hours=h; minutes=m; seconds=s;}Time operator +(Time&); //操作符重载为成员函数，返回结果为Time类void gettime();private:int hours,minutes,seconds;};Time Time::operator +(Time& time){int h,m,s;s=time.seconds+seconds;m=time.minutes+minutes+s/60;h=time.hours+hours+m/60;Time result(h,m%60,s%60);return result;}void Time::gettime(){cout<<hours<<":"<<minutes<<":"<<seconds<<endl; }void main( ){Time t1(8,51,40),t2(4,15,30),t3;t3=t1+t2;t3.gettime();}输出结果：13：7：10例18．3．2 下面程序用来实现复数的加法运算即：（x+yi）+(a+bi)=(x+a)+(y+b)ix+yi+a=(x+a)+yi#include <iostream.h>class complex{public:complex( ) {real=imag=0; }complex(double r, double i=0) //虚部可以省略{real=r;imag=i;}complex operator +(complex & c);friend void print(complex &c);private:double real,imag;};complex complex::operator +(complex & c){return complex(real+c.real,imag+c.imag);}void print(complex &c){cout<<c.real<<"+"<<c.imag<<"i"<<endl;}void main( ){complex c1(2.0,3.0),c2(4.0,-2.0),c3;c3=c1+c2;print(c3);c3=c3+complex(3.5);print(c3);}输出结果：6+1i2、操作符重载为友元函数形式例18．3．3 下面程序修改了例18.3.1，将操作符重载为友元函数实现#include <iostream.h>class Time{public:Time(){ hours=0;minutes=0;seconds=0;} //无参构造函数Time(int h, int m,int s) //重载构造函数{hours=h; minutes=m; seconds=s;}friend Time operator +(Time&,Time&); //重载运算符为友元函数形式void gettime( );private:int hours,minutes,seconds;};Time operator +(Time& time1,Time& time2){int h,m,s;s=time1.seconds+time2.seconds; //计算秒数m=time1.minutes+time2.minutes+s/60; //计算分数h=time1.hours+time2.hours+m/60; //计算小时数Time result(h,m%60,s%60);return result;}void Time::gettime( ){cout<<hours<<":"<<minutes<<":"<<seconds<<endl;}void main( ){Time t1(8,51,40),t2(4,15,30),t3;t3=t1+t2;t3.gettime( );}输出结果：13：7：10例18．3．4 下面程序用友元函数实现复数的加法运算#include <iostream.h>class complex{public:complex( ) {real=imag=0; }complex(double r, double i=0) //虚部可以省略{real=r;imag=i;}friend complex operator +(complex & c1,complex &c2);friend void print(complex &c);private:double real,imag;};complex operator +(complex & c1, complex &c2){return complex(c1.real+c2.real,c1.imag+c2.imag);}void print(complex &c){cout<<c.real<<"+"<<c.imag<<"i"<<endl; }void main( ){complex c1(2.0,3.0),c2(4.0,-2.0),c3;c3=c1+c2;print(c3);c3=c3+complex(3.5);print(c3);}输出结果：6+1i9.5+1i3、其它运算符的重载。