C++运算符的重载

最新推荐文章于 2024-12-11 20:26:24 发布
最新推荐文章于 2024-12-11 20:26:24 发布
阅读量488 收藏
点赞数
文章标签： 运算符 重载 c++

　  C++中运行时的多态性主要是通过虚函数来实现的，而编译时的多态性是由函数重载和运算符重载来实现的。运算符重载的基础就是运算符重载函数。

　　1.运算符重载是对已有的运算符赋予多重含义，使同一个运算符作用域不同类型的数据导致不同行为的发生。比如

复制代码 
1 int i;
2 int i1=10,i2=10;
3 i=i1+i2;
4 std::cout<<"i1+i2="<<i<<std::endl;
5 
6 double d;
7 double d1=20,d2=20;
8 d=d1+d2;
9 std::cout<<"d1+d2="<<d<<std::endl;

复制代码

在这个程序里"+"既完成两个整形数的加法运算，又完成了双精度型的加法运算。为什么同一个运算符"+"可以用于完成不同类型的数据的加法运算？这是因为C++针对预定义基本数据类型已经对"+"运算符做了适当的重载。在编译程序编译不同类型数据的加法表达式时，会自动调用相应类型的加法运算符重载函数。但是C++中所提供的预定义的基本数据类型毕竟是有限的，在解决一些实际的问题时，往往需要用户自定义数据类型。比如高中数学里所提到的复数：

复制代码 
 1 class Complex //复数类
 2 {
 3 public:
 4 double real;//实数
 5 double imag;//虚数
 6         Complex(double real=0,double imag=0)
 7         {
 8 this->real=real;
 9 this->imag=imag;
10         }
11 }
复制代码

假如我们建立两个复数，并用"+"运算符让它们直接相加：

1 Complex com1(10,10),com2(20,20),sum;
2 sum=com1+com2;

那么会提示没有与这些操作数匹配的 "+" 运算符的错误。这是因为Complex类类型不是预定义类型，系统没用对该类型的数据进行加法运算符函数的重载。C++就为运算符重载提供了一种方法，即运算符重载函数。其函数名字规定为operator后紧跟重载运算符。比如：operator+(),operator*()等。现在我们给上述程序声明一个加法运算符的重载函数用于完成复数的加法运算：

复制代码 
 1 #include "stdafx.h"
 2 #include <iostream>
 3 
 4 class Complex //复数类
 5 {
 6 public:
 7 double real;//实数
 8 double imag;//虚数
 9         Complex(double real=0,double imag=0)
10         {
11 this->real=real;
12 this->imag=imag;
13         }
14 };
15 
16 Complex operator+(Complex com1,Complex com2)//运算符重载函数
17 {
18 return Complex(com1.real+com2.real,com1.imag+com2.imag);
19 }
20 
21 int main()
22 {
23     Complex com1(10,10),com2(20,20),sum;
24     sum=com1+com2;//或sum=operator+(com1,com2)
25 
26     std::cout<<"sum的实数部分为"<<sum.real<<std::endl;
27     std::cout<<"sum的虚数部分为"<<sum.imag<<"i"<<std::endl;
28 
29 return0;
30 }
复制代码

结果：

在上述示例代码中，调用运算符重载函数时，也可以以operator+(com1,com2)的形式来调用，实际上com1+com2在程序解释时也是转化成前者一样的形式。但是直接用com1+com2的形式更加符合人的书写习惯。

　　2.上述示例中的运算符重载函数是不属于任何的类，是全局的函数。因为在Complex类(复数类)中的数据成员是公有的性质，所以运算符重载函数可以访问。但如果定义为私有的呢，那该怎么办。其实，在实际的运算符重载函数声明当中，要不定义其为要操作类的成员函数或类的友元函数。

　　(1)运算符重载函数作为类的友元函数的形式：

　　class 类名

　　{

　　　　friend 返回类型 operator运算符(形参表);

　　}

　　类外定义格式：

　　返回类型 operator运算符(参数表)

　　{

　　　　函数体

　　}

友元函数重载双目运算符(有两个操作数，通常在运算符的左右两则)，参数表中的个数为两个。若是重载单目运算符(只有一个操作数)，则参数表中只有一参数。

i.友元函数重载双目运算符(+):

