实验8--友元函数与运算符重载函数

合集下载

C++程序设计实验 友元和类运算符重载

C++程序设计实验 友元和类运算符重载

《C++程序设计》实验报告准考证号xxxxxx题目:友元运算符重载和类运算符重载姓名xxx 日期xxx 实验环境:Visual C++ 6.0- 1 -- 2 -实验内容与完成情况实验目的:1,掌握运算符重载的必要性2,掌握友元运算符重载的一般格式3,掌握类运算符重载的一般格式4,掌握重载后的运算符的使用格式实验内容:1,设计一个类定义相关的数据成员和成员函数重载加、减运算符,实现对象的加减运算定义相关函数实现对象中数据的输出显示2,定义成员函数时,将成员函数定义在类体之外3,设计main 函数创建多个对象进行对象的加减运算,并输出运算后对象的数据并输出结果源程序代码://类运算符的重载实现#include <iostream>using namespace std;class base{double ra;double ia;public: base(double r=0,double i=0){ ra=r; ia=i;cout<<"构造base 对象"<<ra<<"+"<<ia<<"i"<<endl;}base operator +(base a){ cout<<"开始+操作->"<<endl;double r=a.ra+ra; double i=a.ia+ ia; base s(r,i);cout<<"完成+操作,实现复数相加"<<endl;return s; }base operator -(base a){ cout<<"开始-操作->"<<endl;double r=a.ra-ra; double i=a.ia-ia; base s(r,i);cout<<"完成-操作,实现复数相减"<<endl;return s; }void show(){ cout<<"对象中存放的复数值为:"<<ra<<"+"<<ia<<"i"<<endl; }}; void main(){ base c1(2,6),c2(3,2),c3,c4;c3=c2.operator+(c1); c3.show();c4=c1+c2;c4.show();出现的问题解决方案(列出遇到的问题和解决办法,列出未解决的问题)- 3 -。

运算符重载实验报告

运算符重载实验报告

运算符重载实验报告运算符重载实验报告引言:运算符重载是C++语言中的一项重要特性,它允许用户自定义运算符的行为。

通过运算符重载,可以使得程序更加直观、简洁,并提高代码的可读性和可维护性。

本实验旨在探索运算符重载的用法和效果。

一、实验目的本实验旨在通过实际操作,深入了解运算符重载的机制和使用方法,以及运算符重载对程序设计的影响。

二、实验环境本实验使用C++编程语言,并在Visual Studio开发环境下进行实验。

三、实验过程1. 了解运算符重载的基本概念运算符重载是指通过定义函数,改变运算符的行为。

在C++中,可以通过重载运算符函数来实现运算符的重载。

运算符重载函数的命名规则为"operator 运算符",例如"operator+"表示重载加法运算符。

2. 实现运算符重载的实验示例为了更好地理解运算符重载的使用方法,我们以矩阵的加法为例进行实验。

首先,定义一个Matrix类,并重载"+"运算符。

```cppclass Matrix {private:int** data;int rows;int cols;public:Matrix(int rows, int cols) {this->rows = rows;this->cols = cols;data = new int*[rows];for (int i = 0; i < rows; ++i) {data[i] = new int[cols];}}Matrix operator+(const Matrix& other) {Matrix result(rows, cols);for (int i = 0; i < rows; ++i) {for (int j = 0; j < cols; ++j) {result.data[i][j] = data[i][j] + other.data[i][j]; }}return result;}};```在上述代码中,我们定义了一个Matrix类,其中包含矩阵的数据成员data、行数rows和列数cols。

友元与运算符重载

友元与运算符重载
长方体积=6000
在上面的程序中,由于将长方体类定义为矩形类的友元,所以在长方体中,可以使用 矩形类中的私有数据成员计算长方体体积。
11.1.4 友元注意事项
(1)友元关系是不传递的Leabharlann 第 11 章 友元与运算符重载
友元函数可以是普通函数,也可以是某个类的成员函数,甚至可以将某个类说明成另 一个类的友元。下面就这三种友元进行讨论。
11.1.1 定义普通函数为友元函数
在定义一个类时,若在类中用关键词friend修饰普通函数,则该普通函数就成为该类的 友元函数,它可以访问该类中所有的成员。定义普通友元函数的格式为:
{ return r.Length*r.Width*High;}
在该函数内使用矩形对象 r 的私有数据成员 Length 与 Width 来计算长方体体积。由于
矩形对象 r 的私有数据成员不能在矩形类外使用,所以编译时会产生错误。解决问题的方法
之一就是将长方体类的成员函数 Volume()定义为矩形类的友元函数,即在矩形类中增加一
# include <iostream.h>
class Rectangle;
//A
class Cuboid
//B
{ private:
float High;
public:
Cuboid(float h)
{ High=h;}
float Volume(Rectangle &r);
//C
};
class Rectangle
friend <类型> <友元函数名> (形参表); 即:只要将用关键词 friend 修饰的普通函数原型说明写在类中,则该普通函数可以使用 类的所有成员。下面用例题进行说明。 【例 11.1】 用友元函数的方法求长方体的体积。 分析:先定义一个描述长方体的类 Cuboid,其私有数据成员为长方体的长(Length)、宽 (Width)、高(High),通过构造函数对长方体的数据成员进行初始化,见下列程序 A 行处。 再定义一个求长方体体积的普通函数 Volume(): float Volume(Cuboid &c) {return c.Length*c.Width*c.High;} 为了计算长方体对象 c 的体积,该函数的形参必须是长方体类的对象 c,并用该长方体 对象 c 的长、宽、高计算长方体的体积。由于 Volume()为普通函数,因此在其函数体内不 能使用长方体类 Cuboid 的私有数据成员 c.Length、c.Width、c.High,因而上述函数在编译 时会发生错误。解决问题方法之一就是将计算长方体体积的普通函数 Volume()定义为长方 体类的友元函数,即在长方体类 Cuboid 中增加一条将普通函数 Volume()定义成友元函数的 语句: friend float Volume(Cuboid &); 则在普通函数 Volume()内就可使用长方体类 Cuboid 的私有数据成员 c.Length、c.Width、 c.High。用友元函数方法求长方体体积的程序如下:

