下载文档原格式
《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。
实验八运算符重载及应用实验八运算符重载及应用一、实验目的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进行多次递增递减操作，验证了友元函数单目运算符重载的功能。
一、实验目的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运算符重载函数作为类成员函数和友元函数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++运算符重载三种形式（成员函数，友元函数，普通函数）详解三种重载⽅式⾸先，介绍三种重载⽅式：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++学习之路—运算符重载（⼆）运算符重载作为类的成员函数和友元函数对运算符重载的函数有两种处理⽅式：（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类中声明它为友元函数。
运算符重载的规则
运算符重载是C++中的一个强大的特性，它允许程序员定义自己的运算符，以便让它们适用于特定的数据类型。
然而，运算符重载必须遵循一定的规则，否则会产生错误或不可预测的行为。
首先，运算符重载必须是一个成员函数或一个友元函数。
成员函数重载的运算符将被应用于该类的对象，而友元函数可以通过传递对象的引用或指针来重载运算符。
其次，运算符重载必须遵循该运算符的原始语义。
例如，+运算符应该执行加法操作，而不是乘法或除法操作。
这意味着，必须保证重载后的运算符具有正确的返回类型和参数类型，并且应该按照原始运算符的规则来执行操作。
另外，必须注意运算符的优先级和结合性。
例如，重载+和*运算符时，必须确保它们的优先级和结合性与原始运算符相同，以避免歧义和错误。
最后，必须小心地使用运算符重载。
它可以使代码更加简洁和易读，但也可能会导致代码变得难以理解和维护。
因此，必须谨慎使用运算符重载，仅在必要时使用它。
总之，运算符重载是一种强大的特性，可以使程序更加灵活和易于使用。
但是，必须遵循一定的规则，才能确保其正确性和可预测性。
- 1 -。
实验十三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，包含私有数据成员元、角、分，请用友元函数重。
实验十三
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的值。