复制代码 
 1 #include "stdafx.h"
 2 #include <iostream>
 3 
 4 class Complex //复数类
 5 {
 6 private://私有
 7 double real;//实数
 8 double imag;//虚数
 9 public:
10         Complex(double real=0,double imag=0)
11         {
12 this->real=real;
13 this->imag=imag;
14         }
15         friend Complex operator+(Complex com1,Complex com2);//友元函数重载双目运算符+
16 void showSum();
17 };
18 
19 
20 Complex operator+(Complex com1,Complex com2)//友元运算符重载函数
21 {
22 return Complex(com1.real+com2.real,com1.imag+com2.imag);
23 }
24 
25 void Complex::showSum()
26 {
27     std::cout<<real;
28 if(imag>0)
29         std::cout<<"+";
30 if(imag!=0)
31         std::cout<<imag<<"i"<<std::endl;
32 }
33 
34 int main()
35 {
36     Complex com1(10,10),com2(20,-20),sum;
37     sum=com1+com2;//或sum=operator+(com1,com2)
38     sum.showSum();//输出复数相加结果
39 
40 return0;
41 }
复制代码

结果：

ii.友元函数重载单目运算符(++):

复制代码 
 1 #include "stdafx.h"
 2 #include <iostream>
 3 
 4 class Point//坐标类
 5 {
 6 private:
 7 int x;
 8 int y;
 9 public:
10     Point(int x,int y)
11     {
12 this->x=x;
13 this->y=y;
14     }
15     friend voidoperator++(Point& point);//友元函数重载单目运算符++
16 void showPoint();
17 };
18 
19 voidoperator++(Point& point)//友元运算符重载函数
20 {
21 ++point.x;
22 ++point.y;
23 }
24 
25 void Point::showPoint()
26 {
27     std::cout<<"("<<x<<","<<y<<")"<<std::endl;
28 }
29 
30 int main()
31 {
32     Point point(10,10);
33 ++point;//或operator++(point)
34     point.showPoint();//输出坐标值
35     
36 return0;
37 }
复制代码

结果：

运算符重载函数可以返回任何类型，甚至是void，但通常返回类型都与它所操作的类类型一样，这样可以使运算符使用在复杂的表达式中。比如把上述双目运算符重载函数示例代码中main()主函数里的com1+com2改为com1+com2+com2，那么结果又会不一样了。像赋值运算符=、下标运算符[]、函数调用运算符()等是不能被定义为友元运算符重载函数。同一个运算符可以定义多个运算符重载函数来进行不同的操作。

　　(2)运算符重载函数作为类的成员函数的形式：

　　class 类名

　　{

　　　　返回类型 operator 运算符(形参表);

　　}

　　　类外定义格式：

　　返回类型 类名:: operator 运算符(形参表)

　　{

　　　　函数体;

　　}

对于成员函数重载运算符而言，双目运算符的参数表中仅有一个参数，而单目则无参数。同样的是重载，为什么和友元函数在参数的个数上会有所区别的。原因在于友元函数，没有this指针。

i.成员函数重载双目运算符(+):

复制代码 
 1 #include "stdafx.h"
 2 #include <iostream>
 3 
 4 class Complex //复数类
 5 {
 6 private://私有
 7 double real;//实数
 8 double imag;//虚数
 9 public:
10         Complex(double real=0,double imag=0)
11         {
12 this->real=real;
13 this->imag=imag;
14         }
15         Complex operator+(Complex com1);//成员函数重载双目运算符+
16 void showSum();
17 };
18 
19 
20 Complex Complex::operator+(Complex com1)
21 {
22 return Complex(real+com1.real,imag+com1.imag);
23 }
24 
25 void Complex::showSum()
26 {
27     std::cout<<real;
28 if(imag>0)
29         std::cout<<"+";
30 if(imag!=0)
31         std::cout<<imag<<"i"<<std::endl;
32 }
33 
34 
35 int main()
36 {
37     Complex com1(10,10),com2(20,-20),sum;
38     sum=com1+com2;//或sum=com1.operator+(com2)
39     sum.showSum();//输出复数相加结果
40 return0;
41 }
复制代码

对于双目运算符而言，运算符重载函数的形参中仅为一个参数，它作为运算符的右操作数(如com2对象)，而当前对象作为左操作数(如：上述中的com1对象)，它是通过this指针隐含传递给成员运算符重载函数的。

ii.成员函数重载单目运算符(++):