实验八运算符重载及应用

实验八运算符重载及应用

实验八运算符重载及应用实验八运算符重载及应用一、实验目的1.理解多态性概念及分类,熟悉C++中静态多态性的实现方法;2.理解运算符重载的意义,掌握在C++中用成员函数及友元函数实现运算符重载的方法;2.熟悉运算符重载的应用。

二、实验学时课内实验:2课时课外练习:2课时三本实验涉及的新知识㈠多态性的概念及分类1.多态性的概念多态性是指不同对象在收到相同的消息时,产生不同的动作。

即用同一个名字定义不同的函数,执行不同但相似的操作,从而实现“一个接口,多种方法”。

2.多态性的分类及实现方法⑴静态多态性。

亦称编译时多态性,即静态联编支持的多态性,在C++中通过函数重载及运算符重载实现。

⑵动态多态性。

亦称运行时多态性,即动态联编支持的多态性,在C++中通过虚函数实现。

3.函数重载的方法由前面实验中所涉及的知识可知,函数重载主要有以下方式:⑴同一个类中的同名函数,可用参数个数不一样或参数类型不一样或参数个数及类型不一样实现重载。

⑵同一类中,普通成员函数与同名的常量成员函数,可通过“const”实现重载。

⑶不同类中的同名函数,可通过类名调用或类的对象调用实现重载。

㈡运算符重载1.运算符重载的意义及作用C++中的运算符与函数一样,也可以实现重载,从而扩充C++预定义的运算符的作用范围。

编程者可以通过重载运行符扩充运算符的功能,使编写的程序更符合人们的思维习惯,更易于理解。

2.重载的运算符在C++中,大部分运算符可以重载,包括算术运算符、关系运算符、逻辑运算符、增量运算符、赋值运算符等。

如:+、-、*、/、%、&、=、+=、-=、&&、||、!、++、[]、new、delete等(除不能重载的几个运算符外,均可以重载)。

不能重载的运算符有:::——作用域运算符. ——成员访问运算符.* ——成员指针访问运算符: ——条件运算符3.用成员函数重载运算符⑴格式<返回类型> <类名>::operator@(参数表){ 函数体 }其中:返回类型通常为类名(也可以为其它类型);operator是重载运算符必须使用的定义符;@ 表示所重载的运算符,如+、-、*、/等。

友元函数单目运算符重载

友元函数单目运算符重载

友元函数单目运算符重载友元函数单目运算符重载是指在类中定义一个友元函数,用来重载类中的单目运算符,以实现对类的操作。

单目运算符是指只有一个操作数的运算符,例如:取地址运算符、递增递减运算符等。

下面是一个友元函数单目运算符重载的示例代码:```#include<iostream>using namespace std;class Number{private:int num;public:Number(int n):num(n){}friend Number operator++(Number&); // 友元函数递增运算符重载friend Number operator--(Number&); // 友元函数递减运算符重载void display(){cout<<"num="<<num<<endl;}};Number operator++(Number& n){n.num++;return n;}Number operator--(Number& n){n.num--;return n;}int main(){Number n1(10);n1.display(); // 输出10++n1; // 用递增运算符增加n1的值n1.display(); // 输出11--n1; // 用递减运算符减少n1的值n1.display(); // 输出10return 0;}```上面的代码中,定义了一个名为Number的类,其中包含私有成员变量num和公有方法display。

类中定义了两个友元函数operator++和operator--,用来重载递增和递减运算符。

在主函数中,通过对n1进行多次递增递减操作,验证了友元函数单目运算符重载的功能。

友元和运算符重载解读

友元和运算符重载解读

