C++程序设计实践案例教程项目9 运算符重载
C++教学 第9章+友元函数与运算符重载
float v1(A &a) { return PI*a.r*a.r*a.h;} //友元函数volum在类体外定义 float v3(A b) //普通函数 { return PI*b.getr()*b.getr()*b.geth();} void main() { A a1(25,40); A a2(25,40); cout<<v1(a1)<<"\n"; //友元函数的调用 cout <<a2.v2( )<<"\n"; cout<<v3(a1); }
对于大多数程序设计语言，运算符的定义由编译器给出，且 这种用法是不允许用户改变的。在C++中，允许用户重新定 义已有的运算符，并按规定要求去完成特定的操作。 使用成员函数或友元函数，通过操作对象成员，从而实现对 象参加运算的目的。
10
运算符重载函数的定义格式如下： （1）运算符重载函数定义为类的成员函数 函数类型 operator 运算符 （参数表） { …… }
15
9.3 一元运算符重载 C++中允许重载的一元运算符有: 自增运算符“++”、自减运算符“--”、 负号运算符“-”、逻辑非运算符“!”等。
16
9.3.1 用成员函数重载一元运算符
用成员函数重载“++”运算符的格式为： （1）++为前缀形式 函数类型 operator++（void） { 函数体 } （2）++为后缀形式 函数类型 operator++（int） { 函数体 } 重载自减运算符“--”的格式与重载“++”运算符类似。
运算符重载(面向对象程序设计C++)
运算符重载运算符重载的本质是函数重载，它也是C++多态的一种体现，为用户提供了一个直观的接口，调用运算符操作自定义数据类型其实就是调用运算符函数。
运算符重载增强了C++的可扩充性，使得C++代码更加直观、易读，且便于对对象进行各种运算操作。
重载的运算符是具有特殊名字的函数：它们的名字由关键字operator 和其后要重载的运算符共同组成。
语法格式 返回类型 operator 运算符（参数列表）{函数体; }运算符重载规则：只能重载C++中已有的运算符，不能创建新的运算符。
重载之后的运算符不能改变其优先级和结合性，也不能改变其操作数的个数及语法结构。
避免没有目的地使用重载运算符。
类属关系运算符“.”、成员指针运算符“*”、作用域运算符“::”、sizeof 运算符和三目运算符“?:”不可以重载。
输入输出运算符的重载 IO 标准库使用“>>”和“<<”运算符执行输入输出操作，对于这两个运算符来说，IO 库定义了其基本数据类型的操作，但若要直接对类对象进行输入输出，则需要在类中重载这两个运算符。
输入运算符语法格式istream& operator>>(istream&, 类对象引用);输出运算符语法格式ostream& operator<<(ostream&,const 类对象引用); 关系运算符的设计准则关系运算符都要成对的重载。
“==”运算符应该具有传递性当成对出现运算符重载时，可以把一个运算符的工作委托给另一个运算符。
赋值运算符的重载对于赋值运算符来说，如果不重载，那么类会自动为我们提供一个赋值运算符。
这个默认的赋值运算符跟默认拷贝构造函数一样，就是把一个对象的数据成员的值复制给另一个对象对应的数据成员。
下标运算符的重载返回类型 operator[] (参数列表);重载“[]”运算符可以实现两个目的：（1）“对象[下标]”的形式类似于“数组[下标]”，更加符合习惯。
C#运算符重载用法实例分析
这篇文章主要给大家介绍了关于c如何给枚举类型增加一个描述特性的相关资料文中通过示例代码介绍的非常详细对大家的学习或者工作具有一定的参考学习价值需要的朋友们下面来一起学习学习吧
C#运 算 符 重 载 用 法 实 例 分 析
本文实例讲述了C#运算符重载用法。分享给大家供大家参考。具体分析如下：
public class Plane { public virtual double TopSpeed() { return 300.0D;} public static bool operator>(Plane one, Plane two) { return one.TopSpeed() > two.TopSpeed(); } public static bool operator<(Plane one, Plane two) { return one.TopSpeed() < two.TopSpeed(); } } class Jet : Pe TopSpeed() { return 900.0D; } public override string ToString() { return "I'm a Jet"; } } class Airport { [STAThread] static void Main(string[] args) { Plane plane = new Jet(); Console.WriteLine("plane's top speed: {0}",plane.TopSpeed()); Jet jet = new Jet(); Console.WriteLine("jet's top speed: {0}",jet.TopSpeed()); Console.WriteLine("Plane > Jet = {0}", plane > jet); Console.ReadLine(); } }
《C程序设计》电子教案第7章运算符重载
返回本节
7.3 一元运算符重载
类的单目运算符可重载为一个没有参数的非静 态成员函数或者带有一个参数的非成员函数， 参数必须是用户自定义类型的对象或者是对该 对象的引用。 在C++中，单目运算符有++和--，它们是变量自 动增1和自动减1的运算符。在类中可以对这两 个单目运算符进行重载。
返回首页
例7-4：下面程序修改了例7-2，将操作符重载为友元函数实现。 #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; };
//显示临时对象值 //显示原有对象
// 第二次增量操作对
返回本节
7.4 二元运算符重载
对于双目运算符，一个运算数是对象本身的数 据，由 this 指针给出，另一个运算数则需要通 过运算符重载函数的参数表来传递。下面分别 介绍这两种情况。 对于双目运算符B，如果要重载B为类的成员函 数，使之能够实现表达式“oprd1 B oprd2”， 其中 oprd1 为 A 类的对象，则应当把 B 重载为 A 类的成员函数，该函数只有一个形参，形参的 类型是 oprd2 所属的类型。经过重载之后，表 达 式 oprd1 B oprd2 就 相 当 于 函 数 调 用 “oprd1.operator B(oprd2)”。
C++语言程序设计形考三实验九
上机实验9：操作符重载的应用一、实验内容下面程序定义了复数类Complex的3个对象：Complex u(10, 20), v(5,-4), s;在程序中通过s = u + v;来计算u和v的和，并将结果存入s中，填补缺失的语句并调试出正确运行结果。
#include <iostream>using namespace std;class Complex{private:double real, imag; //real、imag分别保存复数的实部、虚部public:Complex() { real = 0; imag = 0;}Complex(double r, double i) { real = r; imag = i; }void display(){ cout<< "(" << real;if (imag >0) cout<< "+" << imag << "i)";else if (imag <0) cout<< imag << "i)";}// 通过成员函数重载运算符“+”};void main(){ Complex u(10, 20), v(5,-4), s;s = u + v; // 使用重载的运算符“+”u.display(); cout<<" + ";v.display(); cout<<" = ";s.display(); cout<<endl;}二、实验要求在Complex类中编写重载运算符“+”的函数，保证语句的用法正确并显示复数运算结果。
三、实验结果截图（请将实际上机运行的结果截图并上传）。
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. 掌握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++第9章运算符重载
§9-2 重载运算符的基本格式
RMB RMB::operator +(RMB &s) { unsigned int c=jf+s.jf; unsigned int d=yuan+s.yuan; if(c>=100) { c-=100; d++; } RMB result(d,c); return result; } RMB & RMB::operator ++(); { jf++; if(jf>=100) { jf-=100; yuan++; } return *this; } void main() { RMB d1(1,60); RMB d2(2,50); RMB d3(0,0); d3=d1+d2; ++d3; d3.display(); }
§9-1 使用运算符重载的必要性
9.1 使用运算符重载的必要性
运算符重载就是对已有的运算符赋予多重含义， 使同一个运算符作用于不同类型的数据，导致不 同类型的行为。
RMB a(10,23),b(20,45),c;
c=a+b; //c=add(a,b);
运算符重载可以增加可读性，使用户定义数据类
型直接使用运算符进行运算，但不是非有不可。
§9-1 使用运算符重载的必要性
class RMB{ //人民币类 public: RMB(double d){ yuan=d; jf=(d-yuan)*100; } RMB interest(double rate); //计算利息 RMB add(RMB d); //人民币加 void display(){ cout <<(yuan + jf / 100.0) << endl; } RMB operator+(RMB d) { return RMB(yuan+d.yuan+(jf+d.jf)/100.0); } RMB operator*(double rate) { return RMB((yuan+jf/100.0)*rate);} private: unsigned int yuan; //元 unsigned int jf; //角分 };
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
实训--运算符重载的实现
实训目的
1.熟悉运算符重载的意义； 2.掌握双目运算符的重载方法； 3.掌握单目运算符的重载方法； 4.掌握重载为友元函数和成员函数的方法。
实训内容与步骤
1.阅读程序，写出程序的运行结果。
（1）先来读一下初步的程序。
/*******************
* point.h *******************/ #ifndef POINT_H_ #define POINT_H_
class Point {
private:
int x,y; public:
/*******************
* point.cpp *******************/ #include "point.h" Point::Point(int a , int b){
（10）运算符重载可以通过成员函数的形式，也可是通过友元函数，非成员非友元的普通函 数。
2.运算符重载的形式
运算符函数重载一般有两种形式：重载为类的成员函数和重载为类的非成员函数。
重载为成员函数的运算符重载，一般格式为： <函数类型> operator <运算符>(<参数表>) { <函数体>
}
当运算符重载为类的成员函数时，函数的参数个数比原来的操作数要少一个（后置单目运算符除外），这 是因为成员函数用this指针隐式地访问了类的一个对象，它充当了运算符函数最左边的操作数。因此：
(1) 双目运算符重载为类的成员函数时，函数只显式说明一个参数，该形参是运算符的右操作 数。
(2) 前置单目运算符重载为类的成员函数时，不需要显式说明参数，即函数没有形参。
(3) 后置单目运算符重载为类的成员函数时，函数要带有一个整型形参。
调用成员函数运算符的格式如下：
<对象名>.operator <运算符>(<参数>)
项目 9 运算符重载
主要内容
9.1
9.2 9.2.1 9.2.2 9.2.3
基础的实现 127 实训目的 127 128
实训内容与步骤 实训总结 133
9.3
9.4
习题及解析 133
思考题 136
基础知识
1.运算符重载定义
C++中预定义的运算符的操作对象只能是基本数据类型。但是，很多时候，对于许多用户自定 义类型（例如类），也需要类似的运算操作。所以必须在C++中重新定义这些运算符，赋予已 有运算符新的功能，使它能够用于特定类型执行特定的操作。 运算符重载的实质是函数重载，它允许程序员在同一个运算符号上定义功能相似运算对象不 同的操作，提供了C++的可扩展性，也是C++区别与其他语言的一个特性。
(1) 一般情况下，单目运算符最好重载为类的成员函数；双目运算符则最好重载为类的友元函 数。
(2) 以下一些双目运算符不能重载为类的友元函数：=、()、[]、->。
(3) 类型转换函数只能定义为一个类的成员函数而不能定义为类的友元函数。
(4) 若一个运算符的操作需要修改对象的状态，选择重载为成员函数较好。 (5) 若运算符所需的操作数（尤其是第一个操作数）希望有隐式类型转换，则只能选用友元函 数。 (6) 当运算符函数是一个成员函数时，最左边的操作数（或者只有最左边的操作数）必须是运 算符类的一个类对象（或者是对该类对象的引用）。如果左边的操作数必须是一个不同类的 对象，或者是一个内部类型的对象，该运算符函数必须作为一个友元函数来实现。 (7) 当需要重载运算符具有可交换性时，选择重载为友元函数。
(4) 重载之后的运算符不能改变运算符的优先级和结合性，也不能改变运算符操作数的个数及 语法结构。
(5) 运算符重载不能改变该运算符用于内部类型对象的含义。它只能和用户自定义类型的对象 一起使用，或者用于用户自定义类型的对象和内部类型的对象混合使用时。
(6) 运算符重载是针对新类型数据的实际需要对原有运算符进行的适当的改造，重载的功能应 当与原有功能相类似，避免没有目的地使用重载运算符。
调用友元函数运算符的格式如下：
operator <运算符>(<参数1>,<参数2>)
它等价于： <参数1><运算符><参数2>
例如：a+b等价于operator +(a,b)。 在多数情况下，将运算符重载为类的成员函数和类的友元函数都是可以的。
但成员函数运算符与友元函数运算符也具有各自的一些特点：
它等价于： <对象名><运算符><参数>
例如：a+b等价于a.operator +(b)。一般情况下，我们采用运算符的习惯表达方式。 一般情况下，非成员运算符重载函数是类的友元，它的一般格式为： friend <函数类型> operator <运算符>(<参数表>)
{
<函数体> }
当运算符重载为类的友元函数时，由于没有隐含的this指针，因此操作数的个数没有变化，所 有的操作数都必须通过函数的形参进行传递，函数的参数与操作数自左至右一一对应。
运算符重载是通过创建运算符函数实现的，运算符函数定义了重载的运算符将要进行的操作。 运算符函数的定义与其他函数的定义类似，惟一的区别是运算符函数的函数名是由关键字 operator和其后要重载的运算符符号构成的。
运算符函数定义的一般格式如下：
<返回类型说明符> operator <运算符符号>(<参数表>)
{ <函数体> }
在重载运算符时，必须遵循以下规则：
(1) 除了类属关系运算符"."、成员指针运算符".*"、作用域运算符"::"、sizeof运算符和三目运算 符"?:"以外，C++中的所有运算符都可以重载。
(2) 重载运算符限制在C++语言中已有的运算符范围内的允许重载的运算符之中，不能创建新 的运算符。 (3) 运算符重载实质上是函数重载，因此编译程序对运算符重载的选择，遵循函数重载的选择 原则。
（7）重载运算符的函数不能有默认的参数，否则就改变了运算符的参数个数，与前面第3点 相矛盾了； （8）重载的运算符只能是用户自定义类型，否则就不是重载而是改变了现有的C++标准数据 类型的运算符的规则了，会引会天下大乱的；
（9）用户自定义类的运算符一般都必须重载后方可使用，但两个例外，运算符“=”和“&”不 必用户重载；