复制代码 
 1 #include "stdafx.h"
 2 #include <iostream>
 3 
 4 
 5 class Point//坐标类
 6 {
 7 private:
 8 int x;
 9 int y;
10 public:
11     Point(int x,int y)
12     {
13 this->x=x;
14 this->y=y;
15     }
16 voidoperator++();//成员函数重载双目运算符++
17 void showPoint();
18 };
19 
20 
21 void Point::operator++()
22 {
23 ++x;
24 ++y;
25 }
26 
27 
28 void Point::showPoint()
29 {
30     std::cout<<"("<<x<<","<<y<<")"<<std::endl;
31 }
32 
33 int main()
34 {
35     Point point(10,10);
36 ++point;//或point.operator++()
37     point.showPoint();//输出坐标值
38     
39 return0;
40 }
复制代码

对于单目运算符而言，当前对象作为运算符的操作数。

　　在运算符重载运用时应该注意以下几个问题：(1)C++中只能对已有的C++运算符进行重载，不允许用户自己定义新的运算符;(2)C++中绝大部分的运算符可重载，除了成员访问运算符.，成员指针访问运算符.*，作用域运算符::，长度运算符sizeof以及条件运算符?:;(3)重载后不能改变运算符的操作对象(操作数)的个数。如："+"是实现两个操作数的运算符，重载后仍然为双目运算符;(4)重载不能改变运算符原有的优先级;(5)重载不能改变运算符原有结合的特性。比如：z=x/y*a，执行时是先做左结合的运算x/y，重载后也是如此，不会变成先做右结合y*a;(6)运算符重载不能全部是C++中预定义的基本数据，这样做的目的是为了防止用户修改用于基本类型数据的运算符性质;(7)从上述的示例中可以看到双目运算符可以被重载为友元函数也可以重载为成员函数，但有一种情况，只能使用友元函数，是什么情况呢？我举个例子：　

复制代码 
 1 class Complex //复数类
 2 {
 3 private://私有
 4 double real;//实数
 5 double imag;//虚数
 6 public:
 7         Complex(double real=0,double imag=0)
 8         {
 9 this->real=real;
10 this->imag=imag;
11         }
12         Complex operator+(int x);
13 };
14 
15 Complex Complex::operator+(int x)
16 {
17 return Complex(real+x,imag);
18 }
19 
20 int main()
21 {
22     Complex com1(5,10),total;
23     total=com1+5;
24 
25 return0;
26 }
复制代码

如果我们把上述main()主函数实现部分里的total=com1+5改为total=5+com1;那么程序就会报错(没有与这些操作数匹配的 "+" 运算符)，因为左操作数5不是该复数类的对象，不能调用相应的成员函数Complex operator+(int x)，所以编译错误。但如果我们定义一下两个友元函数就能解决上述的问题：

　　friend Complex operator+(Complex com1,int x);

　　friend Complex operator+(int x,Complex com1);

　　3.最后还是一样，我将用一个示例来总结一下今天所讲的内容(开发工具：vs2010):　