友元
• 友员有3种: 友员函数 友员类 友员成员函数
Date:27 September 2018
IT Education & Training
友元
• 友元是C++提供的一种破坏数据封装和数据隐藏 的机制。 • 通过将一个模块声明为另一个模块的友元,一个 模块能够引用到另一个模块中本是被隐藏的信息。 • 可以使用友元函数和友元类。 • 为了确保数据的完整性,及数据封装与隐藏的原 则,建议尽量不使用或少使用友元。
Date:27 September 2018
IT Education & Training
1. 运算符重载概念
• • • • • 1). 什么叫重载? 重载既赋予新的含义。 2).什么叫运算符重载? 指对已知的运算符,在新的场合,通过程序实现新的行为。 3). 运算符重载的作用是什么? 它允许你为类的用户提供一个直觉的接口。 运算符重载允许C/C++的运算符在用户定义类型(类)上拥有 一个用户定义的意义。重载的运算符是函数调用的语法修饰:
Date:27 September 2018
IT Education & Training
友元函数
• 友元函数是在类声明中由关键字friend修饰说明的 非成员函数,在它的函数体中能够通过对象名访 问 private 和 protected成员 • 作用:增加灵活性,使程序员可以在封装和快速 性方面做合理选择。
Date:27 September 2018
IT Education & Training
double Distance( Point& a, Point& b) { double dx=a.X-b.X; double dy=a.Y-b.Y; return sqrt(dx*dx+dy*dy); } int main() { Point p1(3.0, 5.0), p2(4.0, 6.0); double d=Distance(p1, p2); cout<<"The distance is "<<d<<endl; 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运算符重载函数作为类成员函数和友元函数

C运算符重载函数作为类成员函数和友元函数

C运算符重载函数作为类成员函数和友元函数IMB standardization office【IMB 5AB- IMBK 08- IMB 2C】C++运算符重载的方法运算符重载的方法是定义一个重载运算符的函数,在需要执行被重载的运算符时,系统就自动调用该函数,以实现相应的运算。

也就是说,运算符重载是通过定义函数实现的。

运算符重载实质上是函数的重载。

重载运算符的函数一般格式如下:函(形参表列){前两个运算符不能重载是为了保证访问成员的功能不能被改变,域运算符和sizeof 运算符的运算对象是类型而不是变量或一般表达式,不具备重载的特征。

C++运算符重载函数作为类成员函数和友元函数例中对运算符“+”进行了重载,使之能用于两个复数的相加。

在该例中运算符重载函数operator+作为Complex类中的成员函数。

可能有的读者会提出这样的问题:”+“是双目运算符,为什么在例程序中的重载函数中只有一个参数呢?实际上,运算符重载函数有两个参数,由于重载函数是Complex类中的成员函数,有一个参数是隐含的,运算符函数是用this指针隐式地访问类对象的成员。

可以看到,重载函数operator+访问了两个对象中的成员,一个是this指针指向的对象中的成员,一个是形参对象中的成员。

如this->real+,this->real就是。

上节中已说明,在将运算符函数重载为成员函数后,如果出现含该运算符的表达式,如c1+c2,编译系统把它解释为:+(c2)即通过对象c1调用运算符重载函数,并以表达式中第二个参数(运算符右侧的类对象c2)作为函数实参。

运算符重载函数的返回值是Complex类型,返回值是复数c1和c2之和(Complex+,+)。

运算符重载函数除了可以作为类的成员函数外,还可以是非成员函数。

可以将例改写为例。

[例]将运算符“+”重载为适用于复数加法,重载函数不作为成员函数,而放在类外,作为Complex类的友元函数。

C++运算符重载三种形式(成员函数,友元函数,普通函数)详解

C++运算符重载三种形式(成员函数,友元函数,普通函数)详解

C++运算符重载三种形式(成员函数,友元函数,普通函数)详解三种重载⽅式⾸先,介绍三种重载⽅式:1//作为成员函数重载(常见)2class Person{3 Private:4string name;5int age;6public:7 Person(const char* name, int age):name(name),age(age){}8bool operator<(const Person& b);910 };11bool Person::operator<(const Person& b)12 {13//作为成员函数时,*this即为左操作数a14 ...15 }1//作为友元函数重载2class Person{3private:4string name;5int age;6public:7 Person(const char* name, int age):name(name),age(age){}8 friend bool operator<(const Person& a,const Person& b);910 };11bool operator<(const Person& a,const Person& b)12 {13 ...14 }1//作为普通函数重载(不推荐)2class Person{3public://注意,重载运算符为普通函数时,使⽤到的类成员必须为public4string name;5int age;6public:7 Person(const char* name, int age):name(name),age(age){}89 };10bool operator<(const Person& a,const Person& b)11 {12 ...13 }作为成员函数重载先介绍第⼀种:bool Person::operator<(const Person& b),bool是函数返回类型,Person::只是指定了成员函数所属类名。

C++程序设计基础教程 第8章 友元函数与运算符重载

C++程序设计基础教程 第8章 友元函数与运算符重载

友元可以是一个函数,该函数被称为友元函数;友元 可以是一个类,该类被称为友元类。
友元函数是一种普通函数,不是类的成员函数,说明 时在函数前面加以关键字friend,它可以象成员函数一 样不受限制地访问该类的任何成员。
2019/2/22
第8章 友元函数与运算符重载
8.1 友元函数与友元类
友元函数 定义格式: (1)类中定义 friend 类型 函数名( 形参 ) { 函数体 } (2)类中说明,类外定义 类中原型说明: friend 类型 函数名(形参); 类外定义: 类型 函数名(形参) { 函数体 }
第8章 友元函数与运算符重载
8.1 友元函数与友元类
int main( ){ B b1; C c1(30 , 40); b1.show(c1); b1.sub(c1); b1.show(c1); return 0; }
第8章 友元函数与运算符重载
8.2 运算符重载
对于大多数程序设计语言,运算符的定义由编译器 给出,且这种用法是不允许用户改变的。在C++中, 允许用户重新定义已有的运算符,并按规定要求去完 成特定的操作。 使用成员函数或友元函数,通过操作对象成员,从 而实现对象参加运算的目的。
2019/2/22
第8章 友元函数与运算符重载
8.1 友元函数与友元类
【例8-1】求圆柱体的体积。
#include<iostream> using namespace std; const float PI=3.1415 ; class A{ float r,h; public: A(float a,float b){r=a;h=b;} friend float v1(A &); //友元函数volum的原型说明 float v2( ){ return PI*r*r*h;} float getr(){return r;} float geth(){return h;} };

8 友元和运算符重载-1

8 友元和运算符重载-1
第十六章
友元和运算符重载-1
1
目标
• • • • • • 友元函数 友元类 运算符重载的概念 以成员的方式重载运算符 以友元函数的方式重载运算符 一般单目元算符的重载
2
类的友元
• 可以把某些选定的函数看作类的“荣誉函 数”,允许它们访问类对象中非公共的成 员,就好像它们是类的成员一样,这种函 数称为类的友元。友元可以访问类对象的 任意成员。 • 可以把一个函数指定为类的友元,也可以 把整个类指定为另一个类的友元。
5
友元函数的注意事项
• 友元函数不是类的成员函数,在函数体中访问对象的成员 ,必须用对象名加运算符“.”加对象成员名。但友元函 数可以访问类中的所有成员(公有的、私有的、保护的) ,一般函数只能访问类中的公有成员。 • 友元函数不受类中的访问权限关键字限制,可以把它放在 类的公有、私有、保护部分,但结果一样。 • 某类的友元函数的作用域并非该类作用域。如果该友元函 数是另一类的成员函数,则其作用域为另一类的作用域, 否则与一般函数相同。 • 友元函数破坏了面向对象程序设计类的封装性,所以友元 函数如不是必须使用,则尽可能少用。或者用其他手段保 证封装性。
一元运算符重载
• 操作数是自定义类的对象或对象的引用 • 作为成员函数重载没有参数 • 作为友元函数重载参数为自定义类的对象 或对象的引用
17
成员函数的方式重载!3-1
//文件CString.h #ifndef CSTRING_H #define CSTRING_H class CString{ public: CString(const char *s=""); CString(const CString& s); ~CString(); CString& operator = (const CString& s); CString& operator = (const char *s); bool operator !(); char *m_str; private: int m_size; }; #endif

C++学习之路—运算符重载(二)运算符重载作为类的成员函数和友元函数

C++学习之路—运算符重载(二)运算符重载作为类的成员函数和友元函数

C++学习之路—运算符重载(⼆)运算符重载作为类的成员函数和友元函数对运算符重载的函数有两种处理⽅式:(1)把运算符重载的函数作为类的成员函数;(2)运算符重载的函数不是类的成员函数,在类中把它声明为友元函数。

1 把运算符重载函数作为类的成员函数例1:为了便于说明问题,将重载函数的定义重写如下:1: Complex Complex :: operator + ( Complex& c2 )2: {3: Complex c ;4: c.real = real + c2.real ;5: c.imag = imag + c2.imag ;6:return c ;7: }有⼈可能会提出这样的疑问:“+”是双⽬运算符,为什么重载函数只有⼀个参数呢?实际上,运算符重载函数应当有两个参数,但是,由于重载函数是Complex类中的成员函数,因此有⼀个参数是隐含的,运算符函数是⽤this指针隐式的访问类对象的成员。

可以看到operator+访问了两个对象中的成员,⼀个是this指针指向的对象中的成员,⼀个是形参对象中的成员。

2 把运算符重载函数作为类的友元函数运算符重载函数除了可以作为类的成员函数外,还可以是⾮成员函数。

在有关的类中把它声明为友元函数,即友元运算符重载函数。

例2:将运算符+重载为适⽤于复数加法,重载函数不作为成员函数,⽽放在类外,作为Complex类的友元函数。

1:class Complex2: {3:public:4: ...5:friend Complex operator + ( Complex& c1 , Complex& c2 ) ; //重载函数作为友元函数6:private:7:double real ;8:double imag ;9: };10:11: Complex operator + ( Complex& c1 , Complex& c2 ) //定义运算符+重载函数12: {13: Complex c ;14: c.real = c1.real + c2.real ;15: c.imag = c1.imag + c2.imag ;16:return c ;17: }这个程序和把运算符重载函数作为类的成员函数相⽐,只做了⼀处改动,就是将运算符重载函数作为类外的普通函数,并在Complex类中声明它为友元函数。

运算符重载实验报告

运算符重载实验报告
};
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日

运算符重载的规则

运算符重载的规则

运算符重载的规则
运算符重载是C++中的一个强大的特性,它允许程序员定义自己的运算符,以便让它们适用于特定的数据类型。

然而,运算符重载必须遵循一定的规则,否则会产生错误或不可预测的行为。

首先,运算符重载必须是一个成员函数或一个友元函数。

成员函数重载的运算符将被应用于该类的对象,而友元函数可以通过传递对象的引用或指针来重载运算符。

其次,运算符重载必须遵循该运算符的原始语义。

例如,+运算符应该执行加法操作,而不是乘法或除法操作。

这意味着,必须保证重载后的运算符具有正确的返回类型和参数类型,并且应该按照原始运算符的规则来执行操作。

另外,必须注意运算符的优先级和结合性。

例如,重载+和*运算符时,必须确保它们的优先级和结合性与原始运算符相同,以避免歧义和错误。

最后,必须小心地使用运算符重载。

它可以使代码更加简洁和易读,但也可能会导致代码变得难以理解和维护。

因此,必须谨慎使用运算符重载,仅在必要时使用它。

总之,运算符重载是一种强大的特性,可以使程序更加灵活和易于使用。

但是,必须遵循一定的规则,才能确保其正确性和可预测性。

- 1 -。

实验8--友元函数与运算符重载函数

实验8--友元函数与运算符重载函数

实验十三1.实验目的通过本次实验(1)理解友元函数与运算符重载函数的概念;(2)学会友元函数的定义与使用方法;(3)掌握运算符重载函数的定义与使用方法;2.实验要求(1)编写实验程序(2)在VC++运行环境中,输入源程序(3)编译运行源程序(4)输入测试数据进行程序测试;(5)写出运行结果。

3.实验内容(1)定义一个复数类,重载“-=”运算符,使这个运算符能直接完成复数的“-=”运算。

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

在主函数中定义复数对象c1(10,20)、c2(15,30),进行c2-=c1的复数运算,并输出c1、c2的复数值。

参考资料:(1)成员函数# include <iostream.h>class Complex{ private:float Real,Image;public:Complex(float r=0,float i=0){ Real=r;Image=i;}void Show(int i){ cout<<"c"<<i<<"=" <<Real<<"+"<<Image<<"i"<<endl;}void operator +=(Complex &c){ Real=Real+c.Real;Image=Image+c.Image;}};void main(void){ Complex c1(10,20),c2(15,30);c1.Show(1);c2.Show(2);c2+=c1;c2.Show(2);}友元函数# include <iostream.h>class Complex{ private:float Real,Image;public:Complex(float r=0,float i=0){ Real=r;Image=i;}void Show(int i){ cout<<"c"<<i<<"=" <<Real<<"+"<<Image<<"i"<<endl;}friend void operator +=(Complex &c1,Complex &c2);};void operator +=(Complex &c1,Complex &c2){ c1.Real=c1.Real+c2.Real;c1.Image=c1.Image+c2.Image;}void main(void){ Complex c1(10,20),c2(15,30);c1.Show(1);c2.Show(2);c2+=c1;c2.Show(2);}(2)定义一个数组类Array,其私有数据成员为整型一维数组a[10]。

友元函数和运算符重载

友元函数和运算符重载

友元函数和运算符重载友元⼀个常规的成员函数声明描述了三件在逻辑上相互不同的事情①该函数能访问类声明中的私⽤部分②该函数位于作⽤域之中③该函数必须经由⼀个对象去激活(有⼀个this指针)通过将函数声明为static,可以让他只有前两种性质通过将⼀个函数声明为友元可以使他只具有第⼀种性质单(++,--)、双⽬运算符(+,-,*,/,%,|,&,+=,-=,*=,/=)的重载(双⽬重载绝⼤多数只考虑对象与对象进⾏的操作),输⼊输出运算符作为友元函数的重载。

//Test1.h#include<iostream>using namespace std;class INT{friend INT operator+(int a, const INT &t);friend ostream& operator<<(ostream &out, const INT &t);friend istream& operator>>(istream &in, INT &t);private:int a;long b;public:INT(int _a=0,long _b=0):a(_a),b(_b){this->a=_a;this->b=_b;}INT(INT &t){this->a = t.a;this->b = t.b;}~INT(){}INT& operator=(const INT &t);INT operator+(const INT &t);INT operator+(int i);INT operator-(const INT &t);INT operator*(const INT &t);INT operator/(const INT &t);INT operator%(const INT &t);INT operator&(const INT &t);INT operator|(const INT &t);INT& operator+=(const INT &t);//因为结果返回本⾝,因此使⽤引⽤更快捷INT& operator-=(const INT &t);INT& operator*=(const INT &t);INT& operator/=(const INT &t);INT& operator%=(const INT &t);INT& operator++();//++a引⽤返回this就不⽤拷贝构造了INT operator++(int);//后++⽐前++多⼀个参数//a++INT& operator--();INT operator--(int);};INT& INT::operator%=(const INT &t){this->a %= t.a;this->b %= t.b;return *this;}INT& INT::operator/=(const INT &t){if(t.a != 0){this->b /= t.b;this->a /= t.a;return *this;}exit(0);}INT& INT::operator*=(const INT &t){this->a *= t.a;this->b *= t.b;return *this;}INT& INT::operator-=(const INT &t){this->a -= t.a;this->b -= t.b;return *this;}INT& INT::operator+=(const INT &t){this->a += t.a;this->b += t.b;return *this;}INT INT::operator|(const INT &t){return(this->a|t.a, this->b|t.b);}INT INT::operator&(const INT &t){return(this->a&t.a, this->b&t.b);}INT INT::operator%(const INT &t){return(this->a%t.a, this->b%t.b);}INT INT::operator/(const INT &t){if(t.a != 0)return(this->a/t.a,this->b/t.a);exit(0);}INT INT::operator*(const INT &t){return (this->a*t.a, this->b*t.b);}INT INT::operator++(int){INT tmp(this->a,this->b);++this->a;++this->b;return tmp;}INT& INT::operator++(){++this->a;++this->b;return *this;}INT INT::operator--(int){INT tmp(this->a);--this->a;--this->b;return tmp;}INT& INT::operator--(){--this->a;--this->b;return *this;}INT INT::operator+(const INT &t){return(this->a+t.a,this->b+t.b);;//将(this->a+t.a)隐式转换为⼀个⽆名的临时对象。

实验八 运算符重载

实验八 运算符重载

实验八运算符重载
实验目的
理解重载运算符的作用,学会对典型的运算符进行重载。

实验内容
1.编写程序重载字符串运算符+、<分别用于字符串的拼接、比较运算,实现字
符串直接操作。

其中<运算符重载函数为友元函数,而+运算符重载为成员函数。

2.编写一个矩形类rect,分别采用友元函数的方式重载和成员函数的方式重载
运算符<、>、==,用于比较两个矩形面积是否相等。

3.在point类中定义一个运算符函数,用于两个对象a和b相加,其结果为一
个point类对象c,c中的x和y分别为对象a和b的x和y的和。

(+操作符作为成员函数重载)
4.在point类中定义一个运算符函数,用于两个对象a和b相加,其结果为一
个point类对象c,c中的x和y分别为对象a和b的x和y的和。

(+操作符作为友元函数重载)
5.以下程序通过重载运算符+、*实现集合(用数组表示)的并(∪)、交(∩)运算。

集合中的元素不能相同。

两个集合的并包含了两个集合的所有元素。

两个集合的交仅包含两个集合中共同存在的元素。

设s1={1,2,3,4,5,6},s2={3,
6.定义一个人民币类RMB,包含私有数据成员元、角、分,请用友元函数重。

C++友元与运算符重载

C++友元与运算符重载

《c++面向对象程序设计》实验报告实验序号:8 实验项目名称:友元与运算符重载1:#include<iostream> using namespace std;namespace std{class fraction{private:int num; //分int deno; //分母public:fraction(){num=0;deno=0;}fraction(int a,int b);fraction reduction(fraction f);int frac(fraction f); //取整数部分double frac1(fraction f); //将分数转变成小数friend fraction operator+(fraction f,fraction k); //重载+运算符friend fraction operator-(fraction f,fraction k); //重载-运算符friend fraction operator*(fraction f,fraction k); //重载*运算符friend fraction operator/(fraction f,fraction k); //重载/运算符friend ostream& operator<<(ostream& outs,const fraction &f);friend istream& operator>>(istream& ins, fraction &f); //分子分母仅有一位*/void show();};fraction::fraction(int a,int b){num=a;deno=b;}fraction fraction::reduction(fraction a){int i;if(a.num%a.deno==0){a.num=a.num/a.deno;a.deno=1;}else{for(i=2;i<=10;i++){if(a.num%i==0){if(a.deno%i==0){a.num=a.num/i;a.deno=a.deno/i;i=i-1;}}}}return fraction(a.num,a.deno);}void fraction::show(){cout<<endl<<num<<"/"<<deno;}int fraction::frac(fraction f) //取整数部分{int a;a=f.num/f.deno;return(a);}double fraction::frac1(fraction f){double a;a=double(f.num)/double(f.deno);return(a);}fraction operator+(fraction f,fraction k){fraction one;one.num=f.num*k.deno+k.num*f.deno;one.deno=f.deno*k.deno;one=one.reduction(one);return one;}fraction operator-(fraction f,fraction k){fraction one;one.num=f.num*k.deno-k.num*f.deno;one.deno=f.deno*k.deno;one=one.reduction(one);return one;}fraction operator*(fraction f,fraction k){fraction one;one.num=f.num*k.num;one.deno=f.deno*k.deno;one=one.reduction(one);return one;}fraction operator/(fraction f,fraction k){fraction one;one.num=f.num*k.deno;one.deno=f.deno*k.num;one=one.reduction(one);return one;}ostream& operator<<(ostream& outs,const fraction &f) {outs<<f.num<<"/"<<f.deno;return(outs);}istream& operator>>(istream& ins, fraction &f){char a;cout<<endl<<"请输入分数(num/deno):";ins>>f.num>>a>>f.deno;f=f.reduction(f);return ins;}}int main(){int a;double b;fraction one(1,2),two(2,3),four,five;one.show();two.show();one=one.reduction(one);one.show();a=one.frac(one);b=one.frac1(one);cout<<endl<<"整数部分为:"<<a;cout<<endl<<"将分数转变成小数为:"<<b;four=one+two;four.show();four=one-two;four.show();four=one*two;four.show();four=one/two;four.show();cout<<endl<<four;cin>>five;cout<<five;cout<<endl;return(0);}运行结果:2:重载函数为类的成员函数:#include<iostream>using namespace std;class complex{private:int real,imag;public:complex(){real=0;imag=0;};complex(int r,int i);complex operator-(complex f);complex operator-=(complex f);complex operator*=(complex f);complex operator/=(complex f);void didplay();};complex::complex(int r,int i){real=r;imag=i;}complex complex::operator-(complex f){complex one;one.real=real-f.real;one.imag=imag-f.imag;return one;}complex complex::operator-=(complex f) {real=real-f.real;imag=imag-f.imag;return complex(real,imag);}complex complex::operator*=(complex f) {real=real*f.real;imag=imag*f.imag;return complex(real,imag);}complex complex::operator/=(complex f) {real=real/f.real;imag=imag/f.imag;return complex(real,imag);}void complex::didplay(){cout<<endl<<"real="<<real;cout<<endl<<"imag="<<imag;}int main(){complex one(1,2),two(2,3),a;a=two-one;a.didplay();one-=two;one.didplay();one*=two;one.didplay();one/=two;one.didplay();cout<<endl;return(0);}运行结果:重载函数为类的成员函数:#include<iostream>using namespace std;namespace std{class complex{private:int real,imag;public:complex(){real=0;imag=0;};complex(int r,int i);friend complex operator-(complex f,complex k);friend complex operator-=(complex &f,complex &k);friend complex operator*=(complex &f,complex &k);friend complex operator/=(complex &f,complex &k);void didplay();};complex::complex(int r,int i){real=r;imag=i;}complex operator-(complex f,complex k){complex one;one.real=f.real-k.real;one.imag=f.imag-k.imag;return one;}complex operator-=(complex &f,complex &k){return complex(f.real-=k.real,f.imag-=k.imag);}complex operator*=(complex &f,complex &k){return complex(f.real*=k.real,f.imag*=k.imag); }complex operator/=(complex &f,complex &k){return complex(f.real/=k.real,f.imag/=k.imag); }void complex::didplay(){cout<<endl<<"real="<<real;cout<<endl<<"imag="<<imag;}}int main(){complex one(1,2),two(2,3),a;a=two-one;a.didplay();one-=two;one.didplay();one*=two;one.didplay();one/=two;one.didplay();cout<<endl;return(0);}运行结果:。

运算符重载和友元函数

运算符重载和友元函数

运算符重载和友元函数1. 运算符重载c++允许将运算符重载扩展到⽤户定义的类型,例如:允许使⽤+将两个对象相加,编译器将根据操作数的数⽬和类型决定使⽤哪种加法定义,重载运算符可以使代码看起来更加⾃然。

例:计算时间,⼀个运算符重载的实例:class Time {private:int hours;int minutes;public:Time() {}Time(int hours, int minutes) {this->hours = hours;this->minutes = minutes;}void setHours(int hours) {this->hours = hours;}int getHours() {return this->hours;}void setMinutes(int minutes) {this->minutes = minutes;}int getMinutes() {return this->minutes;}Time operator+(const Time& t) const {Time sum;sum.minutes = t.minutes + this->minutes;sum.hours = t.hours + this->hours + sum.minutes / 60;sum.minutes = sum.minutes % 60;return sum;}Time operator*(double mult) const {Time result;long totalMinutes = hours * mult * 60 + minutes * mult;result.hours = totalMinutes / 60;result.minutes = totalMinutes % 60;return result;}};测试:2. 友元函数运算符重载中,下⾯的语句A =B * 3.5将被转成下⾯的成员函数调⽤A = B.operator*(3.5)但是下⾯的语句⼜会如何呢A = 3.5 * B; // cannot correspond to a member function解决这个问题的⼀种⽅式是,告诉每个⼈,只能按照B * 3.5这种格式编写,这是⼀种对服务器友好-客户警惕的解决⽅案,与OOP⽆关还有⼀种⽅式:⾮成员函数,⾮成员函数不是由对象调⽤的,它使⽤的所有值都是显式参数,这样编译器能够将下⾯的表达式A = 3.5 * B与⾮成员函数匹配A = operator*(3.5, B);该函数的原型如下:Time operator*(double m, const Time& t);对于⾮成员重载运算符函数⽽⾔,运算符左边的操作数等于操作符函数的第⼀个参数,运算符表达式右边的操作数对应于运算符函数的第⼆个参数。

友元和运算符重载

友元和运算符重载
• 7). 运算符重载后,优先级和结合性怎么办? 用户重载新定义运算符,不改变原运算符的优先级 和结合性。这就是说,对运算符重载不改变运算符 的优先级和结合性,并且运算符重载后,也不改变 运算符的语法结构,即单目运算符只能重载为单目 运算符,双目运算符只能重载双目运算符。 8). 编译程序如何选用哪一个运算符函数? • 运算符重载实际是一个函数,所以运算符的重载实 际上是函数的重载。编译程序对运算符重载的选择, 遵循着函数重载的选择原则。当遇到不很明显的运 算时,编译程序将去寻找参数相匹配的运算符函数。
// 哈哈,多可笑...
Date:27 November 2018
IT Education & Training
1. 运算符重载概念
• 4).算符重载的好处是什么? 通过重载类上的标准算符,你可以发掘类的用户的 直觉。使得用户程序所用的语言是面向问题的,而 不是面向机器的。
Date:27 November 2018
Date:27 November 2018
IT Education & Training
1. 运算符重载概念
• 9). 重载运算符有哪些限制? (1) 不可臆造新的运算符。必须把重载运算符限制在C++语言 中已有的运算符范围内的允许重载的运算符之中。 (2) 重载运算符坚持4个“不能改变”。
· 不能改变运算符操作数的个数; · 不能改变运算符原有的优先级; · 不能改变运算符原有的结合性; · 不能改变运算符原有的语法结构。
• 访问对象中的成员必须通过对象名。
Date:27 November 2018
IT Education & Training
例10 使用友元函数计算两点距离
  1. 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
  2. 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
  3. 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。

