第4章运算符重载
第04章 运算符重载
class A { int i; public: A(int a=0){ i=a;} void Show(void) {cout<<"i="<<i<<endl;} void AddA(A &a, A &b) // 利用函数进行类之间的运算 { i=a.i+b.i; } A operator +(A &a) // 重载运算符+ { A t; t.i=i+a.i; return t; } }; void main(void) { A a1(10),a2(20),a3; 相当于a3=a1.operator+(a2) a1.Show (); a2.Show (); a3=a1+a2; //重新解释了加法，可以直接进行类的运算 a3.AddA(a1,a2); //调用专门的功能函数 a3.Show (); }
总结：
重新定义运算符，由左操作符
调用右操作符。最后将函数返
回值赋给运算结果的对象。
由对象c1调用
若已有运算载Complex operator+ (Complex &c1, Complex &c2) ，那下面的表达式还 合法吗 c3=c2+12; // 这个表达式合法吗？ int i=3+5; //这个表达式合法吗？
C++与面向对象程序设计第四章 运算符重载 (PPT4)
有：函数重载；
运算符重； 运算符重载——同一个运算符可以有多种含义或功能。
4.1 运算符重载的语法规则
函数返回值类型 operator 被重载的运算符（函数参数表）
说明：运算符进行重载本质——是编写运算符重载函数； 函数名——必须以operator开始，后跟被重载的运算符；
Байду номын сангаас
注意几点： 1.只能重载C++中已有的运算符。 2.“.”、“.*”、“::”、“?:”和sizeof这5个运算符不允许被 重载。除此之外，都可以被重载。 3.不能改变运算符的操作数个数。比如，对于单目运算符，它只能 有一个操作数。 4.不能改变运算符原有的优先级。 5.不能改变运算符原有的结合性。 6.不能改变运算符对C++内部那些预定义数据类型的操作方式。
C++与面向对象程序设计
第四章：运算符重载
本章教学内容
运算符重载的语法规则 复数类的运算符重载 (+) 字符串类的运算符重载 (+,=,[]) 运算符“<<”的重载 (复数，字符串对象输出 ) 类型转换函数(C++内部数据类型--->类对象)
第四章 运算符重载
“重载”技术是面向对象程序设计的主要特征之一。
//成员函数的实现CComplex.cpp CComplex::CComplex() //默认构造函数 { m_ Re =0.0; m_ Im =0.0; } CComplex::CComplex(double x,double y) //构造函数 { m_ Re=x; m_ Im=y; } CComplex CComplex::operator +(const CComplex c) //两个复数相加 { return CComplex (m_ Re + c.m_ Re, m_ Im+c.m_ Im); } CComplex CComplex::operator +(const double c) //一个复数加一个double数 { return CComplex ( m_ Re +c , m_ Im); }
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运算符重载其实就是定义⼀个函数，在函数体内实现想要的功能，当⽤到该运算符时，编译器会⾃动调⽤这个函数，它本质上是函数重载。
第4讲 运算符重载(上)
重载函数作为类的友元函数
11
小结
C++规定，有的运算符(如赋值运算符、下标运算符、 C++规定，有的运算符(如赋值运算符、下标运算符、函数 规定 调用运算符)必须定义为类的成员函数， 调用运算符)必须定义为类的成员函数，有的运算符则不能 定义为类的成员函数(如流插入“<<” 定义为类的成员函数(如流插入“<<”和流提取运算符 >>” 类型转换运算符) “>>”、类型转换运算符) 一般将单目运算符重载为成员函数， 一般将单目运算符重载为成员函数，将双目运算符重载为 友元函数 说明： 有的C++编译系统( C++编译系统 6.0)没有完全实 说明： 有的C++编译系统(如Visual C++ 6.0)没有完全实 C++标准 它所提供不带后缀. 标准， 现C++标准，它所提供不带后缀.h的头文件不支持把成员函 数重载为友元函数。但是Visual C++所提供的老形式的带 数重载为友元函数。但是Visual C++所提供的老形式的带 后缀. 后缀.h的头文件可以支持此项功能
第4讲 运算符重载
4.1 运算符重载概念 4.2 重载运算符的规则
1
4.1 运算符重载概念
重载概念:用户根据自己需要对C++已提供的运算符 或函数的功能重新赋予新的含义，使之“一词多义”
函数重载：同一函数名可以实现不同的功能 运算符重载：同一运算符能实现不同的运算操作
2
生活中的重载概念
“杯具”一词重 杯具” 载
12
本讲重点
重载的概念：“双肩挑” 重载的方法： 重载的方法：运算符重载是通过定义函 数实现的 重载的规则：7+1
vc 04 运算符重载
于是: 于是:
string x,y; x=x+y; //表示串 和串 合并,放入串 表示串x 表示串 和串y 合并,放入串x
这就使对基本类型的预定义运算符" 的含义在串类中被扩展 这就使对基本类型的预定义运算符"+"的含义在串类中被扩展 为对串类对象的合并操作,即运算符"+"被重载. 为对串类对象的合并操作,即运算符" 被重载. 被重载 运算符重载应注意的几个问题: 运算符重载应注意的几个问题: 1,哪些运算符可以重载? 哪些运算符可以重载? 中除了下面四种运算符外, 在C++ 中除了下面四种运算符外,系统预定义的运算符都 能被重载. 能被重载.
string x,y;
那么, 实现两个串的合并. 那么,可以使用函数strcat(x,y)实现两个串的合并. 如果在表示字符串的类对象x, 的特定环境下,运算符" 使 如果在表示字符串的类对象 ,y 的特定环境下,运算符"+"使 用于类对象,能被解释为串对象x 的合并, 用于类对象,能被解释为串对象 和y 的合并,则编程就更方便 了.
例如:下边是运算符重载的另一个例子,程序实现了复数的加 例如:下边是运算符重载的另一个例子, 和减运算. 和减运算.
#include <iostream.h> class Complex { public: Complex() { real=imag=0.0; } Complex(double r) { real=r; imag=0.0; } Complex(double r,double i) { real=r; imag=i; } Complex operator+(const Complex& c); Complex operator-(const Complex& c); friend void print(const Complex& c); private: double real,imag; };
4第四章 运算符重载
const complex operator - (const complex &c) const; void display(); //输出复数 private: //私有数据成员 1.是为了堵塞a+b=c的漏洞。 double real; //复数实部 2. 3.是为了扩大适应性。 double imag; //复数虚部 };
17
[ ]运算符重载为成员函数
下标运算符［］可以重载： 重载形式为：operator［］(int); 当 X x; 隐含调用。 x[y] 可被解释为： 显式调用。 x. operator [ ](y)； 只能重载为成员函数，不能使用友元函数。 这个类显然是个‚数组类‛。
18
前置++和后置++重载为成员函数
9
使用
void main(){
complex c1(5,4),c2(2,10),c3; //三个复数类的对象 cout<<"c1="; cout<<"c2="; c1.display(); c2.display();
c3=c1-c2; //使用重载运算符完成复数减法 cout<<"c3=c1-c2="; c3.display(); 程序输出结果为：
这三个运算符是许多 教课书没有提到的。
唯一的一个三目运 算符不能重载。
3
运算符重载的基础
设计运算符重载函数，首先要了解运算符原本的运算语义。重
载函数要忠实遵守该运算符作用于基本数据类型时的语义，
并表现出自身所特有的性质。 例如：+ 、+= 、=、++(前)、++(后) ....
第4章 运算符重载
• 在C++中只能重载单目运算符、双目运算符及 不确定目数运算符“()”
下列运算符不能重载 . 类成员运算符 .* 成员指针运算符 :: 域解析运算符 ?: 条件表达式运算符 “#” (???) sizeof(???)
重载运算符有哪些限制？
(1) 不可臆造新的运算符。必须把重载运算符 限制在C++语言中已有的运算符范围内的允许 重载的运算符之中。 (2) 重载运算符坚持4个“不能改变”。 · 不能改变运算符操作数的个数； · 不能改变运算符原有的优先级； · 不能改变运算符原有的结合性； · 不能改变运算符原有的语法结构
用类的成员函数重载双目运算符
• 双目运算符重载为类的成员函数时，形参 表中有一个参数，以当前对象作为运算符 的左操作数，参数作为右操作数。
例4.4 双目运算符重载为类的成员函数示例。 // 声明整型类 class Integer { private: // 数据成员 int num; // 数据值 public: // 公有函数 Integer(int n = 0): num(n){ } // 构造函数 void Set(int n) { num = n; } // 设置数据值 int Get() const { return num; } // 返回数据值 Integer operator+(const Integer &a) const// 重载加法运算符“+” { return Integer(this->num + a.num); } }; int main() // 主函数main() { Integer i(6), j(9), k; // 定义整型对象 k = i + j; // 对整型对象求加法运算，i+j等价于i.operator+(j); cout<<i.Get()<<"+"<<j.Get()<<"="<<k.Get()<<endl;// 输出数值 system("PAUSE"); // 输出系统提示信息 程序运行时屏幕输出如下： return 0; // 返回值0, 返回操作系统 6+9=15 } 请按任意键继续. . .
4 运算符重载
可以将+代表的操作看成一个函数：+为函数的名字，+操作的两个操 作数的类型即为函数形参的类型，+操作的结果的类型即为函数的返回 值类型。
北京化工大学 VC++ 教学课件
2
计算机系 江志英 jiangzy@
运算符重载的提出
C/C++中，每种基本数据类型的变量都可通过几种运算符来做相关计 算，如int型变量，它们可以同“+”，“-”，“*”，“/”等运算符 来做加法，减法，乘法，除法等。如：
4 5 6
常用运算符的重载
重载赋值运算符operator=
重载输入/输出运算符 << | >>
重载下标运算符operator[ ]
重载类型转换函数
北京化工大学 VC++ 教学课件
4
计算机系 江志英 jiangzy@
运算符重载的基本语法
运算符的使用和普通函数在语法上有所不同，但是可以将 运算符看作是一种特殊的函数，操作数是函数的参数，运 算结果是函数的返回值。
北京化工大学 VC++ 教学课件
14
计算机系 江志英 jiangzy@
// 重载运算符的使用示例 int main() { Byte a, b, *bp; +b; -b; ~b; bp = &b; !b; ++b; b++; --b; b--; } //end of main()
3
Vector vec1,vec2 vec1+vec2; vec1-vec2; vec1*vec2; vec1/vec2; 两个向量类对象的加减乘除
C++提供了运算符重载机制来帮助我们实现上述目的。
第四章 运算符重载
例:给出以下程序的运行结果。
#include <iostream.h> <iostream. int square(int x) { return x*x; x*x; } 此程序的运行结果为： double square(double y) The square of integer 7 is 49 { return y*y; y*y; The square of integer 7.5 is 56.25 } main() { cout<<” cout<<”The square of integer 7 is”<<square(7)<<endl; is”<<square(7)<<endl; cout<<” cout<<” The square of double 7.5 is”<<square(7.5)<<endl; is”<<square(7 )<<endl; return 0; }
函数重载
重载： 重载：
在同一作用域， 在同一作用域 ， 允许多个函数使用同一名 字的措施。 字的措施。 名字相同， 参数个数或者 参数对应位置 名字相同 ， 但 参数个数 或者参数对应位置 的类型不同，这样的函数称为重载 （overloading）。 overloading） 例如： int func(); func(); int func(int a,int b); b); void func(char *a,int b); b);
运算符重载
只听过数学中可以有运算， 对象之间也可以加减乘除？？？
运算符重载
C++语言允许程序员重新定义已有的运算符，使 C++语言允许程序员重新定义已有的运算符，使 其能按用户的要求完成一些特定的操作，这就是所谓 的运算符重载。运算符重载与函数重载相似，其目的 是设置某一运算符，让它具有另一种功能，尽管此运 算符在原先C++语言中代表另一种含义，但他们彼此 算符在原先C++语言中代表另一种含义，但他们彼此 之间并不冲突。C++会根据运算符的位置辨别应使用 之间并不冲突。C++会根据运算符的位置辨别应使用 哪一种功能进行运算。
简述运算符重载的规则。
简述运算符重载的规则。
篇一：运算符重载是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. 逻辑运算符重载逻辑运算符包括条件运算符和逻辑非运算符。
每个逻辑运算符都有一组默认的行为,可以通过运算符重载来自定义它们的行为。
第四章运算符重载
2、对于任意一元运算符α：
(1)成员函数重载运算符
定义
type x::operator α( )
{…}
显式调用
objX.operator α( )
隐式调用
αobjX 或：ojbXα
(2)友元函数重载运算符
定义
type operator α(Xobj)
{…}
显式调用
operatorα(obj X)
隐式调用
友元函数重载运算符时，需要明确给出参数，不会出错。 3、不能用友元函数重载的运算符：
= 、 ( )、［］、- > 4、注意： (1)对THIS所指向的数据的任何改变都会影响到激活运算数函数的对象。 (2)可使用引用参数(指针)来解决重载时的二义性。
4.1.5 重载++和--
一、关于++和- 1、C中的++和- -的两种形式： 前缀：++i； 后缀：i--； 2、在C++中的约定 (显式地区分前缀和后缀) (1)对于前缀方式++i:
例4-1 1、重载“+”、“=”、“++”；读懂几个成员函数； 2、成员函数重载运算符，激活运算符的对象都是由THIS指针隐含传递的。
4.1.4 用友元函数重载运算符
1、成员函数重载可能造成的麻烦：成员函数重载的运算符不具有交换性。 原因：成员函数仅能被一个“实际对象”所调用，如果引起成员函数
调用的是一个值(非一个对象)，成员函数将不能正确工作。 2、可用友元函数解决这一问题：
5、除“=”以外，重载的运算符可以被任何派生类所继承， “=”需要每个类明确定义自己的解释；
6、 重载可能让程序的可读性下降，在使用时应模仿运算符的 习惯用法 。
运算符重载——精选推荐
运算符重载运算符重载学习运算符重载，让运算符能做⼀些原来做不了的事情，⽅便它的使⽤⼀、运算符重载的概念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）不能返回局部变量的引⽤。
运算符重载
sizeof (长度运算符)
(3) 重载运算符的函数不能有默认的参数，否则就改变了 运算符参数的个数。 (4) 重载的运算符必须和用户自定义类型的对象一起使用， 其参数至少应有一个是类对象(或类对象的引用)。也 就是说，参数不能全部是C++的标准类型，以防止用 户修改用于标准类型数据的运算符的性质。
operator+(Complex &c2)，进行求值，得到两 个复数之和。
为了重载运算符，必须定义一个函数，并告诉编译器， 遇到这个重载运算符就调用该函数，由这个函数来完成 该运算符应该完成的操作。 这种函数称为运算符重载函数，它通常是类的成员函数 或者是友元函数。 运算符的操作数通常也应该是类的对象。 运算符被重载后，其原有的功能仍然保留，没有丧失或 改变。 通过运算符重载，扩大了C++已有运算符的作用范围， 使之能用于类对象。
void String∷display( ) { cout<<p;}l operator>(String &string1,String &string2) 函数 { if(strcmp(string1.p,string2.p)>0) return true; else return false; } int main( ) { String string1(″Hello″),string2(″Book″); cout<<(string1>string2)<<endl; }
//定义3个复数对象 //调用复数相加函数 //输出c1的值 //输出c2的值 //输出c3的值
调用方式不直观、不方便、太烦琐。
能否也和整数的加法运算一样，直接用加号“+”
C++程序设计04737 第4章 运算符重载
//成员函数
myComplex &operator=(double);
//成员函数 };
myComplex::myComplex(){ real=0;imag=0;}
myComplex::myComplex(double r,double i)
{real=r;imag=i;}
myComplex myComplex::addCom(myComplex c1) {return myComplex(this->real+c1.real,this->imag+c1.imag); } void myComplex::outCom(){cout<<"("<<real<<","<<imag<<")";} void myComplex::outCom(string s) {cout<<s<<"=("<<real<<","<<imag<<")"<<endl;} void myComplex::changeReal(double r) {this->real=r;} myComplex operator+(const myComplex &c1,const myComplex &c2) //c1+c2 {return myComplex(c1.real+c2.real,c1.imag+c2.imag);}//返回一个临时对象 myComplex operator+(const myComplex &c1,double r) //c1+r {return myComplex(c1.real+r,c1.imag);} //返回一个临时对象 myComplex operator+(double r,const myComplex &c1) //r+c1 {return myComplex(r+c1.real,c1.imag);} //返回一个临时对象 myComplex operator-(const myComplex &c1,const myComplex &c2)//c1-c2 {return myComplex(c1.real-c2.real,c1.imag-c2.imag);}//返回一个临时对象 myComplex operator-(const myComplex &c1,double r) //c1-r {return myComplex(c1.real-r,c1.imag);//返回一个临时对象} myComplex operator-(double r,const myComplex &c1) //r-c1 {return myComplex(r-c1.real,-c1.imag); //返回一个临时对象} myComplex &myComplex::operator=(const myComplex &c1) {this->real=c1.real;this->imag=c1.imag;return *this; } myComplex &myComplex::operator=(double r) {this->real=r;this->imag=0;return *this;}
运算符重载解读
02
在重载运算符时，应明确指定 运算符的参数类型和返回类型 ，避免与其他操作符混淆。
03
在重载运算符时，应尽量使用 有意义的操作符名称，以提高 代码的可读性。
考虑性能和效率
01
02
03
运算符重载时，应考虑 性能和效率，避免对原 有代码造成不必要的性
能损失。
在重载运算符时，应尽 量减少额外的计算和内 存开销，以提高代码的
一元运算符重载
一元运算符重载是指对一元运算符进行重载，使其能够应用于一个操作数。例如，在C中，我们可以 重载一元减号运算符(-)来返回一个数的相反数。
常见的一元运算符有：+、-、~、!等。
二元运算符重载
二元运算符重载是指对二元运算符进行重载，使其能够应用于两个操作数。例如，在C中，我们可以重载加号运算符(+)来定 义两个自定义类型的相加行为。
01
提高代码可读性
运算符重载可以使代码更易读， 因为运算符的使用可以使代码更 简洁、更直观。
02
03
方便函数调用
运算符重载可以使得函数调用更 加方便，因为运算符的使用可以 减少函数调用的开销。
04
缺点分析
易造成混淆
运算符重载可能会使得代码难以理解，因为 运算符的行为可能会被改变，导致读者难以
理解代码的含义。
常见的二元运算符有：+、-、*、/、%等。
三元运算符重载
三元运算符重载是指对三元运算符进行重载，使其能够应用于三个操作数。例如，在C中，我们可以重载条件运 算符(?)来定义一个自定义类型的条件判断行为。
常见的三元运算符有：?:。
03
运算符重载的常见场景
类与类之间的运算
01
两个类对象之间的加法运算，可以表示它们之间的某种关联或 合并。
运算符重载详解
运算符重载详解1.运算符重载定义：C++中预定义的运算符的操作对象只能是基本数据类型。
但实际上，对于许多⽤户⾃定义类型（例如类），也需要类似的运算操作。
这时就必须在C++中重新定义这些运算符，赋予已有运算符新的功能，使它能够⽤于特定类型执⾏特定的操作。
运算符重载的实质是函数重载，它提供了C++的可扩展性，也是C++最吸引⼈的特性之⼀。
运算符重载是通过创建运算符函数实现的，运算符函数定义了重载的运算符将要进⾏的操作。
运算符函数的定义与其他函数的定义类似，惟⼀的区别是运算符函数的函数名是由关键字operator和其后要重载的运算符符号构成的。
运算符函数定义的⼀般格式如下：<返回类型说明符> operator <运算符符号>(<参数表>){<函数体>} 2.运算符重载时要遵循以下规则：(1) 除了类属关系运算符"."、成员指针运算符".*"、作⽤域运算符"::"、sizeof运算符和三⽬运算符"?:"以外，C++中的所有运算符都可以重载。
(2) 重载运算符限制在C++语⾔中已有的运算符范围内的允许重载的运算符之中，不能创建新的运算符。
(3) 运算符重载实质上是函数重载，因此编译程序对运算符重载的选择，遵循函数重载的选择原则。
(4) 重载之后的运算符不能改变运算符的优先级和结合性，也不能改变运算符操作数的个数及语法结构。
(5) 运算符重载不能改变该运算符⽤于内部类型对象的含义。
它只能和⽤户⾃定义类型的对象⼀起使⽤，或者⽤于⽤户⾃定义类型的对象和内部类型的对象混合使⽤时。
(6) 运算符重载是针对新类型数据的实际需要对原有运算符进⾏的适当的改造，重载的功能应当与原有功能相类似，避免没有⽬的地使⽤重载运算符。
（7）重载运算符的函数不能有默认的参数，否则就改变了运算符的参数个数，与前⾯第3点相⽭盾了；（8）重载的运算符只能是⽤户⾃定义类型，否则就不是重载⽽是改变了现有的C++标准数据类型的运算符的规则了，会引会天下⼤乱的；（9）⽤户⾃定义类的运算符⼀般都必须重载后⽅可使⽤，但两个例外，运算符“=”和“&”不必⽤户重载；（10）运算符重载可以通过成员函数的形式，也可是通过友元函数，⾮成员⾮友元的普通函数。
C#运算符重载（操作符重载）
C#运算符重载（操作符重载）1.什么是操作符重载定义:(百科定义)就是把已经定义的、有⼀定功能的操作符进⾏重新定义，来完成更为细致具体的运算等功能。
操作符重载可以将概括性的抽象操作符具体化，便于外部调⽤⽽⽆需知晓内部具体运算过程。
2.为什么需要运算符重载？在C#中 ,内置的数据类型有：int、double等这些类型是可以直接进⾏数值加减运算。
例如：int i, j = 1; int sum=i+j；可以直接得到想要的和sum。
如果要⽐较⼀个类（结构）进⾏对象⽐较加、减等操作该如何实现？例如⼀个类Test，有对象a，b 如何实现对象相加a+b？3.运算符重载出场公式：public static “返回类型” operator “操作符符号” ｛…………｝eg: public static Test operator +(Test lhs, Test rhs){ return new Test(lhs.value + rhs.value); }4.案例struct Test{private int value;public int Value{get { return value; }}public Test(int iValue){this.value = iValue;}//C#操作符重载//1、声明⼀个⼆元操作符，将两个Test加到⼀起public static Test operator +(Test lhs, Test rhs){return new Test(lhs.value + rhs.value);}//2、声明⼀个⼆元操作符，将Test和int加到⼀起public static Test operator +(Test lhs, int rhs){return lhs + new Test(rhs);}//3、声明⼀个⼆元操作符，将int和Test加到⼀起public static Test operator +(int lhs, Test rhs){return new Test(lhs) + rhs;}//4、声明⼀个⼀元操作符，public static Test operator ++(Test h){h.value++;return h;}}定义⼀个结构struct，当然定义成类class⼀样结果：只有定义了才可做操作相关的操作，例如上⾯3：将int和Test加到⼀起只可以 int+Test对象，2.3+Test对象则报错例2using System;class Player{public int neili;public int tili;public int jingyan;public int neili_r;public int tili_r;public Player(){neili = 10;tili = 50;jingyan = 0;neili_r = 50;tili_r = 50;}// ⼀元操作符重载public static Player operator ++(Player p){p.neili = p.neili + 50;p.tili = p.tili + 50;p.neili_r = p.neili;p.tili_r = p.tili;return p;}// ⼆元操作符重载public static Player operator +(Player p1, Player p2){Player p = new Player();p.neili = p1.neili +p2.neili;p.tili = p1.tili + p2.tili;p.neili_r = p.neili;p.tili_r = p.tili;return p;}public static void Main(){Player p1 = new Player();Player p2 = new Player();p1++;Console.WriteLine(" {0}", p1.neili);Player p = p1 + p2;Console.WriteLine(" {0}", p.neili);}}5.注意C#中有6个⽐较运算符，它们分为 3对：● == 和 !=● > 和 <● >= 和 <=C#要求成对重载⽐较运算符。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
例4.6 单目运算符的前置与后置重载
#include<iostream> using namespace std; class Time 输出： 输出： { public: time1: 34:59 Time() {minute=0;sec=0;} ++time1: 35:0 Time(int m,int s):minute(m),sec(s){} time1++: 35:1 //声明前置重载函数 Time operator++(); //声明前置重载函数 time2: 35:0 //声明后置重载函数 Time operator++(int); //声明后置重载函数 void display(){cout<<minute<<":"<<sec<<endl;} private: int minute,sec; int main() }; {Time time1பைடு நூலகம்34,59),time2; Time Time::operator++() cout<<"time1: "; time1.display(); {sec{if(++sec>=60) {sec-=60;++minute;} ++time1; cout<<"++time1:"; return *this; time1.display(); } time2=time1++; cout<<"time1++:"; Time Time::operator++(int) time1.display(); //复制对象 {Time temp(*this); //复制对象 cout<<"time2:"; time2.display(); sec++; return 0; {secif(sec>=60) {sec-=60; ++minute;} } return temp; }
后置单目运算符 ++和-++和
• 如果要重载 ++或--为类成员函数，使之能够实现表达 ++或--为类成员函数 为类成员函数， oprd-类对象， 式 oprd++ 或 oprd-- ，其中 oprd 为A类对象，则 ++或 类的成员函数， ++或-- 应被重载为 A 类的成员函数，且具有一个 int 类型形参。 类型形参。 形参 • 经重载后，表达式 oprd++ 相当于 oprd.operator 经重载后， ++(0) • 增加的形参没有任何作用，只是为了与前置重载函数有 增加的形参没有任何作用， 所区别
• • • 函数重载 运算符重载 虚函数
用“+”、“-”能够实现复数的加减运算吗？ +”、 能够实现复数的加减运算吗？
通过函数实现两个复数相加（没有用运算符重载）。 例4.1 通过函数实现两个复数相加（没有用运算符重载）。
void Complex::display() #include <iostream> { cout<<" ("<<real<<", "<<imag using namespace std; <<"i)"<<endl; class Complex } {public: int main() Complex(){real=0;imag=0;} c1(3,4),c2(5,{ Complex c1(3,4),c2(5,-10),c3; Complex(double r,double i) c3=plex_add(c2); {real=r;imag=i;} cout<<"c1="; c1.display(); Complex complex_add(Complex &c2); cout<<"c2="; c2.display(); void display(); cout<<"c1+c2="; c3.display(); private: return 0; double real,imag; } }; Complex::complex_add(Complex Complex Complex::complex_add(Complex &c2) 输出： 输出： { Complex c; c1=(3,4i) c.real=real+c2.real; c2=(5,c2=(5,-10i) c.imag=imag+c2.imag; c1+c2=(8,c1+c2=(8,-6i) return c; }
<iostream.h iostream.h> #include <iostream.h> class Complex {public: Complex(){real=0;imag=0;} Complex(double r,double i) {real=r;imag=i;} friend Complex operator+(Complex &c1,Complex &c2); void display(); private: double real,imag; }; operator+(Complex Complex operator+(Complex &c1,Complex &c2) { return Complex(c1.real+c2.real,c1.imag+c2.imag);} void Complex::display() { cout<<" ("<<real<<", "<<imag<<"i)"<<endl;} int main() c1(3,4),c2(5,{ Complex c1(3,4),c2(5,-10),c3; c3=c1+c2; cout<<"c1="; c1.display(); cout<<"c2="; c2.display(); cout<<"c1+c2="; c3.display(); return 0;}
–参数个数=原操作数个数-1 参数个数=原操作数个数参数个数 –重载为友元函数时，参数个数=原操作数个数， 重载为友元函数时， 重载为友元函数时 参数个数=原操作数个数， 且至少应该有一个自定义类型的形参。 且至少应该有一个自定义类型的形参。
重载运算符＋，实现两个复数相加。 ＋，实现两个复数相加 例4.3 重载运算符＋，实现两个复数相加。
Complex::operator+(Complex ::operator+ Complex Complex::operator+(Complex &c2)
–经重载后，表达式 oprd1 B oprd2 相当于 经重载后， 经重载后 oprd1.operator B(oprd2)
c3=c1.operator+ operator+(c2); c3=c1+c2; 相当于 c3=c1.operator+(c2);
4.3 重载运算符的规则
C++不允许用户定义新的运算符，只能对已有的运算符进行重 C++不允许用户定义新的运算符，只能对已有的运算符进行重 不允许用户定义新的运算符 载。 大部分C++运算符都能被重载 不能重载的运算符有5 大部分C++运算符都能被重载，不能重载的运算符有5个： C++运算符都能被重载， . * :: sizeof ?: 重载不能改变运算符的运算对象的个数、优先级和结合方向。 重载不能改变运算符的运算对象的个数、优先级和结合方向。 重载运算符的函数不能有默认参数。 重载运算符的函数不能有默认参数。 重载的运算符必须和用户定义的自定义类型的对象一起使用， 重载的运算符必须和用户定义的自定义类型的对象一起使用， 其参数至少应有一个是类对象（或类对象的引用）。 其参数至少应有一个是类对象（或类对象的引用）。 用于类对象的运算符一般必须重载，只有“ 用于类对象的运算符一般必须重载，只有“＝”和“&”不必用 不必用 户重载。 户重载。 应当使重载运算符的功能类似于该运算符作用于标准类型数据 时所实现的功能。 时所实现的功能。 运算符重载函数可以是类的成员函数，也可以是类的友元函数， 运算符重载函数可以是类的成员函数，也可以是类的友元函数， 极少数情况下还可以是普通函数。 极少数情况下还可以是普通函数。
4.2 运算符重载的方法
运算符重载是通过定义函数实现的。 运算符重载是通过定义函数实现的。运算符重载实质上是函数的 重载。 重载。 定义一个重载运算符的函数，在需要执行被重载的运算符时， 定义一个重载运算符的函数，在需要执行被重载的运算符时，系 统就自动调用该函数，以实现相应的运算符的运算。 统就自动调用该函数，以实现相应的运算符的运算。 定义重载运算符的函数的一般格式： 定义重载运算符的函数的一般格式： 函数类型 operator 运算符名(形参表列) 运算符名(形参表列) 对运算符的重载处理｝ ｛对运算符的重载处理｝ operator是关键字 是关键字， operator是关键字，专门用于定义重载运算符 如： 的函数。函数名是operator运算符。 operator运算符 的函数。函数名是operator运算符。 Complex {…} operator+(Complex operator+(Complex &c1,Complex &c2)