复制代码 
  1 #include "stdafx.h"
  2 #include <iostream>
  3 
  4 class Complex //复数类
  5 {
  6 private://私有
  7 double real;//实数
  8 double imag;//虚数
  9 public:
 10         Complex(double real=0,double imag=0)
 11         {
 12 this->real=real;
 13 this->imag=imag;
 14         }
 15         Complex operator+(Complex com1);//成员函数重载双目运算符+
 16 //或friend Complex operator+(Complex com1,Complex com2);//友元函数重载双目运算符+
 17         friend Complex operator+(Complex com1,int x);//友元函数重载双目运算符+
 18 //或Complex operator+(int x);
 19         friend Complex operator+(int x,Complex com1);//友元函数重载双目运算符+
 20 void showSum();
 21 };
 22 
 23 
 24 Complex Complex::operator+(Complex com1)
 25 {
 26 return Complex(real+com1.real,imag+com1.imag);
 27 }
 28 
 29 Complex operator+(Complex com1,int x)//左操作数类型为复数，右操作数的类型为整数
 30 {
 31 return Complex(com1.real+x,com1.imag);
 32 }
 33 
 34 Complex operator+(int x,Complex com1)//左操作数类型为整数，右操作数的类型为复数
 35 {
 36 return Complex(x+com1.real,com1.imag);
 37 }
 38 
 39 void Complex::showSum()
 40 {
 41     std::cout<<real;
 42 if(imag>0)
 43         std::cout<<"+";
 44 if(imag!=0)
 45         std::cout<<imag<<"i"<<std::endl;
 46 }
 47 
 48 class Point//坐标类
 49 {
 50 private:
 51 int x;
 52 int y;
 53 public:
 54     Point(int x,int y)
 55     {
 56 this->x=x;
 57 this->y=y;
 58     }
 59     friend voidoperator++(Point& point);//友元函数重载单目运算符++
 60     Point operator++();//成员函数重载双目运算符++
 61 void showPoint();
 62 };
 63 
 64 voidoperator++(Point& point)//友元运算符重载函数
 65 {
 66 ++point.x;
 67 ++point.y;
 68 }
 69 
 70 Point Point::operator++()
 71 {
 72 ++x;
 73 ++y;
 74 return*this;//返回当前对象
 75 }
 76 
 77 
 78 void Point::showPoint()
 79 {
 80     std::cout<<"("<<x<<","<<y<<")"<<std::endl;
 81 }
 82 
 83 int main()
 84 {
 85 //两个复数相加
 86     std::cout<<"两个复数相加:"<<std::endl;
 87 
 88     Complex com1(10,10),com2(20,-20),sum;
 89     sum=com1+com2;//或sum=com1.operator+(com2)
 90     std::cout<<"(10+10i)+(20-20i)=";
 91     sum.showSum();//输出复数相加结果
 92 
 93 //三个复数相加
 94     std::cout<<"三个复数相加:"<<std::endl;
 95 
 96     sum=com1+com2+com2;
 97     std::cout<<"(10+10i)+(20-20i)+(20-20i)=";
 98     sum.showSum();
 99 
100 //整数和复数相加
101     std::cout<<"整数和复数相加:"<<std::endl;
102     
103     Complex com3(5,10),total;
104     total=com3+5;//或total=operator+(com1,5);
105     std::cout<<"(5+10i)+5=";
106     total.showSum();
107 
108     total=5+com3;//或total=operator+(5,com1);
109 //只能用友元函数来重载运算符
110     std::cout<<"5+(5+10i)=";
111     total.showSum();
112 
113 //单目运算符++重载
114     std::cout<<"单目运算符++重载:"<<std::endl;
115 
116 //注意：下述实现部分不能只用一个++point会造成二义性
117     Point point(10,10);
118 //调用友元函数
119 operator++(point);//或++point
120     std::cout<<"调用友元函数:++(10,10)=";
121     point.showPoint();//输出坐标值
122 
123 //调用成员函数
124     point=point.operator++();//或++point;
125     std::cout<<"调用成员函数:++(10,10)=";
126     point.showPoint();
127 
128 return0;
129 }
复制代码

结果：