实验十三
1.实验目的
通过本次实验
(1)理解友元函数与运算符重载函数的概念;
(2)学会友元函数的定义与使用方法;
(3)掌握运算符重载函数的定义与使用方法;
2.实验要求
(1)编写实验程序
(2)在VC++运行环境中,输入源程序
(3)编译运行源程序
(4)输入测试数据进行程序测试;
(5)写出运行结果。

3.实验内容
(1)定义一个复数类,重载“-=”运算符,使这个运算符能直接完成复数的“-=”运算。

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

在主函数中定义复数对象c1(10,20)、c2(15,30),进行c2-=c1的复数运算,并输出c1、c2的复数值。

参考资料:
(1)成员函数
# include <iostream.h>
class Complex
{ private:
float Real,Image;
public:
Complex(float r=0,float i=0)
{ Real=r;Image=i;}
void Show(int i)
{ cout<<"c"<<i<<"=" <<Real<<"+"<<Image<<"i"<<endl;}
void operator +=(Complex &c)
{ Real=Real+c.Real;
Image=Image+c.Image;
}
};
void main(void)
{ Complex c1(10,20),c2(15,30);
c1.Show(1);
c2.Show(2);
c2+=c1;
c2.Show(2);
}
友元函数
# include <iostream.h>
class Complex
{ private:
float Real,Image;
public:
Complex(float r=0,float i=0)
{ Real=r;Image=i;}
void Show(int i)
{ cout<<"c"<<i<<"=" <<Real<<"+"<<Image<<"i"<<endl;}
friend void operator +=(Complex &c1,Complex &c2);
};
void operator +=(Complex &c1,Complex &c2)
{ c1.Real=c1.Real+c2.Real;
c1.Image=c1.Image+c2.Image;
}
void main(void)
{ Complex c1(10,20),c2(15,30);
c1.Show(1);
c2.Show(2);
c2+=c1;
c2.Show(2);
}
(2)定义一个数组类Array,其私有数据成员为整型一维数组a[10]。

