C++成员函数运算符重载减法
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++面向程序设计（第二版）课后习题答案解析
C++⾯向程序设计（第⼆版）课后习题答案解析最近没什么⼼情整理零散的知识点，就整理⼀下第四章的课后习题答案。
1.定义⼀个复数类Complex，重载运算符“+”，使之能⽤于复数的加法运算。
将运算符函数重载为⾮成员函数，⾮友元的普通函数。
编程序，求两个复数之和。
源代码：1 #include <iostream>2 #include<stdlib.h>3using namespace std;4class Complex5 {public:6 Complex(){real=0;imag=0;}7 Complex(double r,double i){real=r;imag=i;}8double get_real();//获取实部函数9double get_imag();//获取虚部函数10void display();//显⽰函数11private:12double real;13double imag;14 };1516//实现具体的函数17double Complex::get_real()18 {19return real;20 }21double Complex::get_imag()22 {23return imag;24 }25void Complex::display()26 {27 cout<<"("<<real<<","<<imag<<"i)"<<endl;28 }29//重载运算符“+”30 Complex operator + (Complex &c1,Complex &c2)31 {32return Complex(c1.get_real()+c2.get_real(),c1.get_imag()+c2.get_imag());33 }343536int main()37 {38 Complex c1(3,4),c2(5,-10),c3;39 c3=c1+c2;40 cout<<"c3=";41 c3.display();42 system("pause");43return0;44 }2.定义⼀个复数类Complex，重载运算符“+”，“-”，“*”，“/”，使之能⽤于复数的加，减，乘，除。
C++笔记——在模板类中重载操作符
C++笔记 ——在模板类中重载操作符
实现了一个Matrix模板类，以此为例记录一下在模板类中重载常用的运算符。
不是所有运算符都可以重载，不能被重载的运算符有：长度运算符sizeof，条件运算符？，成员选择运算符.，域解析运算符::
23 Matirx<T> operator+(T1 a){
24
Matirx<T> temp(row, col);
25
for(int i = 0; i < row * col; i++)
26
values[i] += (T)a;
27
return temp;
28 }
29
30 template <typename T1>
9
Matirx<T> tmp(1, col);
10
for(int i = 0; i < col; ++i)
11
tmp.values[i] = values[(r - 1) * col + i];
12
return tmp;
13 }
10.其他
除了面提到的运算符，常用的运算符还有复合运算符（比如+=，*=）和方括号运算符[]（用于支持随机访问）以及delete和delete[] 运算符， 由于这些运算符重载方式都大同小异，基本上能在以上的几种中找到差不多的例子，不再赘述。
重载操作符需要特别注意的一点是函数的参数表和返回值的形式。
重载操作符有两种方法，一种是重载为成员函数，一种是重载为友元。
c++结构体重载减号运算符
在C++中，你可以重载减号运算符（`-`）来为自定义的结构体或者类实现减法操作。
以下是一个简单的例子，它定义了一个名为`Vector`的结构体，并重载了减号运算符：```cpp#include <iostream>#include <cmath>struct Vector {double x, y, z;Vector(double x = 0.0, double y = 0.0, double z = 0.0) : x(x), y(y), z(z) {}double length() {return std::sqrt(x * x + y * y + z * z);}Vector operator - (const Vector& rhs) {return Vector(-rhs.x, -rhs.y, -rhs.z);}};int main() {Vector a(1.0, 2.0, 3.0);Vector b(4.0, 5.0, 6.0);Vector c = a - b;std::cout << "The length of the difference vector is: " << c.length() << std::endl;return 0;}```在这个例子中，`Vector`结构体有一个构造函数，可以初始化`x`，`y`，`z`三个分量。
它还重载了减号运算符，使得我们可以对两个`Vector`对象执行减法操作。
这个减法操作实际上是返回一个新的`Vector`对象，它的每个分量都是被减数（即`a`）对应分量和减数（即`b`）对应分量的差的相反数。
最后，我们计算并打印出差向量的长度。
c++学习资料第 06 章 运算符重载
第 6 章 运 算 符 重 载
{ return Complex( c.Real, c.Image ); } void Complex::print()const { cout << '(' << Real << " , " << Image << ')' << endl; } void main() { Complex c1( 2.5,3.7 ), c2( 4.2, 6.5 ) ; Complex c ; c = c1 c2 ; // operator(c1,c2) c.print() ; c = 25 + c2 ; // operator+(25,c2) c.print() ; c = c2 + 25 ; // operator+(c2,52) c.print() ; c = c1 ; // operator(c1) c.print() ; } 当一个运算符的操作需要修改类对象状态时，应该以成员函数重载。例如，需要左值操 作数的运算符（如 =，*=，++ 等）应该用成员函数重载。如果以友员函数重载，可以使用 引用参数修改对象。 当运算符的操作数（尤其是第一个操作数）希望有隐式转换，则重载算符时必须用友员 函数或普通函数。 C++中不能用友员函数重载的运算符有 = （） ［］ －> 6.3 几个典型运算符重载 本节讨论在数学类中常用的几个运算符重载的特点和应用。 6.3.1 重载 ++ 与 自增和自减运算符有前置和后置两种形式。每个重载运算符的函数都必须有明确的特 征，使编译器确定要使用的版本。C++规定，前置形式重载为一元运算符函数，后置形式重 载为二元运算符函数。 【例 64】例 62 中使用了成员函数重载++和运算符。本例用友员函数重载++运算符。 设有简单类定义 class Increase { public : Increase() ; … friend Increase operator ++ ( Increase & ) ; friend Increase operator ++ ( Increase & , int ) ; private : unsigned value ; } ; 则前置重载的实现为： Increase operator++ ( Increase & a ) { a.value ++ ;
c 函数重载 方法
c 函数重载方法
C函数重载是C语言中一种非常有用的编程技术，它允许我们定义多个具有相同名称但参数列表不同的函数。
通过函数重载，我们可以使用相同的函数名来执行不同的操作，这样可以提高代码的可读性和灵活性。
在C语言中，函数重载是通过函数名相同但参数列表不同来实现的。
当调用一个重载函数时，编译器会根据传入的参数类型和数量来决定调用哪个函数。
这样，我们可以根据需要定义多个具有相同函数名但不同参数列表的函数，从而实现函数重载。
函数重载在C语言中有许多应用场景，比如实现不同类型的输入参数、返回不同类型的值、实现相似但不完全相同的功能等。
通过函数重载，我们可以更加灵活地使用函数，提高代码的复用性和可维护性。
总之，C函数重载是一种非常有用的编程技术，它可以帮助我们更好地组织和管理代码，提高代码的可读性和灵活性。
在实际开发中，我们可以根据需要合理地使用函数重载，从而更好地实现我们的编程目标。
C++中运算符的重载应用
例如 ： ＋ 运算符完成两个 实数 、 用“ ” 两个复数 、 两个字符串的 法 的实 现 。
相关运算 。两个实 数 ａ １，＝ ，则 两个实 数相加 的结 果是 ： ＝０ｂ２
ａ ｂ １＋ ＝ ２ 两个复 数 ：＝ ０ ２，＝ ＋ ０ ， 两个 复数相 加 的 ＋＝０２ １； ａ １＋ ｉｂ ２ １ｉ则 结 果 是 ：＋ ＝ ２ １ｉ两 个 字 符 串 ：＝ ｖ ｕｌ，＝ ｔｄ ” 则 两 ａｂ １＋ ２ ； ａ “ｉ ａ ｂ “ｓ ｉ ， ｓ ” ｕｏ
（ ａｇａｇＰ ｌｔｃｎｃ ｎｇ Ｈｕｎ ｇｎ ４ ８０ ） Ｈｕｎ ｇｎ ｏｙｅｈ ｉＣｏｅｅ ａｇａｇ ３０ ２
Ａｂ ｔｕ ｔ Ｏｎ ｔ ｅ Ｃ ＋ ＋，ｏ ｅ ａｏ ｖ ｒ ａ ｉ ｇｉ ａ ａｙ ｅ ｏ ｅ ｐ ａ ｎ ｔ ｅ ｃ ｎ ｅ ｔ ｆ ｐ ｒ ｔ ｒ ｖ ｒ ａ ｉ ｇ ｓｎ ｘ ｍ— ｓ ｒｃ ｈ ｐ ｒ ｔｒｏ ｅ ｌ ｄ ｎ ｎ ｌｚ ｄ ｔ ｘ ｌｉ ｏ ｃ ｐ ｅ ａｏ ｅ ｌ ｄ ｎ ，ｕ ｉ ｇ ｅ ａ ｏ ｓ ｈ ｏｏ ｏ ｏ
中图分 类 号 ＴＰ３ ２ １ 文 献 标 识 码 Ｂ 文 章 编号 １ １ ２ — ５ ４ ００ ０ ５ ７
Ａｐ ｌ ａ ｉｎ ｏ ｅ ａ ｏ ｅ ｌａ ｉｇ ｉ ＋ ｐｉ ｔ ｆ ｃ ｏ Ｏｐ ｒ ｔ ｒ Ｏｖ ｒ ｄ ｎ Ｃ＋ ｏ ｎ
Ｚ ａｇ Ｊｅ ｈｎ ｉ
Ｋ ｙ ｒｓ ｐ ｒｔｒ Ｆ ｎ ｔ ｎｏ ｅｌａ ｉｇ Ａｐ ｌ ａｉｎ ｅ ｗｏ ｄ Ｐ ｅａｏ ｕ ｃｉ ｖ ｒ ｄｎ ｏ ｏ ｐｉ ｔ ｓ ｃ ｏ
一
、
什 么是运算符的重载
（） ４ 重载运算含义必须清楚 ， 不能产生二义性 。运算符的重
运算符重载一般分两种形式 ， 即重载为类的 运算符重载是对 已有的运算符赋予多重含义 ，使同一个运 载实质是函数重载 。 成员 函数和重载为类的友元 函数 ，这两种形式都可访问类中的 算符作
C++的PPT第10章
Hale Waihona Puke 总结： 设有双目运算符 B，如果要重载 B 为类的成员函 数，使之能够实现表达式 oprd1 B oprd2，其 中 oprd1 为A 类对象，则 B 应被重载为 A 类的 成员函数，形参类型应该是 oprd2 所属的类型。 经重载后，表达式oprd1 B oprd2 相当于 oprd1.operator B(oprd2)，注意重载双目运 算符只需要一个参数。
单目运算符重载
单目运算符，如果重载为类的成员函数，为区 分前置和后置运算符，C++规定：
对于前置单目运算符，重载函数没有参数。 对于后置单目运算符，重载函数有一个整型参数， 这个整型参数没有其他用途，只是用于区分前置运 算与后置运算。
（附加例）：定义一个CInt类，类中只有一个数据成 员i，两个运算符“++”的重载函数，一个没有参数， 实现的是前置运算符重载，另一个有一个整型参数， 实现后置运算符重载。
class CInt {private: int i; public: CInt(int a=0); void Print(); CInt operator ++(); CInt operator ++(int); }; int main() { CInt a(5), b(5), c, d; c = a++; d = ++b; cout << "a: “<<a.Print(); cout << "b: “<<b.Print(); cout << "c: “<<c.Print(); cout << "d: “<<d.Print(); }
c++结构体重载运算符
c++结构体重载运算符C++结构体可以通过重载运算符来实现自定义的操作符行为。
重载运算符允许我们使用结构体对象与其他对象之间进行类似于内置数据类型的操作。
下面将介绍一些常用的运算符重载的方式以及其使用场景。
1. 算术运算符重载：- 重载+运算符：可以用于结构体对象之间的相加操作。
- 重载-运算符：可以用于结构体对象之间的相减操作。
- 重载*运算符：可以用于结构体对象与标量之间的乘法运算。
- 重载/运算符：可以用于结构体对象与标量之间的除法运算。
2. 关系运算符重载：- 重载==运算符：用于比较两个结构体对象是否相等。
- 重载!=运算符：用于比较两个结构体对象是否不相等。
- 重载<运算符：用于比较两个结构体对象的大小关系。
- 重载>运算符：用于比较两个结构体对象的大小关系。
- 重载<=运算符：用于比较两个结构体对象的大小关系。
- 重载>=运算符：用于比较两个结构体对象的大小关系。
3. 赋值运算符重载：- 重载=运算符：用于将一个结构体对象的值赋给另一个对象。
- 重载+=运算符：用于将一个结构体对象与另一个对象相加，并将结果赋给第一个对象。
- 重载-=运算符：用于将一个结构体对象与另一个对象相减，并将结果赋给第一个对象。
- 重载*=运算符：用于将一个结构体对象与标量相乘，并将结果赋给第一个对象。
- 重载/=运算符：用于将一个结构体对象与标量相除，并将结果赋给第一个对象。
4. 输入输出运算符重载：- 重载<<运算符：用于将结构体对象的数据输出到标准输出流。
- 重载>>运算符：用于从标准输入流中读取数据，并赋给结构体对象的成员变量。
运算符重载的基本语法如下：```返回类型 operator运算符(参数列表) {// 重载运算符的实现代码// 可以直接访问结构体对象的成员变量// 可以调用结构体对象的方法// 可以与其他对象进行运算// 返回运算结果}```在进行运算符重载时，需要注意以下几点：- 重载运算符必须是成员函数或友元函数。
实验七-运算符重载参考答案
实验七-运算符重载参考答案实验七多态性—函数与运算符重载7.1 实验目的1．理解掌握成员函数方式运算符重载；2．理解掌握友元函数方式运算符重载；3．理解掌握++、--运算符的重载。
7.2 实验内容7.2.1程序阅读1．理解下面的程序，并运行查看结果，回答程序后面的问题。
#include <iostream>using namespace std;class CComplex{public:CComplex(){real = 0;imag = 0;}CComplex(int x,int y){real = x;imag = y;}int real;int imag;CComplex operator + (CComplex obj1)//---------------------------------------------①{CComplex obj2(real - obj1.real, imag - obj1.imag);return obj2;}};int main(){CComplex obj1(100,30);CComplex obj2(20, 30);CComplex obj;obj = obj1+obj2; //------------------------------------------------------------------②cout << obj.real <<endl;cout << obj.imag << endl;return 0;}问题一：①处的运算符重载，为什么该函数的返回值要设计成CComplex类型？答：因为在函数中return obj2,obj2是CComplex 类型，所以函数返回值要与return返回的类型相同，即设计成CComplex类型。
问题二：②处的运算符重载函数调用就相当于“obj=operator+(obj1,obj2);”，但是为什么CComplex类中的运算符重载函数只设计了一个参数？答：因为成员函数经编译后会产生this指针，this指针会指向调用该函数的obj1对象，该obj1对象就是就相当于函数的第一个参数。
简述运算符重载的规则。
简述运算符重载的规则。
运算符重载是指可以为自定义的类类型或枚举类型定义新的含义和功能。
在
C++中，运算符重载遵循以下一般规则：
1. 运算符重载必须至少有一个操作数是用户自定义的类类型或枚举类型的对象，否则将无法重载。
2. 运算符重载可以作为成员函数或非成员函数来实现。
3. 对于成员函数的运算符重载，操作数的数量为运算符的操作数减去1。
例如，重载双目运算符时（如+、-、*等），成员函数需要接受一个参数，用于表示另一个操作数。
4. 对于非成员函数的运算符重载，所有操作数都作为参数传递给函数。
可以通过将重载运算符函数声明为友元函数来访问类的私有成员。
5. 对于重载一元运算符（如++、），如果是成员函数，则返回一个修改后的对象；如果是非成员函数，则返回一个新的对象。
6. 对于重载二元运算符（如+、-、*等），如果是成员函数，则一个对象被修改，另一个对象不变；如果是非成员函数，则返回一个新的对象。
7. 运算符重载不能改变原有运算符的优先顺序和结合性。
8. 运算符重载遵循函数重载的规则，即可以根据参数类型和参数数量进行重载，实现不同的功能。
需要注意的是，运算符重载应该遵循语义上的合理性并不滥用。
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++实验报告之静态成员、运算符重载
题目1：定义一个复数类，通过重载运算符：*，/，直接实现二个复数之间的乘除运算。
编写一个完整的程序，测试重载运算符的正确性。
要求乘法“*”用友元函数实现重载，除法“/”用成员函数实现重载。
源程序1/*******************第1题*******************//******************单森汉*****************//******************2012-5-1*****************/#include<iostream>using std::cout;using std::endl;class Complex{float Real, Image;public:Complex(float r=0,float i=0) { Real=r;Image=i;}void Show(){cout <<"Real="<<Real<<'\t'<<"Image="<<Image<<'\n';}friend Complex operator *(Complex &, Complex &);Complex operator /(Complex &); //重载运算符+Complex operator +( Complex &);friend Complex operator -(Complex &, Complex &);};Complex operator *( Complex &c1,Complex &c2){Complex t;t.Real=c1.Real * c2.Real - c1.Image * c2.Image;t.Image = c1.Image*c2.Real +c1.Real* c2.Image;return t;}Complex Complex::operator /(Complex &c){Complex t;t.Real =(Real *c.Real+ Image * c.Image)/(c.Real*c.Real+ c.Image * c.Image);t.Image = (Image *c.Real - Real * c.Image)/(c.Real*c.Real+ c.Image * c.Image);return t;}Complex Complex::operator + ( Complex &c){Complex t;t.Real = Real + c.Real;t.Image = Image + c.Image;return t;}Complex operator -(Complex &c1, Complex &c2){Complex t;t.Real=c1.Real-c2.Real;t.Image=c1.Image-c2.Image;return t;}void main(){Complex c1(1,2),c2(3,4),c3;c3=c1*c2;cout<<"两个复数的乘法c3=c1*c2:";c3.Show();c3=c1/c2;cout<<"两个复数的除法c3=c1/c2:";c3.Show();Complex c4(1,2),c5(3,4),c6,c7(1,2),c8(3,0),c9; c6=c4+c5;cout<<"两个复数的加法c6=c4+c5:";c6.Show();c6=c4-c5;cout<<"两个复数的减法c6=c4-c5:";c6.Show();c9=c7+c8;cout<<"一个复数与一个实数的加法c9=c7+c8:"; c9.Show();c9=c7-c8;cout<<"一个复数与一个实数的减法c9=c7-c8:"; c9.Show();}运行结果截图题目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、 重载可能让程序的可读性下降，在使用时应模仿运算符的 习惯用法 。
c++运算符重载复数加减乘除
c++运算符重载复数加减乘除C++中的复数是由实部和虚部组成的数字，可以使用运算符重载来实现复数的加减乘除操作。
对于加法和减法，我们只需将实部和虚部分别相加或相减即可。
对于乘法，我们需要使用以下公式：(a+bi)×(c+di) = (ac-bd) + (ad+bc)i其中，a、b、c、d分别为复数的实部和虚部。
对于除法，我们需要使用以下公式：(a+bi) / (c+di) = ((ac+bd)/(c+d)) + ((bc-ad)/(c+d))i 实现时，我们需要在类中重载相应的运算符。
以下是一个示例程序：```#include <iostream>using namespace std;class Complex {private:float real, imag;public:Complex(float r = 0, float i = 0) : real(r), imag(i) {} Complex operator+(const Complex &c) {return Complex(real + c.real, imag + c.imag);}Complex operator-(const Complex &c) {return Complex(real - c.real, imag - c.imag);}Complex operator*(const Complex &c) {float r = real * c.real - imag * c.imag;float i = real * c.imag + imag * c.real;return Complex(r, i);}Complex operator/(const Complex &c) {float r = (real*c.real + imag*c.imag) / (c.real*c.real + c.imag*c.imag);float i = (imag*c.real - real*c.imag) / (c.real*c.real + c.imag*c.imag);return Complex(r, i);}void show() {cout << '(' << real << ' + ' << imag << 'i)' << endl;}};int main() {Complex c1(2, 3), c2(4, 5);Complex c3 = c1 + c2;c3.show(); // (6 + 8i)c3 = c1 - c2;c3.show(); // (-2 - 2i)c3 = c1 * c2;c3.show(); // (-7 + 22i)c3 = c1 / c2;c3.show(); // (0.560976 + 0.0243902i)return 0;}```运行结果：```(6 + 8i)(-2 - 2i)(-7 + 22i)(0.560976 + 0.0243902i)```以上是一个简单的复数运算符重载示例，可以根据需要进行扩展和优化。
C++程序设计04737 第4章 运算符重载
~myComplex(){ }
myComplex addCom(myComplex c1);//成员函数，调用对象与参数对象c1相加
void outCom();
//成员函数
void outCom(string s); //成员函数
void changeReal(double r);//成员函数
friend myComplex operator+(const myComplex &c1,const myComplex &c2); //c1+c2
4.1 运算符重载的概念
例4-2 重载为友元函数
#include <iostream>
using namespace std;
class myComplex
{private: double real,imag;
public:
myComplex();
myComplex(double r,double i);
class myComplex
//复数类
{
private: double real,imag;
public: myComplex();
//构造函数
myComplex(double r,double i);
//构造函数
void outCom();
//成员函数
myComplex operator-(const myComplex &c);//成员函数
4.1 运算符重载的概念
三、重载运算符为友元函数
例4-1 重载为成员函数的限制
1. #include <iostream>
2. using namespace std;
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类中声明它为友元函数。
c++运算符重载加法和减法
c++运算符重载加法和减法在C++中，运算符重载允许我们重新定义现有的运算符，以便在用户自定义的数据类型上执行操作。
对于加法和减法运算符，我们可以通过重载来定义它们在自定义类上的行为。
首先，让我们来看一下如何重载加法运算符。
假设我们有一个名为`MyClass`的自定义类，我们希望能够使用`+`运算符来执行自定义的加法操作。
我们可以这样做：cpp.class MyClass {。
public:int value;MyClass(int v) : value(v) {}。
MyClass operator+(const MyClass& other) {。
MyClass result(0);result.value = this->value + other.value;return result;}。
};在这个例子中，我们重载了`+`运算符，使得当我们对两个`MyClass`对象进行相加时，会调用我们定义的`operator+`函数。
这个函数返回一个新的`MyClass`对象，其值为两个操作数的和。
接下来，让我们看一下如何重载减法运算符。
同样假设我们有一个名为`MyClass`的自定义类，我们希望能够使用`-`运算符来执行自定义的减法操作。
我们可以这样做：cpp.class MyClass {。
public:int value;MyClass(int v) : value(v) {}。
MyClass operator-(const MyClass& other) {。
MyClass result(0);result.value = this->value other.value;return result;}。
};在这个例子中，我们重载了`-`运算符，使得当我们对两个`MyClass`对象进行相减时，会调用我们定义的`operator-`函数。
这个函数返回一个新的`MyClass`对象，其值为两个操作数的差。
c语言函数重载
c语言函数重载
c语言函数重载指的是同一个函数可以根据传入参数的不同而有不同的行为。
它通过编译器在编译时，根据参数的类型、个数及顺序来决定调用哪一个函数。
它可以使得同一个函数名称下可以有多个函数实现相同的功能，但是它们的参数列表不同。
c语言函数重载是c语言中实现函数多态性的一种方式，它能够帮助我们实现函数调用的简化，减少代码量，增强代码可读性和可维护性，提高程序的可维护性。
一般来说，c语言函数重载的实现方法有两种，一种是使用预处理器技术，另一种是使用宏技术。
前者使用预处理器技术将多个函数名称重新定义为一个函数名称，然后在函数体内部根据不同的参数类型来实现不同的操作。
而后者则是通过定义宏，然后通过宏中的if/else语句，根据参数的不同来调用不同的函数体。
预处理器技术和宏技术都可以实现函数重载，但是它们的机制不同，因此它们的实现方式也不同。
如果使用预处理器技术，只要将多个函数名称重新定义为一个函数名称，然后在函数体内部根据不同的参数类型来实现不同的操作就可以了。
而如果使用宏技术，则需要先定义一个
宏，然后在宏中定义一个if/else语句，根据参数的不同来调用不同的函数体。
此外，c语言函数重载还可以帮助我们实现函数的重命名，例如将一个函数名称重新定义为另一个函数名称，这样就可以把原来的函数名称彻底抹去，从而避免函数调用出现调用错误的情况，从而更好地保证代码的可维护性。
总而言之，c语言函数重载是c语言中实现函数多态性的一种方式，能够帮助我们实现函数调用的简化，减少代码量，增强代码可读性和可维护性，提高程序的可维护性，并且还可以实现函数的重命名，从而更好地保证代码的可维护性。
c++运算符重载及其返回值引用
c++运算符重载及其返回值引⽤运算符重载为成员函数重载为类成员的运算符函数定义形式1. 函数类型 operator 运算符（形参）2. {3. ......4. }5. 参数个数=原操作数个数-1 （后置++、--除外）双⽬运算符重载规则例：复数类加减法运算重载为成员函数1. #include <iostream>2. using namespace std;3. class Complex {4. public:5. Complex(double r = 0.0, double i = 0.0) : real(r), imag(i) { }6. //运算符+重载成员函数7. Complex operator + (const Complex &c2) const;8. //运算符-重载成员函数9. Complex operator - (const Complex &c2) const;10. void display() const; //输出复数11. private:12. double real; //复数实部13. double imag; //复数虚部14. };15. 例复数类加减法运算重载为成员函数16. Complex Complex::operator+(const Complex &c2) const{17. //创建⼀个临时⽆名对象作为返回值18. return Complex(real+c2.real, imag+c2.imag);19. }20.21. Complex Complex::operator-(const Complex &c2) const{22. //创建⼀个临时⽆名对象作为返回值23. return Complex(real-c2.real, imag-c2.imag);24. }25.26. void Complex::display() const {27. cout<<"("<<real<<", "<<imag<<")"<<endl;28. }29. 例：复数类加减法运算重载为成员函数30. int main() {31. Complex c1(5, 4), c2(2, 10), c3;32. cout << "c1 = "; c1.display();33. cout << "c2 = "; c2.display();34. c3 = c1 - c2; //使⽤重载运算符完成复数减法35. cout << "c3 = c1 - c2 = "; c3.display();36. c3 = c1 + c2; //使⽤重载运算符完成复数加法37. cout << "c3 = c1 + c2 = "; c3.display();38. return 0;39. }运算符重载为⾮成员函数有些运算符不能重载为成员函数，例如⼆元运算符的左操作数不是对象，或者是不能由我们重载运算符的对象运算符重载为⾮成员函数的规则运算符重载为⾮成员函数的规则表达式oprd1 B oprd2等同于operator B(oprd1,oprd2 )表达式 B oprd等同于operator B(oprd )表达式 oprd B等同于operator B(oprd,0 )例重载Complex的加减法和“<<”运算符为⾮成员函数• 将+、-（双⽬）重载为⾮成员函数，并将其声明为复数类的友元，两个操作数都是复数类的常引⽤。