C++(七)运算符重载-c七运算符重载.md
title: C++(七)运算符重载
date: 2021-04-21 20:35:17.371
updated: 2021-04-21 22:56:05.47
url: /?p=98
categories: C++
tags: C++
运算符重载(Operator Overloading)基本认识
对于重载,我们都会有一个认识,函数重载。顾名思义,函数重载会把原来的函数赋予新的含义,使得相同函数名能够拥有多种操作,其实也算是编译时的多态。
根据我们对函数重载的理解,其实也能大概摸清运算符重载准备干什么了。下面我们开始认识它吧。
实际上,我们已经在不知不觉中使用了运算符重载。例如,+
号可以对不同类型(int、float 等)的数据进行加法操作;<<
既是位移运算符,又可以配合 cout 向控制台输出数据。C++ 本身已经对这些运算符进行了重载。
C++ 也允许程序员自己重载运算符,这给我们带来了很大的便利。
下面的代码定义了一个复数类,通过运算符重载,可以用+号实现复数的加法运算:
1 |
|
运行结果:
6.7 + 9.5i
本例中义了一个复数类 complex,m_real 表示实部,m_imag 表示虚部,第 10 行声明了运算符重载,第 21 行进行了实现(定义)。认真观察这两行代码,可以发现运算符重载的形式与函数非常类似。
运算符重载其实就是定义一个函数,在函数体内实现想要的功能,当用到该运算符时,编译器会自动调用这个函数。也就是说,运算符重载是通过函数实现的,它本质上是函数重载。
运算符重载的格式为:
1 | 返回值类型 operator 运算符名称 (形参表列){ |
operator
是关键字,专门用于定义重载运算符的函数。我们可以将operator 运算符名称
这一部分看做函数名,对于上面的代码,函数名就是operator+
。
运算符重载函数除了函数名有特定的格式,其它地方和普通函数并没有区别。
上面的例子中,我们在 complex 类中重载了运算符+,该重载只对 complex 对象有效。当执行c3 = c1 + c2;
语句时,编译器检测到+
号左边(+
号具有左结合性,所以先检测左边)是一个 complex 对象,就会调用成员函数operator+()
,也就是转换为下面的形式:
1 | c3 = c1.operator+(c2); |
c1 是要调用函数的对象,c2 是函数的实参。
上面的运算符重载还可以有更加简练的定义形式:
1 | complex complex::operator+(const complex &A)const{ |
return 语句中的complex(this->m_real + A.m_real, this->m_imag + A.m_imag)
会创建一个临时对象,这个对象没有名称,是一个匿名对象。在创建临时对象过程中调用构造函数,return 语句将该临时对象作为函数返回值。
在全局范围内重载运算符
运算符重载函数不仅可以作为类的成员函数,还可以作为全局函数。更改上面的代码,在全局范围内重载+,实现复数的加法运算:
1 |
|
运算符重载函数不是 complex 类的成员函数,但是却用到了 complex 类的 private 成员变量,所以必须在 complex 类中将该函数声明为友元函数。
当执行c3 = c1 + c2;
语句时,编译器检测到+
号两边都是 complex 对象,就会转换为类似下面的函数调用:
1 | c3 = operator+(c1, c2); |
虽然运算符重载所实现的功能完全可以用函数替代,但运算符重载使得程序的书写更加人性化,易于阅读。运算符被重载后,原有的功能仍然保留,没有丧失或改变。通过运算符重载,扩大了C++已有运算符的功能,使之能用于对象。
运算符重载时要遵循的规则
- 并不是所有的运算符都可以重载。能重载的运算符包括:
1 | + - * / % ^ & | ~ ! = < > += -= *= /= %= ^= &= |= << >> <<= >>= == != <= >= && || ++ -- , ->* -> () [] new new[] delete delete[] |
上述运算符中,[]
是下标运算符,()
是函数调用运算符。自增自减运算符的前置和后置形式都可以重载。长度运算符sizeof
、条件运算符: ?
、成员选择符.
和域解析运算符::
不能被重载。
- 重载不能改变运算符的优先级和结合性。假设上一节的 complex 类中重载了+号和*号,并且 c1、c2、c3、c4 都是 complex 类的对象,那么下面的语句:
1 | c4 = c1 + c2 * c3; |
等价于:
1 | c4 = c1 + ( c2 * c3 ); |
乘法的优先级仍然高于加法,并且它们仍然是二元运算符。
- 重载不会改变运算符的用法,原有有几个操作数、操作数在左边还是在右边,这些都不会改变。例如
~
号右边只有一个操作数,+
号总是出现在两个操作数之间,重载后也必须如此。 - 运算符重载函数不能有默认的参数,否则就改变了运算符操作数的个数,这显然是错误的。
- 运算符重载函数既可以作为类的成员函数,也可以作为全局函数。
将运算符重载函数作为类的成员函数时,二元运算符的参数只有一个,一元运算符不需要参数。之所以少一个参数,是因为这个参数是隐含的。
例如,上节的 complex 类中重载了加法运算符:
1 | complex operator+(const complex & A) const; |
当执行:
1 | c3 = c1 + c2; |
会被转换为:
1 | c3 = c1.operator+(c2); |
通过 this 指针隐式的访问 c1 的成员变量。
将运算符重载函数作为全局函数时,二元操作符就需要两个参数,一元操作符需要一个参数,而且其中必须有一个参数是对象,好让编译器区分这是程序员自定义的运算符,防止程序员修改用于内置类型的运算符的性质。
例如,下面这样是不对的:
1 | int operator + (int a,int b){ |
+号原来是对两个数相加,现在企图通过重载使它的作用改为两个数相减, 如果允许这样重载的话,那么表达式4+3的结果是 7 还是 1 呢?显然,这是绝对禁止的。
如果有两个参数,这两个参数可以都是对象,也可以一个是对象,一个是C ++内置类型的数据,例如:
1 | complex operator+(int a, complex &c){ |
它的作用是使一个整数和一个复数相加。
另外,将运算符重载函数作为全局函数时,一般都需要在类中将该函数声明为友元函数。原因很简单,该函数大部分情况下都需要使用类的 private 成员。
上节的最后一个例子中,我们在全局范围内重载了+
号,并在 complex 类中将运算符重载函数声明为友元函数,因为该函数使用到了 complex 类的 m_real 和 m_imag 两个成员变量,它们都是 private 属性的,默认不能在类的外部访问。
- 箭头运算符
->
、下标运算符[ ]
、函数调用运算符( )
、赋值运算符=
只能以成员函数的形式重载。
C++ 重载运算符
四则运算符(+、-、、/、+=、-=、=、/=)和关系运算符(>、<、<=、>=、==、!=)都是数学运算符,它们在实际开发中非常常见,被重载的几率也很高,并且有着相似的重载格式。本节以复数类 Complex 为例对它们进行重载,重在演示运算符重载的语法以及规范。
复数能够进行完整的四则运算,但不能进行完整的关系运算:我们只能判断两个复数是否相等,但不能比较它们的大小,所以不能对 >、<、<=、>= 进行重载。下面是具体的代码:
1 |
|
运行结果:
c7 = 35 + 55i
c8 = 15 + 15i
c9 = -450 + 850i
c10 = 1.9 + -0.3i
c3 = 26 + 37i
c4 = -6 + -11i
c5 = 220 + 4460i
c6 = 5.2 + 1.592i
c1 != c2
需要注意的是,我们以全局函数的形式重载了 +、-、、/、==、!=,以成员函数的形式重载了 +=、-=、=、/=,而且应该坚持这样做,不能一股脑都写作成员函数或者全局函数,具体原因我们将在下节《到底以成员函数还是全局函数(友元函数)的形式重载运算符》讲解。
到底以成员函数还是全局函数(友元函数)的形式重载运算符
在上节的例子中,我们以全局函数的形式重载了 +、-、、/、==、!=,以成员函数的形式重载了 +=、-=、=、/=,而没有一股脑都写成全局函数或者成员函数,这样做是有原因的,这节我们就来分析一下。
简单地了解转换构造函数
在分析以前,我们先来了解一个概念,叫做「转换构造函数」。这个概念将会在《C++转换构造函数》一节中深入讲解,但是为了搞清成员函数和全局函数的区别,本节我们有必要提前了解一下。
请大家先看下面的例子:
1 |
|
运行结果:
40.6 + 35i
53.23 + 35i
请读者留意第 30、31 行代码,它说明 Complex 类型可以和 double 类型相加,这很奇怪,因为我们并没有对针对这两个类型重载 +,这究竟是怎么做到的呢?
其实,编译器在检测到 Complex 和 double(小数默认为 double 类型)相加时,会先尝试将 double 转换为 Complex,或者反过来将 Complex 转换为 double(只有类型相同的数据才能进行 + 运算),如果都转换失败,或者都转换成功(产生了二义性),才报错。本例中,编译器会先通过构造函数Complex(double real);
将 double 转换为 Complex,再调用重载过的 + 进行计算,整个过程类似于下面的形式:
也就是说,小数被转换成了匿名的 Complex 对象。在这个转换过程中,构造函数Complex(double real);起到了至关重要的作用,如果没有它,转换就会失败,Complex 也不能和 double 相加。
Complex(double real);
在作为普通构造函数的同时,还能将 double 类型转换为 Complex 类型,集合了“构造函数”和“类型转换”的功能,所以被称为「转换构造函数」。换句话说,转换构造函数用来将其它类型(可以是 bool、int、double 等基本类型,也可以是数组、指针、结构体、类等构造类型)转换为当前类类型。
作为了解,这里不再对转换构造函数阐述更多细节,后续将在《C++转换构造函数》一节中深入讲解。
为什么要以全局函数的形式重载 +
上面的例子中,我们定义的operator+
是一个全局函数(一个友元函数),而不是成员函数,这样做是为了保证 + 运算符的操作数能够被对称的处理;换句话说,小数(double 类型)在 + 左边和右边都是正确的。第 30 行代码中,15.6 在 + 的右边,第 31 行代码中,28.23 在 + 的左边,它们都能够被顺利地转换为 Complex 类型,所以不会出错。
如果将operator+
定义为成员函数,根据“+ 运算符具有左结合性”这条原则,Complex c2 = c1 + 15.6;
会被转换为下面的形式:
1 | Complex c2 = c1.operator+(Complex(15.6)); |
这就是通过对象调用成员函数,是正确的。而对于Complex c3 = 28.23 + c1;,编译器会尝试转换为不同的形式:
1 | Complex c3 = (28.23).operator+(c1); |
很显然这是错误的,因为 double 类型并没有以成员函数的形式重载 +。
也就是说,以成员函数的形式重载 +,只能计算c1 + 15.6,不能计算28.23 + c1,这是不对称的
有读者可能会问,编译器明明可以把 28.23 先转换成 Complex 类型再相加呀,也就是下面的形式:
1 | Complex c3 = Complex(28.23).operator+(c1); |
为什么就是不转换呢?没错,编译器不会转换,原因在于,C++ 只会对成员函数的参数进行类型转换,而不会对调用成员函数的对象进行类型转换。以下面的语句为例:
1 | obj.func(params); |
编译器不会尝试对 obj 进行任何类型转换,它有 func() 成员函数就调用,没有就报错。而对于实参 params,编译器会“拼命地”将它转换为形参的类型。
为什么要以成员函数的形式重载 +=
我们首先要明白,运算符重载的初衷是给类添加新的功能,方便类的运算,它作为类的成员函数是理所应当的,是首选的。不过,类的成员函数不能对称地处理数据,程序员必须在(参与运算的)所有类型的内部都重载当前的运算符。以上面的情况为例,我们必须在 Complex 和 double 内部都重载 + 运算符,这样做不但会增加运算符重载的数目,还要在许多地方修改代码,这显然不是我们所希望的,所以 C++ 进行了折中,允许以全局函数(友元函数)的形式重载运算符。
C++ 创始人 Bjarne Stroustrup 也曾考虑过为内部类型(bool、int、double 等)定义额外运算符的问题,但后来还是放弃了这种想法,因为 Bjarne Stroustrup 不希望改变现有规则:任何类型(无论是内部类型还是用户自定义类型)都不能在其定义完成以后再增加额外的操作。这里还有另外的一个原因,C内部类型之间的转换已经够肮脏了,决不能再向里面添乱。而通过成员函数为已存在的类型提供混合运算的方式,从本质上看,比我们所采用的全局函数(友元函数)加转换构造函数的方式还要肮脏许多。
采用全局函数能使我们定义这样的运算符,它们的参数具有逻辑的对称性。与此相对应的,把运算符定义为成员函数能够保证在调用时对第一个(最左的)运算对象不出现类型转换,也就是上面提到的「C++ 不会对调用成员函数的对象进行类型转换」。
总起来说,有一部分运算符重载既可以是成员函数也可以是全局函数,虽然没有一个必然的、不可抗拒的理由选择成员函数,但我们应该优先考虑成员函数,这样更符合运算符重载的初衷;另外有一部分运算符重载必须是全局函数,这样能保证参数的对称性;除了 C++ 规定的几个特定的运算符外,暂时还没有发现必须以成员函数的形式重载的运算符。
C++ 规定,箭头运算符->、下标运算符[ ]、函数调用运算符( )、赋值运算符=只能以成员函数的形式重载。
C++ 重载>>和<<
在 C++ 中,标准库本身已经对左移运算符<<
和右移运算符>>
分别进行了重载,使其能够用于不同数据的输入输出,但是输入输出的对象只能是 C++ 内置的数据类型(例如 bool、int、double 等)和标准库所包含的类类型(例如 string、complex、ofstream、ifstream 等)。
如果我们自己定义了一种新的数据类型,需要用输入输出运算符去处理,那么就必须对它们进行重载。本节以前面的 complex 类为例来演示输入输出运算符的重载。
其实 C++ 标准库已经提供了 complex 类,能够很好地支持复数运算,但是这里我们又自己定义了一个 complex 类,这样做仅仅是为了教学演示。
本节要达到的目标是让复数的输入输出和 int、float 等基本类型一样简单。假设 num1、num2 是复数,那么输出形式就是:
1 | cout<<num1<<num2<<endl; |
输入形式就是:
1 | cin>>num1>>num2; |
cout 是 ostream 类的对象,cin 是 istream 类的对象,要想达到这个目标,就必须以全局函数(友元函数)的形式重载<<和>>,否则就要修改标准库中的类,这显然不是我们所期望的。
cout 是 ostream 类的对象,cin 是 istream 类的对象,要想达到这个目标,就必须以全局函数(友元函数)的形式重载<<和>>,否则就要修改标准库中的类,这显然不是我们所期望的。
重载输入运算符>>
下面我们以全局函数的形式重载>>,使它能够读入两个 double 类型的数据,并分别赋值给复数的实部和虚部:
1 | istream & operator>>(istream &in, complex &A){ |
istream 表示输入流,cin 是 istream 类的对象,只不过这个对象是在标准库中定义的。之所以返回 istream 类对象的引用,是为了能够连续读取复数,让代码书写更加漂亮,例如:
1 | complex c1, c2; |
如果不返回引用,那就只能一个一个地读取了:
1 | complex c1, c2; |
另外,运算符重载函数中用到了 complex 类的 private 成员变量,必须在 complex 类中将该函数声明为友元函数:
1 | friend istream & operator>>(istream & in , complex &a); |
运算符可以按照下面的方式使用:
1 | complex c; |
当输入1.45 2.34↙后,这两个小数就分别成为对象 c 的实部和虚部了。cin>> c;这一语句其实可以理解为:
1 | operator<<(cin , c); |
重载输出运算符<<
同样地,我们也可以模仿上面的形式对输出运算符>>
进行重载,让它能够输出复数,请看下面的代码:
1 | ostream & operator<<(ostream &out, complex &A){ |
ostream 表示输出流,cout 是 ostream 类的对象。由于采用了引用的方式进行参数传递,并且也返回了对象的引用,所以重载后的运算符可以实现连续输出。
为了能够直接访问 complex 类的 private 成员变量,同样需要将该函数声明为 complex 类的友元函数:
1 | friend ostream & operator<<(ostream &out, complex &A); |
综合演示
结合输入输出运算符的重载,重新实现 complex 类:
1 |
|
运行结果:
2.4 3.6↙
4.8 1.7↙
c1 + c2 = 7.2 + 5.3 i
c1 - c2 = -2.4 + 1.9 i
c1 * c2 = 5.4 + 21.36 i
c1 / c2 = 0.942308 + 0.705128 i
C++ 重载[](下标运算符)
C++ 规定,下标运算符[ ]必须以成员函数的形式进行重载。该重载函数在类中的声明格式如下:返回值类型 & operator[ ] (参数);
或者:const 返回值类型 & operator[ ] (参数) const;
使用第一种声明方式,[ ]
不仅可以访问元素,还可以修改元素。使用第二种声明方式,[ ]
只能访问而不能修改元素。在实际开发中,我们应该同时提供以上两种形式,这样做是为了适应 const 对象,因为通过 const 对象只能调用 const 成员函数,如果不提供第二种形式,那么将无法访问 const 对象的任何元素。
下面我们通过一个具体的例子来演示如何重载[ ]
。我们知道,有些较老的编译器不支持变长数组,例如 VC6.0、VS2010 等,这有时候会给编程带来不便,下面我们通过自定义的 Array 类来实现变长数组。
1 |
|
运行结果:
5↙
0, 5, 10, 15, 20
33685536
重载[ ]
运算符以后,表达式arr[i]
会被转换为:
1 | arr.operator[ ](i); |
需要说明的是,B 是 const 对象,如果 Array 类没有提供 const 版本的operator[ ]
,那么第 60 行代码将报错。虽然第 60 行代码只是读取对象的数据,并没有试图修改对象,但是它调用了非 const 版本的operator[ ]
,编译器不管实际上有没有修改对象,只要是调用了非 const 的成员函数,编译器就认为会修改对象(至少有这种风险)。
C++ 重载++和–(自增和自减运算符)
自增++和自减–都是一元运算符,它的前置形式和后置形式都可以被重载。请看下面的例子:
1 |
|
运行结果:
s1: 00:00
s2: 00:01
s1: 00:01
s2: 00:01
上面的代码定义了一个简单的秒表类,m_min 表示分钟,m_sec 表示秒钟,setzero() 函数用于秒表清零,run() 函数是用来描述秒针前进一秒的动作,接下来是三个运算符重载函数。
先来看一下 run() 函数的实现,run() 函数一开始让秒针自增,如果此时自增结果等于60了,则应该进位,分钟加1,秒针置零。
operator++() 函数实现自增的前置形式,直接返回 run() 函数运行结果即可。
operator++ (int n) 函数实现自增的后置形式,返回值是对象本身,但是之后再次使用该对象时,对象自增了,所以在该函数的函数体中,先将对象保存,然后调用一次 run() 函数,之后再将先前保存的对象返回。在这个函数中参数n是没有任何意义的,它的存在只是为了区分是前置形式还是后置形式。
自减运算符的重载与上面类似,这里不再赘述。
C++重载new和delete运算符
内存管理运算符 new、new[]、delete 和 delete[] 也可以进行重载,其重载形式既可以是类的成员函数,也可以是全局函数。一般情况下,内建的内存管理运算符就够用了,只有在需要自己管理内存时才会重载。
以成员函数的形式重载 new 运算符:
1 | void * className::operator new( size_t size ){ |
以全局函数的形式重载 new 运算符:
1 | void * operator new( size_t size ){ |
两种重载形式的返回值相同,都是void *类型,并且都有一个参数,为size_t类型。在重载 new 或 new[] 时,无论是作为成员函数还是作为全局函数,它的第一个参数必须是 size_t 类型。size_t 表示的是要分配空间的大小,对于 new[] 的重载函数而言,size_t 则表示所需要分配的所有空间的总和。
size_t 在头文件 中被定义为typedef unsigned int size_t;,也就是无符号整型。
当然,重载函数也可以有其他参数,但都必须有默认值,并且第一个参数的类型必须是 size_t。
同样的,delete 运算符也有两种重载形式。以类的成员函数的形式进行重载:
1 | void className::operator delete( void *ptr){ |
以全局函数的形式进行重载:
1 | void operator delete( void *ptr){ |
两种重载形式的返回值都是 void 类型,并且都必须有一个 void 类型的指针作为参数,该指针指向需要释放的内存空间。
当我们以类的成员函数的形式重载了new 和 delete 操作符,其使用方法如下:
1 | C * c = new C; //分配内存空间 |
如果类中没有定义 new 和 delete 的重载函数,那么会自动调用内建的 new 和 delete 运算符。
C++ 重载()(强制类型转换运算符)
在 C++ 中,类型的名字(包括类的名字)本身也是一种运算符,即类型强制转换运算符。
类型强制转换运算符是单目运算符,也可以被重载,但只能重载为成员函数,不能重载为全局函数。经过适当重载后,(类型名)对象
这个对对象进行强制类型转换的表达式就等价于对象.operator 类型名()
,即变成对运算符函数的调用。
下面的程序对 double 类型强制转换运算符进行了重载。
1 |
|
程序的输出结果是:
1.2
3.2
第 8 行对 double 运算符进行了重载。重载强制类型转换运算符时,不需要指定返回值类型,因为返回值类型是确定的,就是运算符本身代表的类型,在这里就是 double。
重载后的效果是,第 13 行的(double)c
等价于c.operator double()
。
有了对 double 运算符的重载,在本该出现 double 类型的变量或常量的地方,如果出现了一个 Complex 类型的对象,那么该对象的 operator double 成员函数就会被调用,然后取其返回值使用。
例如第 14 行,编译器认为本行中c
这个位置如果出现的是 double 类型的数据,就能够解释得通,而 Complex 类正好重载了 double 运算符,因而本行就等价于:
1 | double n = 2 + c.operator double(); |
C++运算符重载注意事项以及汇总
在 C++ 中进行运算符重载时,有以下问题需要注意:
- 重载后运算符的含义应该符合原有用法习惯。例如重载+运算符,完成的功能就应该类似于做加法,在重载的
+
运算符中做减法是不合适的。此外,重载应尽量保留运算符原有的特性。 - C++ 规定,运算符重载不改变运算符的优先级。
- 以下运算符不能被重载:
.
、.*
、::
、? :
、sizeof
。 - 重载运算符
()
、[]
、->
、或者赋值运算符=
时,只能将它们重载为成员函数,不能重载为全局函数。
运算符重载的实质是将运算符重载为一个函数,使用运算符的表达式就被解释为对重载函数的调用。
运算符可以重载为全局函数。此时函数的参数个数就是运算符的操作数个数,运算符的操作数就成为函数的实参。
运算符也可以重载为成员函数。此时函数的参数个数就是运算符的操作数个数减一,运算符的操作数有一个成为函数作用的对象,其余的成为函数的实参。
必要时需要重载赋值运算符=,以避免两个对象内部的指针指向同一片存储空间。
运算符可以重载为全局函数,然后声明为类的友元。
<<和>>是在 iostream 中被重载,才成为所谓的“流插入运算符”和“流提取运算符”的。
类型的名字可以作为强制类型转换运算符,也可以被重载为类的成员函数。它能使得对象被自动转换为某种类型。
自增、自减运算符各有两种重载方式,用于区别前置用法和后置用法。
运算符重载不改变运算符的优先级。重载运算符时,应该尽量保留运算符原本的特性。