通过构造函数给a[10]赋初值。

用Show函数显示a[10]的元素值。

用成员函数重载运算符“+”,直接实现两个一维数组对应元素相加的运算。

在主函数中定义数组a、b分别为:
int a[10]={1,2,3,4,5,6,7,8,9,10}; int b[10]={4,5,6,7,8,9,10,11,12,13};
用Array定义三个数组对象arr1(a)、arr2(b)、arr3,执行arr3=arr1+arr2运算,输出arr3的数组元素值。

类似地,用友元函数重载运算符“+=”,实现复合赋值运算:arr1+=arr2,并输出arr1的元素值。

(3)定义一个人民币类Money,类中数据成员为元、角、分。

用成员函数与友元函数重载“――”运算符,实现人民币对象的减1运算。

在主函数中定义人民币对象m1=10元8角5分及对象m2、m3。

对m1作前置“――”并赋给m2。

对m1作后置“――”并赋给m3。

显示m1、m2、m3的结果。

(4)定义描述字符串的类String,编写字符串运算符“+=”的重载函数,使运算符“+=”用于两个字符串联接操作,即用str1+=str2实现字符串函数strcat(str1,str2)的操作功能。

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

在主函数中定义字符串对象s1("software and ")与s2("hardware"),进行s1+=s2的字符串联接,并输出s1、s2的值。

相关文档
最新文档