冷冷七弦
关注
c++中 使用自定义类做map的key.方式四:特化模板std::less
鸟哥的博客
09-25 787
//使用自定义类做map的key.方式四:特化模板std::less #include <iostream> #include <map> using namespace std; class Tree{ public: int height; int diameter; Tree(int h,int d){ height=h; diameter=d; } }; template <> //fu
C++运算符重载
weixin_44923692的博客
11-13 2448
赋值运算是指已经存在了两个对象，把其中一个对象的成员变量的值赋给另一个对象的成员变量。对于+号运算符来说，类外运算符重载和运算符重载同时存在时，系统会不知道调用哪一个，所以要去掉类外运算符重载。为了解决这个问题，C++规定，在重载++或–时，允许写一个增加了int形参的版本，编译器处理后置表达式时，成员函数版本的重载运算符函数：形参个数比运算符的操作数个数少一个，其中一个操作数隐式传递了调用对象。如果运算符重载既可以是成员函数也可以是全局函数，应该优先考虑成员函数，这样更符合运算符重载的初衷。
C++之运算符重载(1)
weixin_30682415的博客
08-12 280
　　在前一节中曾提到过，C++中运行时的多态性主要是通过虚函数来实现的，而编译时的多态性是由函数重载和运算符重载来实现的。这一系列我将主要讲解C++中有关运算符重载方面的内容。在每一个系列讲解之前，都会有它的一些基础知识需要我们去理解。而运算符重载的基础就是运算符重载函数。所以今天主要讲的是运算符重载函数。 　　1.运算符重载是对已有的运算符赋予多重含义，使同一个运算符作用域不同类型的数据导致不...
C++ 如何使用结构体作为map的key
Jane_yuhui的专栏
10-27 3718
#include <iostream> #include <string> #include <map> using namespace std; struct StructTest { std::string str1; std::string str2; double diameter; double length; StructTest() : str1(""), str2(""), diameter(0.), length(0.) {} S..
C++类或结构作为map的key值
qq_23350817的博客
05-07 3395
只有重载<的类或者结构才能作为map的key值。string可以作为key值是因为string重载了<。如果不重载<会提示如下错误： error C2676: 二进制“<”: “const C”不定义该运算符或到预定义运算符可接收的类型的转换 #include <string> #include <map> using namespace std;...
C++运算符重载规则详解
09-03
C++运算符重载是语言特性之一，允许程序员为已存在的运算符赋予新的含义，以适应自定义数据类型的运算需求。然而，运算符重载并不是无限制的，它遵循一些特定的规则，以确保代码的清晰性和正确性。 首先，C++中大...
8、C++运算符重载
如是牛
12-11 1176
本章内容带领大家学习C++的运算符重载，了解C++运算符重载的应用场景和书写方式。
c++ map　结构体作为key关键词
zisuina_2的博客
05-08 4045
c++　 map　结构体作为key关键词 结构体的定义： 这里的结构体是三个值 int x; int y; int label; 当三个值作为ＫＥＹ值时，你需要重新定义它的对比操作operator，这样才能对map进行查找操作； //数据结构声明；并且对key的查找操作进行定义，这样才能进行find等操作 struct point { int x; int y; ...
【C++】自定义结构体作为map的key
二十三小时
11-18 8495
自定义结构体作为C/C++中的map，或是unordered_map的key值： /** * self defined struct as the key of map in c++ */ struct K { int n1, n2; K(int i, int j): n1(i), n2(j) {} // the operator < defines the operation
map中字符串与结构体作key效率比较
03-11
比较两者查找效率，得出结论是结构体比字符串组合快～～～
在STL的map或set容器中使用类作为key
01-02
在STL的map或set容器中，当使用类作为key时，需要的类结构
C++简单的复数四则运算源码（cpp）
07-14
C++简单的复数四则运算源码（cpp），代码比较容易看懂
C++-STL(11)-map-结构体指针作为key
aggie4628的专栏
02-07 1329
map中如果要存的是结构体指针怎么做？创建时：要重载 <函数，你得告诉Map如何排序。查找时：重载==，你得告诉MAP何时相等。删除时：delete外还要置空，因为是new的。 上代码： #include <map> #include <iostream> using namespace std; struct Key { int x, y; boo...
运算符的重载及调用方式
OPK625153475的专栏
08-01 2028
定义重载运算符函数：opereator@(),其中@表示运算符号 #include using namespace std; class Complex{ public: double real; double imag; Complex(double r=0,double i=01) { real=r; imag=i; } }; Complex ope
运算符的重载
m0_51918781的博客
07-21 400
运算符的重载
C++ map以自定义数据类型做键值
nk_wang的专栏
02-14 7943
前言 作者最近在项目开发中遇到一个问题，想采用自定义的结构体作为键值，但是无论怎样，就连编译都不能通过，针对这个问题，作者就开始寻求解决的办法.。终于这个问题得以解决，高兴之余，决定写个例子，供大家参考 1.map在STL中的定义 template, class A = allocator > 第一个参数 Key： map的关键字类型 第二个参数T：      map的值类型 第
java map的结构体_结构体作为map的key或放入set中，需要重载<运算符
weixin_32633271的博客
02-21 398
结构体作为map的key或放入set中，需要重载typedef struct tagRoadKey{int m_i32Type;int m_i32Scale;bool operator {if (m_i32Type != other.m_i32Type) // 类型按升序排序{return (m_i32Type < other.m_i32Type);}else // 如果类型相同，按比例尺升...
c＋＋运算符重载
最新发布
03-25
<think>好的，我现在要帮用户介绍C++的运算符重载。首先，我需要回忆一下运算符重载的基本概念。运算符重载允许用户自定义类型使用C++内置的运算符，比如+、-、*等，使得代码更直观和易读。例如，可以让两个对象直接相加，而不必调用特定的函数。 接下来，我应该考虑用户可能的背景。用户可能是刚开始学习C++，或者已经有一定基础但想深入了解运算符重载。因此，解释需要清晰，从基础开始，逐步深入。可能需要先说明什么是运算符重载，为什么需要它，然后讲解如何实现，包括语法和注意事项。 然后，运算符重载的语法是关键部分。需要详细说明如何定义运算符重载函数，包括成员函数和非成员函数（友元函数）的区别。例如，重载+运算符时，成员函数通常只需要一个参数，因为左操作数是对象本身，而非成员函数需要两个参数。同时，要提到一些运算符必须作为成员函数重载，比如赋值运算符=。 例子是帮助理解的重要部分。我应该举一个简单的例子，比如为自定义的Vector类重载+运算符，这样用户可以看到具体的实现方式。同时，需要区分成员函数和非成员函数的例子，说明它们的不同应用场景。 注意事项和常见问题也不能遗漏。比如不能重载的运算符（如.、::、sizeof等），以及重载时保持运算符的原有语义，避免滥用导致代码难以理解。此外，还需要提到运算符的返回类型和参数类型的选择，比如是否返回引用或值，参数的const修饰等。 用户可能还会有疑问，比如运算符重载的使用场景，或者何时应该使用成员函数而非友元函数。因此，在解释过程中需要涵盖这些方面，可能的话，给出一些最佳实践的建议。 最后，总结运算符重载的优点和需要注意的地方，帮助用户全面理解。确保语言通俗易懂，避免过于专业的术语，必要时进行类比，让用户更容易接受。</think>### C++运算符重载详解 #### 1. 什么是运算符重载？ 运算符重载（Operator Overloading）是C++中的一种特性，允许开发者**为自定义类型（如类或结构体）重新定义运算符的行为**。通过重载运算符，可以让对象像内置类型（如`int`、`double`）一样使用`+`、`-`、`*`、`==`等运算符，提升代码可读性和简洁性。 --- #### 2. 如何实现运算符重载？ 运算符重载通过**成员函数**或**全局函数**实现，语法形式为： $$ \text{返回类型 operator 运算符(参数列表)} $$ ##### 示例1：成员函数重载`+` ```cpp class Vector { public: int x, y; // 成员函数重载 + Vector operator+(const Vector& other) { return {x + other.x, y + other.y}; } }; // 使用 Vector v1{1, 2}, v2{3, 4}; Vector v3 = v1 + v2; // 等价于 v1.operator+(v2) ``` ##### 示例2：全局函数重载`<<`（输出流） ```cpp class Student { public: string name; int age; }; // 全局函数重载 << ostream& operator<<(ostream& os, const Student& s) { os << "Name: " << s.name << ", Age: " << s.age; return os; } // 使用 Student s{"Alice", 20}; cout << s; // 输出: Name: Alice, Age: 20 ``` --- #### 3. 常见运算符重载规则 | 运算符类型 | 可重载性 | 示例 | |------------------|----------------|----------------------| | 算术运算符 | `+`, `-`, `*` | `a + b` | | 关系运算符 | `==`, `>`, `<` | `a == b` | | 赋值运算符 | `=`, `+=` | `a = b` | | 下标运算符 | `[]` | `a[0]` | | 函数调用运算符 | `()` | `a(1, 2)` | | **不可重载运算符** | `.`、`::`、`?:`、`sizeof` | 无法重载 | --- #### 4. 关键注意事项 1. **参数限制**： - 至少一个操作数是用户自定义类型（不能全为内置类型）。 - 不能修改运算符的优先级或结合性。 2. **成员函数 vs 全局函数**： - 赋值运算符（`=`）、下标运算符（`[]`）、函数调用运算符（`()`）**必须**作为成员函数重载。 - 输入输出运算符（`>>`、`<<`）通常作为全局函数。 3. **保持语义一致性**： - 例如重载`+`时，不应修改操作数本身，而应返回新对象。 --- #### 5. 完整示例：复数类重载 ```cpp class Complex { private: double real, imag; public: Complex(double r = 0, double i = 0) : real(r), imag(i) {} // 成员函数重载 + Complex operator+(const Complex& other) { return Complex(real + other.real, imag + other.imag); } // 全局友元函数重载 << friend ostream& operator<<(ostream& os, const Complex& c); }; ostream& operator<<(ostream& os, const Complex& c) { os << c.real << " + " << c.imag << "i"; return os; } // 使用 Complex c1(2, 3), c2(4, 5); Complex c3 = c1 + c2; cout << c3; // 输出: 6 + 8i ``` --- #### 6. 应用场景 - 数学计算（向量、矩阵、复数） - 字符串操作（`str1 + str2`） - 容器类（自定义数组、链表） --- #### 7. 总结 **优点**：提升代码直观性，使自定义类型操作更自然。 **注意**：避免过度使用或违反直觉的重载（例如用`+`实现减法）。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值