【例6.4】用友元函数重载运算符实现两字符串加法

5
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） { 函数体 } 重载自减运算符“--”的格式与重载“++”运算符类似。

T1 operator@(T2 b){ ……};
}
其中，T1是运算符函数的返回类型，T2是参数的类型， 原则上T1、T2可以是任何数据类型，但事实上它 们常与X相同。
6.1.4 类运算符的重载
【例6-1】 有复数类Complex，利用运算符重载实现复数的加、减、 乘、除等复数运算。
//Eg6-1.cpp #include<iostream> using namespace std; class Complex { private: double r, i; public:
//...... };
Complex operator+(Complex a,Complex
b){……}
//定义
6.2 重载二元运算符
1、二元运算符的调用形式与解析 a@b 可解释成 a.operator@(b) 或解释成 operator@(a, b)
6.2.1 作为成员函数重载
class X{ ……
why?
使程序便于编写和阅读 使程序定义类型与语言内建类型更一致
how?
1.使用特殊的成员函数 2.使用自由函数，一般为友元函数
6.1.3 运算符重载的语法
运算符的计算结果是值，因此运算符函数是要返 回值的函数。其重载的语法形式如下：
返回类型 operator@(参数表)
//错误?
6.2.2 作为友元函数重载
2、重载二元运算符为类的友元函数时需要两个参数， 其形式Hale Waihona Puke 下：class X{ ……
friend T1 operator(T2 a,T3 b); }
T1 operator(T2 a,T3 b){ ……}

能用友元函数重载的运算符
友元函数重载的运算符是一种常见的C++编程技术，可以使类的成员函数以及非成员函数来实现操作符的重载。

友元函数重载运算符可以被用于各种类，例如字符串、向量、复数等等。

使用友元函数重载运算符，我们可以自定义运算符的行为，使它们适用于我们的数据类型。

例如，我们可以重载加法运算符'+'以进行字符串连接，重载乘法运算符'*'以进行矩阵乘法，或者重载一元运算符'-'以取相反数。

由于友元函数可以访问类的私有成员，因此可以让我们设计更加精细的运算符重载。

在使用友元函数重载运算符时，需要注意避免对运算符进行过度重载，以免对代码的可读性和可维护性造成影响。

总之，友元函数重载运算符是一个功能强大的C++编程技术，可以使代码更加灵活以及易于理解和维护。

- 1 -。

长方体积=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。用友元函数方法求长方体体积的程序如下：

15
7.2 重载++和－－的前缀和后缀方式
【例7.6】用成员ห้องสมุดไป่ตู้数，区分单目运算符的前缀和后缀
【例7.7】用友元函数，区分单目运算符的前缀和后缀
16
【例7.1】 在复数complex类中重载运算符+(P186)
void main( ) #include <iostream.h> {complex c1(1,2),c2(3,4),c3; class complex c1.operator+(c2) ; c3= c1+c2; { private: //隐式调用形式 //这里的+采用类中重载后的含义 int real, imag; //定义复数的实部和虚部 //显式调用形式 } public: complex(int x=0, int y=0) { real=x; imag=y; } complex operator+ (complex c) //定义+运算符重载函数 { complex t; 函数名 t.real=real+c.real; //这里的+采用系统预定义含义 t.imag=imag+c.imag; return t; } };
19
【例7.2】用成员函数重载运算符的完整的复数类（P191） complex complex::operator +(complex c2) //重载运算符+函数实现 { double r=c2.real+real; double i=c2.imag+imag; return complex(r,i); } complex complex::operator -(complex c2) //重载运算符-函数实现 { double r=real-c2.real; double i=imag-c2.imag; return complex(r,i); }

字符串和字符的加操作在计算机编程领域中，字符串和字符的加操作是常见的操作之一。

字符串是由多个字符组成的数据类型，而字符则是单个字符组成的数据类型。

在很多场景下，程序需要将多个字符串或字符进行拼接操作，以满足某些需求。

本篇文章将详细讨论字符串和字符的加操作。

首先，我们来看字符串的加操作。

字符串的加操作通常用于将多个字符串连接在一起，形成一个更长的字符串。

在大多数编程语言中，字符串的加操作可以使用加号（+）来实现。

例如，在Python语言中，我们可以使用以下代码实现字符串的加操作：```str1 = "Hello"str2 = "World"str3 = str1 + " " + str2print(str3)```在上面的代码中，我们定义了两个字符串变量str1和str2，并将它们拼接在一起，生成一个新的字符串str3。

在拼接过程中，我们使用了空格，以避免两个字符串之间没有间隔。

类似地，在Java语言中，我们也可以使用加号实现字符串的加操作。

例如：```String str1 = "Hello";String str2 = "World";String str3 = str1 + " " + str2;System.out.println(str3);```在上面的代码中，我们同样定义了两个字符串变量str1和str2，并将它们拼接在一起，生成一个新的字符串str3。

需要注意的是，字符串的加操作并不是所有编程语言都支持的。

例如，在C语言中，字符串的拼接操作需要使用strcpy（）和strcat （）等函数来实现。

接下来，让我们来看看字符的加操作。

字符的加操作通常用于将多个字符连接在一起，形成一个更长的字符串。

在大多数编程语言中，字符的加操作同样可以使用加号（+）来实现。

例如，在Python语言中，我们可以使用以下代码实现字符的加操作：```char1 = 'H'char2 = 'i'char3 = char1 + char2print(char3)```在上面的代码中，我们定义了两个字符变量char1和char2，并将它们拼接在一起，生成一个新的字符char3。

C++重载（主要介绍使⽤友元函数重载）重载限制多数C++运算符都可以⽤下⾯的⽅式重载。

重载的运算符不必是成员函数，但必须⾄少有⼀个操作数是⽤户⾃定义的类型。

下⾯详细介绍C++对⽤户定义的运算符重载的限制。

1 重载后的运算符必须⾄少有⼀个操作数是⽤户⾃定义的类型，这将防⽌⽤户为标准类型重载运算符。

因此，不能将减法运算符（-）重载为double值的和，⽽不是它们的差。

虽然这种限制将对创造性有所影响，但可以确保程序正常运⾏。

2 使⽤运算符时不能违反运算符原来的句法规则。

例如，不能将求模运算符（%）重载成使⽤⼀个操作数。

同样，不能修改运算符的优先级。

因此，如果将加号运算符重载成将两个类相加，则新的运算符与原来的加号具有相同的优先级。

3 不能创建新的运算符。

例如，不能定义operator**（）函数来表⽰求幂。

4 不能重载下⾯的运算符sizeof：sizeof运算符.：成员运算符.*：成员指针运算符:: ：作⽤域解析运算符？:：条件运算符typeid：⼀个RTTI运算符const_cast：强制类型转换运算符dynamic_cast：强制类型转换运算符reinterpret_cast：强制类型转换运算符static_cast：强制类型转换运算符然⽽，下表中的所有运算符都可以被重载5 下表中的⼤多数运算符都可以通过成员或⾮成员函数进⾏重载，但下⾯的运算符值能通过成员函数进⾏重载=：赋值运算符（）：函数调⽤运算符[]：下标运算符->：通过指针访问类成员的运算符可重载的运算符除了这些正式限制之外，还应在重载运算符时遵循⼀些限制。

例如，不要将*运算符重载成交换两个对象的数据成员。

友元C++控制对类对象私有部分的访问。

通常，公有类⽅法提供唯⼀的访问途径，这种限制太严格，以⾄于不适合特定的编程问题。

在这种情况下，C++提供了另外⼀种形式的访问权限：友元。

友元有3种：友元函数友元类友元成员函数通过让函数成为类的友元，可以赋予该函数与类的成员函数相同的访问权限。

C++运算符重载模板友元newdelete++=+=今天的重载是基于C++ 类模板的，如果需要⾮类模板的重载的朋友可以把类模板拿掉，同样可以参考，谢谢。

⼀、类模板中的友元重载本⼈喜好类声明与类成员实现分开写的代码风格，如若您喜欢将类成员函数的实现写在类声明中，那么可以跳过该部分。

请看下⾯这段代码：头⽂件：#pragma oncetemplate<typename T>class CLA{T m_value;public:CLA(const T&);friend CLA operator+(const CLA&, const CLA&);};template<typename T>CLA<T>::CLA(const T& a):m_value(a){ }template<typename T>CLA<T> operator+(const CLA<T>& lhs, const CLA<T>& rhs){return CLA<T>(lhs.m_value + rhs.m_value);}源⽂件：（已包含上述的头⽂件）int main(){CLA<int> a{ 0 }, b{ 1 }, c{ 2 };a + b;return0;}我们去执⾏上述代码的时候，编译器就会报错：⼀个⽆法解析的外部指令。

当然，将实现放⼊声明中是可以的，但是为了维护类的书写风格，我们还是希望有⼀种⽅法可以去维护这个风格。

那么我们可以将类中友元函数的声明写成如下形式：friend CLA operator+<T>(const CLA&, const CLA&);原因很简单，类模板具有抽象性，⽽刚刚那个友元函数就是普通的函数，不具有模板的抽象性。

即使参数为CLA<T> ... 还是⼀样，它代表的只不过是⼀个参数的类型，函数本⾝依旧是⼀个普通的函数。

友元函数和运算符重载友元⼀个常规的成员函数声明描述了三件在逻辑上相互不同的事情①该函数能访问类声明中的私⽤部分②该函数位于作⽤域之中③该函数必须经由⼀个对象去激活（有⼀个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）隐式转换为⼀个⽆名的临时对象。

c字符串相加的函数1.引言1.1 概述C字符串是一种由字符组成的数组，以空字符'\0'作为结束符。

在C 语言中，字符串是一种常见且重要的数据类型，被广泛应用于各个领域和场景中。

在日常编程中，经常需要对字符串进行操作和处理，其中一个常见的需求是将两个字符串进行相加。

例如，我们可能需要将两个人的姓和名字拼接在一起，或者将两段文本串联成一段完整的文本。

字符串相加的功能在实际开发中非常常见，存在广泛的应用场景。

为了满足这一需求，我们需要设计和实现一个函数，该函数能够将两个C字符串相加并返回结果。

这个函数可以接收两个输入字符串，并将它们连接在一起，形成一个新的字符串。

这个新字符串将包含原始字符串中的所有字符，并以'\0'作为结束符。

本文将介绍如何编写一个C字符串相加的函数，探讨其重要性以及如何改进和优化这个函数的实现。

我们将从C字符串的定义和特点开始，了解字符串相加的需求和应用场景，最后总结函数的重要性，并提出改进和优化的方向。

通过阅读本文，读者将能够理解和掌握C字符串相加的函数实现方法，为日后的编程工作提供帮助。

1.2 文章结构文章结构部分的内容可以包括以下内容：文章结构部分主要介绍了本篇长文的组织结构和章节安排，为读者提供了对整篇文章的整体概念和导向。

首先，文章将按照以下章节进行组织：1. 引言：介绍本篇文章的主题和目的。

包括概述、文章结构及目的。

2. 正文：详细阐述C字符串的定义和特点，并探讨字符串相加的需求和应用场景。

这一部分将逐步引导读者了解C字符串的相关概念及其在实际编程中的应用。

3. 结论：总结C字符串相加的函数的重要性，并提出改进和优化的方向。

这一部分将对正文部分进行总结，并针对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::只是指定了成员函数所属类名。

6.2.1 友元运算符重载
complex operator/(complex a,complex b) {
complex temp; double t; t=1/(b.real*b.real+b.imag*b.imag);
temp.real=(a.real*b.real+a.imag*b.imag)*t; temp.imag=(b.real**b.imag)*t; return temp; } void complex::print() {
@aa;
// 隐式调用
operator@(aa);
// 显式调用
6.2.1 友元运算符重载
说明：
（1）运算符重载函数operator@()可以返回任 何类型；
（2）可以不保持原有含义； （3）不能定义新的运算符； （4）编译器根据参数类型和个数决定调用哪
个重载函数；
（5）不能用友元重载的运算符是：＝,(),[],->; （6）单目运算符“-”可不改变操作数自身的
第6章 运算符重载
6.1 运算符重载概述
6.1.1 运算符重载函数的定义
运算符重载允许C/C++的运算符在用户定义类 型（通常指类）上拥有一个用户定义的意义。
当你定义一个类之后，系统是不会对你自己定 义的类进行算术运算等运算的，只有当你对相应 的运算府重载之后，你才可以对两个或者多个对 象进行运算。
//… 返回类型 operator运算符(形参表); //… } 在类外定义成员运算符函数的格式如下: 返回类型 X::operator运算符(形参表) {
函数体 }
6.2.2 成员运算符重载函数
2. 双目运算符重载 对双目运算符而言,成员运算符函数的

第6章 运算符重载 章
6.2.1 运算符重载的规则
不能重载对内部C++数据类型进行操作的运算符。 内部C++数据类型进行操作的运算符 (2) 不能重载对内部C++数据类型进行操作的运算符。 不能创建新的运算符。 (3) 不能创建新的运算符。 创建新 (4) 不能重载下面运算符： 不能重载下面运算符：
第6章 运算符重载 章
6.1.3 两种运算符重载形式的比较
用友元或成员函数重载运算符在功能上没有什么区别。 用友元或成员函数重载运算符在功能上没有什么区别。有 时将二元运算符重载为友元函数比重载为一个成员函数使用起 来更灵活。例如： 来更灵活。例如： c=34.5+c1; 该语句右边的表达式被解释为： 该语句右边的表达式被解释为：34.5.operator + (c1); 由于34.5是float型数据 不能进行“.”操作，编译时会出错。 是 型数据,不能进行 操作， 由于 型数据 不能进行“ 操作 编译时会出错。 解决这个问题的办法就是用用友元函数重载加法。这时， 解决这个问题的办法就是用用友元函数重载加法。这时，该语 句右边的表达式被解释为： 句右边的表达式被解释为： operator + (34.5，c1); ， 两个变元都被显式传给运算符函数。 两个变元都被显式传给运算符函数。
第6章 运算符重载 章
6.1 运算符重载的形式 6.2 运算符重载的规则 6.3 基本运算符重载 6.4 赋值运算符重载 6.5 特殊运算符重载 6.6 类类型转换运算符重载 6.7 应用实例
第6章 运算符重载 章
引例(问题 用户定义类型是否也可以使用运算符 引例 问题:用户定义类型是否也可以使用运算符 问题 用户定义类型是否也可以使用运算符?)

10
I/O运算符重载的使用 运算符重载的使用2-2 运算符重载的使用
ostream& operator<<(ostream &ostrm,Complex &clsCom){ ostrm<<‘(’<<clsCom.real<<“;”<<clsCom.imaginary <<‘)’<<endl; } istream& operator>>(istream &istrm, Complex &clsCom){ istrm>>clsCom.read>>clsCom.imaginary; } void main(){ Complex clsCom; cout<<“please input…”<<endl; cin>>clsCom; cout<<clsCom; }
class CString{ public: CString & operator = (const CString & s); CString & operator = (const char *s); //其他省略 }; CString& CString::operator =(const CString& str){ if (this!=&str){ delete[] m_str; m_size=strlen(str.m_str); m_str=new char[m_size+1]; strcpy(m_str,str.m_str); } return *this; }
14
‘+’运算符重载的使用 运算符重载的使用2-2 运算符重载的使用

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类中声明它为友元函数。

再如
Complex c1(5,6), c2(9,3); Complex c3； 自定义的复数类（c++有复数类）的对象不能直 接使用+ - * / << >>等运算，我们可以为它定义这 些运算，也就是重载这些运算,如果已经重载了， 就可以 c3 = c1+c2; cout << c3;
运算符+重载函数名








Complex Complex:: operator+(const Complex &operand2) const { 参数名，第2个操作数 Complex tmp; tmp.real = real + operand2.real; tmp.imaginary = imaginary+ operand2.imaginary; return tmp; }
独立自由的运算符函数

双目运算通常都写成中缀表达式 3+2 a>b a=b 一般可以写成 lhs op rhs （lhs 左手边运算数，rhs右手边运 算数，op 运算符）
在类外添加一个自由(独立)函数
Complex operator+ (const Complex &lhs, const Complex &rhs)
默认的赋值是浅赋值，如图
具有指针成员的对象正确的赋值结果是深赋 值，即指针所指的数值赋值
必须对赋值运算重载，即让它的赋值是这样的含义
如何进行运算符重载？


数据类型的运算能力显然是它的行为特征 给类型赋予某种运算能力，就是要为它定义具有 运算功能的函数：运算符重载函数，这种函数可 以是我们熟悉的成员函数，或者类之外的自由函 数，还可以是类的友元函数（例子） 运算符重载函数的格式是 返回类型 operator运算符（参数1，参数2） 其中运算符是要重载的运算符号，如+，<<等

两个数相加函数重载两个数相加：重载函数之美在编程中，函数是一种封装了特定功能的代码块，可以被重复调用，提高代码的复用性和可读性。

而函数重载则是指在同一个作用域中，通过改变函数的参数类型或参数个数来定义多个同名函数的过程。

下面我们将探讨函数重载的概念、用途以及如何正确使用函数重载。

一、函数重载的概念和用途函数重载是指在同一个作用域中，可以定义多个同名函数，但这些函数的参数类型或参数个数必须不同。

通过函数重载，我们可以根据不同的参数类型或参数个数来调用不同的函数，以满足不同的需求。

函数重载的主要用途有以下几个方面：1. 提高代码的可读性和可维护性：通过函数重载，我们可以使用相同的函数名来实现不同的功能，使代码更加简洁和易于理解。

2. 提供更多的灵活性：通过函数重载，我们可以根据不同的参数类型或参数个数来选择不同的函数实现，从而提供更多的灵活性和选择性。

3. 简化函数调用：通过函数重载，我们可以使用相同的函数名来调用不同的函数，而不需要记忆多个不同的函数名，简化了函数的调用过程。

二、函数重载的实现方法函数重载是通过函数的参数类型或参数个数来实现的。

当编译器在调用函数时遇到同名函数时，会根据参数类型或参数个数的不同来选择合适的函数。

下面我们以两个数相加的函数为例，介绍函数重载的实现方法。

1. 两个整数相加的函数重载```cppint add(int a, int b) {return a + b;}```在这个例子中，我们定义了一个两个整数相加的函数add，函数的参数类型为int。

当我们调用add函数时，编译器会根据传入的参数类型来选择合适的函数进行调用。

2. 两个浮点数相加的函数重载```cppfloat add(float a, float b) {return a + b;}```在这个例子中，我们定义了一个两个浮点数相加的函数add，函数的参数类型为float。

当我们调用add函数时，编译器会根据传入的参数类型来选择合适的函数进行调用。