★第12章 运算符重载
复习五 运算符重载(改)
6.1 运算符重载的规则
算符重载就是赋予已有的运算符多重含义 运算符重载就是赋予已有的运算符多重含义。 例如： 例如：a=3+4； ； a=”abc”+”def”; 同一个运算符“＋”，由于所操作的数据类型不 同一个运算符“ 同而具有不同的意义，这就是运算符重载。 同而具有不同的意义，这就是运算符重载。 运算符重载是C++的一项强大功能。通过重载， 运算符重载是 的一项强大功能。通过重载， 的一项强大功能 可以扩展C++运算符的功能，使它们能够操作用户 运算符的功能， 可以扩展 运算符的功能 自定义的数据类型， 自定义的数据类型，增加程序代码的直观性和可读 性
5
void main(void){ Complex c1(1,2),c2(3,4),c3,c4,; c3=c1+c2; c4=c1-c2; } c1+c2被解释为：operator+(c1,c2) 被解释为： 被解释为 c1-c2被解释为： operator-(c1,c2) 被解释为： 被解释为
6
cout<<r;
if (i>0) cout<<"+"; If (i!=0) cout<<i<<"i"<<endl; }
void main(void) { Complex c1(1,2),c2(3,4),c3,c4,; c3=c1+c2; C++会将它们转换成下面形式的调用 会将它们转换成下面形式的调用 c4=c1-c2; 语句： 语句： c1.display(); // 1+2i c3=c1.operator+(c2); c2.display(); // 3+4i c4=c1.operator –(c2); c3.display(); // 4+6i c4.display();} // -2-2i
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运算符重载其实就是定义⼀个函数，在函数体内实现想要的功能，当⽤到该运算符时，编译器会⾃动调⽤这个函数，它本质上是函数重载。
C语言新教材PPT课堂课件第12章位运算
1011=11 (3)主要用途：将1个数的某(些)位置1，其余各位不变。
3．按位异或── ^ (1)格式：x^y (2)规则：对应位相同时为0，不同时为1：3^9=10。 例如，3^9=1： 0011
^ 1001
────
1010=10 (3)主要用途：使1个数的某(些)位翻转(即原来为1的位变为0，为0 的变为1)，其余各位不变。 4．按位取反── ~ (1)格式：~x (2)规则：各位翻转，即原来为1的位变成0，原来为0的位变成1： 在IBM-PC机中，~0＝0xffff，~9=0xfff6。 (3)主要用途：间接地构造一个数，以增强程序的可移植性。 5．按位左移── << (1)格式：x<< 位数 (2)规则：使操作数的各位左移，低位补0，高位溢出：5<<2=20。
程序运行情况：
Input a integer number:1000 ←┘
result=0x3
程序说明：~ ( ~0 << 4)按位取0的反，为全1；左移4位后，其低4位为0，其 余各位为1；再按位取反，则其低4位为1，其余各位为0。这个整数正是我们 所需要的。
[例12.2] 从键盘上输入1个正整数给int变量num，按二进制位输 出该数。
printf("Input a integer number: ");
scanf("%d",&num);
num >>= 8;
/*右移8位，将8～15位移到低8位上*/
mask = ~ ( ~0 << 4);/*间接构造1个低4位为1、其余各位为0的整数*/
printf("result=0x%x\n", num & mask); }
c++结构体重载运算符
c++结构体重载运算符C++结构体可以通过重载运算符来实现自定义的操作符行为。
重载运算符允许我们使用结构体对象与其他对象之间进行类似于内置数据类型的操作。
下面将介绍一些常用的运算符重载的方式以及其使用场景。
1. 算术运算符重载：- 重载+运算符：可以用于结构体对象之间的相加操作。
- 重载-运算符：可以用于结构体对象之间的相减操作。
- 重载*运算符：可以用于结构体对象与标量之间的乘法运算。
- 重载/运算符：可以用于结构体对象与标量之间的除法运算。
2. 关系运算符重载：- 重载==运算符：用于比较两个结构体对象是否相等。
- 重载!=运算符：用于比较两个结构体对象是否不相等。
- 重载<运算符：用于比较两个结构体对象的大小关系。
- 重载>运算符：用于比较两个结构体对象的大小关系。
- 重载<=运算符：用于比较两个结构体对象的大小关系。
- 重载>=运算符：用于比较两个结构体对象的大小关系。
3. 赋值运算符重载：- 重载=运算符：用于将一个结构体对象的值赋给另一个对象。
- 重载+=运算符：用于将一个结构体对象与另一个对象相加，并将结果赋给第一个对象。
- 重载-=运算符：用于将一个结构体对象与另一个对象相减，并将结果赋给第一个对象。
- 重载*=运算符：用于将一个结构体对象与标量相乘，并将结果赋给第一个对象。
- 重载/=运算符：用于将一个结构体对象与标量相除，并将结果赋给第一个对象。
4. 输入输出运算符重载：- 重载<<运算符：用于将结构体对象的数据输出到标准输出流。
- 重载>>运算符：用于从标准输入流中读取数据，并赋给结构体对象的成员变量。
运算符重载的基本语法如下：```返回类型 operator运算符(参数列表) {// 重载运算符的实现代码// 可以直接访问结构体对象的成员变量// 可以调用结构体对象的方法// 可以与其他对象进行运算// 返回运算结果}```在进行运算符重载时，需要注意以下几点：- 重载运算符必须是成员函数或友元函数。
运算符重载优秀课件
定义一种简化旳复数类complex: class complex { public: double real,imag; complex(double r=0,double i=0) { real=r; imag=i;}
}; 若要把类complex旳两个对象com1和com2加在一起,下面旳语句
是不能实现旳: main() { complex com1(1.1,2.2),com2(3.3,4.4),total; total=com1+com2; //错误 //… return 0; }
第7章 运算符重载
7.1为何引入运算符重载
int sum_i; float sum_f; int i1=123， i2=456; float f1=3.45， f2=56.78; sum_i= i1+i2;//两个整数相加 cout<<"i1+i2 ="<< sum_i; sum_f= f1+f2; //两个浮点数相加 cout<<"f1+f2 ="<< sum_f; sum_f= i1+i2+f1; //进行类型转换后相加 cout<<"i1+i2+f1 ="<<sum_f;
. .* ：： ？Sizeof() ?:不能重载
（3）运算符重载后，不能变化运算符操作数旳
个数、优先级、结合性、语法构造。
（4）不能定义新旳运算符
7.3.1 单目运算符“++”和“--”旳重载 在C++中,能够经过在运算符函数参数表中是否插 入关键字int来区别前缀和后缀这两种方式。 例如：重载单目运算符++
运算符重载实验报告
一、实验目的1. 理解运算符重载的概念和原理。
2. 掌握C++中运算符重载的方法和规则。
3. 通过实例，实现自定义类型对运算符的重载。
4. 分析运算符重载在实际编程中的应用和优势。
二、实验环境1. 编程语言：C++2. 开发环境：Visual Studio 20193. 操作系统：Windows 10三、实验内容1. 运算符重载的概念和原理2. 运算符重载的方法和规则3. 自定义类型运算符重载实例4. 运算符重载的实际应用四、实验步骤1. 概念和原理运算符重载是指为已有的运算符赋予新的功能，使其能够应用于自定义类型的数据。
在C++中，运算符重载可以通过成员函数或友元函数实现。
2. 方法和规则- 成员函数重载：在自定义类型中定义一个成员函数，该函数的名称与要重载的运算符相同。
- 友元函数重载：在自定义类型外部定义一个友元函数，该函数的名称与要重载的运算符相同，并在函数声明中添加类名和作用域解析运算符。
运算符重载规则：- 运算符重载的函数必须返回与操作数相同的类型。
- 运算符重载的函数不能改变原有运算符的操作数个数。
- 运算符重载的函数不能改变原有运算符的优先级。
- 运算符重载的函数不能改变原有运算符的结合性。
3. 自定义类型运算符重载实例假设我们有一个自定义类型`Point`，表示二维平面上的一个点，其坐标为`(x, y)`。
```cppclass Point {public:int x, y;Point(int x, int y) : x(x), y(y) {}// 成员函数重载加法运算符Point operator+(const Point& p) const {return Point(x + p.x, y + p.y);}// 友元函数重载加法运算符friend Point operator-(const Point& p1, const Point& p2);};// 实现友元函数重载减法运算符Point operator-(const Point& p1, const Point& p2) {return Point(p1.x - p2.x, p1.y - p2.y);}```4. 运算符重载的实际应用运算符重载在实际编程中具有以下优势：- 提高代码可读性：使用自定义类型时，可以像操作基本数据类型一样使用运算符，提高代码的可读性。
乘法运算符重载语法
乘法运算符重载语法乘法运算符重载语法是一种非常有用的编程技巧，它允许我们自定义对象之间的乘法操作。
通过合理地使用这个特性，我们可以让我们的代码更加灵活、高效。
那么，如何使用乘法运算符重载语法呢？首先，让我们看一下乘法运算符重载的基本语法。
在C++中，乘法运算符重载使用关键字"operator*"，后面跟着一个参数表示右侧操作数，然后在函数体内实现乘法运算，最后返回结果。
```cpp返回类型 operator*(const 类名& 对象名) {// 实现乘法运算return 结果;}```这是一个简单的乘法重载函数的框架，我们只需要在其中添加自定义的乘法逻辑即可。
接下来，让我们通过一个例子来进一步理解乘法运算符重载的应用。
假设我们有一个"向量"类，表示在二维平面上的一个向量。
我们希望能够通过乘法操作将两个向量相乘，得到它们的点积。
首先，我们需要在向量类中定义乘法运算符重载函数：```cppclass 向量 {public:// 定义向量的成员变量和构造函数等// 乘法运算符重载函数向量 operator*(const 向量& v) {// 计算点积double 结果 = this->x * v.x + this->y * v.y;// 返回结果向量return 向量(结果);}};```在这个例子中，我们假设向量类有两个成员变量x和y分别表示向量在x轴和y轴上的分量。
乘法运算符重载函数中，我们利用点积的计算公式，将两个向量的x和y分量相乘，并将计算结果返回。
接下来，我们就可以使用乘法运算符重载来计算两个向量的点积了：```cpp向量 v1(1, 2); // 创建向量对象1，分量为(1, 2)向量 v2(3, 4); // 创建向量对象2，分量为(3, 4)向量结果 = v1 * v2; // 计算两个向量的点积// 输出点积结果cout << "两个向量的点积为：" << 结果 << endl;```通过使用乘法运算符重载，我们可以方便地计算出两个向量的点积，并将结果保存在一个新的向量对象中。
ch12补充(友元、运算符重载)
运行结果： 4+6i
Press any key to continue
注:对于+=运算符,如果分别重载了”+”和”=”号
运算符,如果没特殊要求就不需要重载”+=“运算
符。其它重运算符“-=，*=，/=，……”的重载
也是这样。
六、重载赋值（=）运算符 #include<iostream.h> #include<string.h> class string{ private: char *p; public: string(char *s="") { p=new char[strlen(s)+1]; strcpy(p,s); }
complex operator+(complex& ob1,complex& ob2)
{
complex temp; temp.real=ob1.real+ob2.real; temp.imag=ob1.imag+ob2.imag; return temp; } void main(){ complex c1(1,2),c2(3,4),c3,c4; c3=operator+(c1,c2); c3.disp(); c4=c1+c2; c4.disp(); }
};
void main(){ complex c1(1,2),c2(3,4),c3,c4; c3=c1.operator+(c2); //c3=c1+c2; c3.disp(); c4=c1+c2; c4.disp(); } 运行结果： 4+6i 4+6i Press any key to continue
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
实际通过调用“+”运算符 重载函数来完成，即： operator+(c1,c2) 实际通过调用取负运算符 重载函数来完成，即： operator-(c1)
• 从例12.1和例12.2可见，不管运算符的重载是通过成员函数实 现还是通过友元函数实现，运算符的用法是相同的，但编译器 所做的解释是不同的。
• 大多运算符既可重载为成员函数又可重载为友元函数，给编程 带来了灵活性。但从类的封装性和成员数据的安全性角度考虑， 重载运算符时应优先重载为成员函数，无法用成员函数重载时 才考虑用友元函数。 • 举例：对于例12.1和例12.2来说只有“实数+复数”这种情况无 法用成员函数重载加(+)运算符，其余情况均可。因此复数类定 义成下列形式更好。 class Complex{ //复数类 double real,image; public: Complex(double r=0,double i=0){real=r;image=i;} Complex operator+(Complex&); //复数+复数 Complex operator+(Complex&,double); //复数+实数 friend Complex operator+(double,Complex&);//实数+复数 … };
• 例12.1 定义复数类，重载加(+)、减(-)、乘(*)、除(/)运算 符，实现复数的四则运算；重载取负(-)运算符，实现复数的 取负操作。 #include<iostream.h>
class Complex{ //复数类 double real,image; public: Complex(double r=0,double i=0){real=r;image=i;} void print( ); Complex operator+(Complex&);//重载+：复数+复数 Complex operator-(Complex&);//重载-：复数-复数 Complex operator*(Complex&);//重载*：复数*复数 Complex operator/(Complex&);//重载/：复数/复数 Complex operator-( ); //重载-：-复数 };
12.2 运算符重载为成员函数
• 定义格式： class X{ … public: <type> operator @(<Arg>); … }; • 说明： –@函数应说明为公有的，否则外界无法使用。 –系统约定，当@函数为类成员时，其第一操作数为 当前对象。因此，若@为一元运算符，则参数表为 空；若@为二元运算符，则参数表的参数为第二操 作数。 –成员运算符函数的定义方法与普通成员函数相同。
Complex operator+(Complex&c1,Complex&c2) //复数+复数 { return Complex(c1.real+c2.real,c1.image+c2.image);} Complex operator+(Complex&c,double d) { return Complex(c.real+d,c.image); } Complex operator+(double d,Complex&c) { return Complex(c.real+d,c.image); } //复数+实数 //实数+复数
12.3 运算符重载为友元函数
• 定义格式： class X{ … public: friend <type> operator@(<Arg>); … }; • 说明： –在函数原型前加关键字friend。 –类的友元函数可置于类的任何位置。 –友元函数无this指针，应在参数表中列出每个操作数。若@ 为一元运算符，则参数表应有一个参数；若@为二元运算符， 则参数表应有两个参数，第一个参数为左操作数，第二个参 数为右操作数。
第12章 运算符重载
• 运算符重载：重定义 已有运算符，完成特 定操作，即同一运算 符根据不同的运算对 象完成不同的操作。 • 运算符重载是面向对 象程序设计的多态性 之一。 • C++允许运算符重载。
12.1 12.2 12.3 12.4 12.5 12.6
运算符重载的基本方法 运算符重载为成员函数 运算符重载为友元函数 几个特殊运算符的重载 运算符重载的规则 字符串类
Complex Complex::operator*(Complex &c) { Complex temp; temp.real=real*c.real-image*c.image; temp.image=real*c.image+image*c.real; return temp; }
Complex Complex::operator/(Complex &c) { Complex temp; double r=c.real*c.real+c.image*c.image; temp.real=(real*c.real+image*c.image)/r; temp.image=(image*c.real-real*c.image)/r; return temp; 实际通过调用“+”运算符 } 重载函数来完成，即： Complex Complex::operator-( ) { return Complex(-real,-image); } c1.operator+(c2) void main(void) { Complex c1(5,2),c2(3,4),c3; +、-、*和/运算符重载函数的 c3= c1+c2; c3.print( ); 返回值类型均为Complex，使 c3= c1+c2+c3; c3.print( ); 它们可继续参加Complex类型 c3=c1-c2; c3.print( ); 数据的运算，如c1+c2+c3。 c3=c1*c2; c3.print( ); 实际通过调用取负运算符 c3=c1/c2; c3.print( ); 重载函数来完成，即： c3= -c1; c3.print( ); c1.operator-( ) }
• 问题：例12.1将+运算符重载为类的成员函数实现了 “复数+复数”操作，能否通过类似的方法实现“复 数+实数”和“实数+复数”操作？ • 答：要实现“复数+实数”操作，可在复数类Complex 中重载下列+运算符： Complex Complex::operator+(double d) { return Complex(real+d, image); } 但要实现“实数+复数”操作，无法在复数类Complex 中通过重载+运算符为类的成员函数来实现。原因是， 将运算符重载为类的成员函数时，其第一操作数只能 是当前对象，而不可能是其它类型的数据。 • 对于“实数+复数”这样的操作只能通过重载+运算符 为类的友员函数来实现。
void Complex::print( ) { if(image<0) cout<<real<<image<<"i\n"; else if(image>0) cout<<real<<’+’<<image<<"i\n"; else cout<<real<<endl; }
void main(void) { Complex c1(5,2),c2(3,4),c3; c3= c1+c2; c3.print( ); c3=c1-c2; c3.print( ); c3=c1*c2; c3.print( ); c3=c1/c2; c3.print( ); c3= -c1; c3.print( ); c3=c1+8.2; c3.print( ); c3=3.5+c2; c3.print( ); }
Complex operator/(Complex&c1,Complex&c2) //复数/复数 { Complex t; double r=c2.real*c2.real+c2.image*c2.image; t.real=(c1.real*c2.real+c1.image*c2.image)/r; t.image=(c1.image*c2.real-c1.real*c2.image)/r; return t; } Complex operator-(Complex&c1) { return Complex(-c1.real,-c1.image); //复数取负 }
void Complex::print( ) { if(image<0) cout<<real<<image<<"i\n"; else if(image>0) cout<<real<<’+’<<image<<"i\n"; else cout<<real<<endl; 第一操作数为当前对象 }
Complex Complex::operator+(Complex &c) { return Complex(real+c.real, image+c.image); Complex Complex::operator-(Complex &c) { return Complex(real-c.real,image-c.image); } }