所谓重载,就是赋予新的含义。函数重载(Function Overloading)可以让一个函数名有多种功能,在不同情况下进行不同的操作。运算符重载(Operator Overloading)也是一个道理,同一个运算符可以有不同的功能。
实际上,我们已经在不知不觉中使用了运算符重载。例如,+号可以对不同类型(int、float 等)的数据进行加法操作;<<既是位移运算符,又可以配合 cout 向控制台输出数据。C++ 本身已经对这些运算符进行了重载。
v
C++ 也允许程序员自己重载运算符,这给我们带来了很大的便利。
运算符重载其实就是定义一个函数,在函数体内实现想要的功能,当用到该运算符时,编译器会自动调用这个函数。也就是说,运算符重载是通过函数实现的,它本质上是函数重载。
运算符重载的格式为:
返回值类型 operator 运算符名称 (形参表列)
{
//TODO:
}
operator是关键字,专门用于定义重载运算符的函数。我们可以将operator 运算符名称这一部分看做函数名,对于上面的代码,函数名就是operator+。
运算符重载函数除了函数名有特定的格式,其它地方和普通函数并没有区别。
运算符重载函数不仅可以作为类的成员函数,还可以作为全局函数
运算符重载是通过函数重载实现的,概念上大家都很容易理解,这节我们来说一下运算符重载的注意事项。
1) 并不是所有的运算符都可以重载。能够重载的运算符包括:
+ - * / % ^ & | ~ ! = < > += -= *= /= %= ^= &= |= << >> <<= >>= == != <= >= && || ++ -- , ->* -> () [] new new[] delete delete[]
上述运算符中,[]是下标运算符,()是函数调用运算符。自增自减运算符的前置和后置形式都可以重载。
长度运算符sizeof、条件运算符: ?、成员选择符.、对象选择符.*和域解析运算符::不能被重载
2) 重载不能改变运算符的优先级和结合性。
3) 重载不会改变运算符的用法,原有有几个操作数、操作数在左边还是在右边,这些都不会改变。例如~号右边只有一个操作数,+号总是出现在两个操作数之间,重载后也必须如此。
4) 运算符重载函数不能有默认的参数,否则就改变了运算符操作数的个数,这显然是错误的。
5) 运算符重载函数既可以作为类的成员函数,也可以作为全局函数。
将运算符重载函数作为类的成员函数时,二元运算符的参数只有一个,一元运算符不需要参数。之所以少一个参数,是因为这个参数是隐含的
将运算符重载函数作为全局函数时,二元操作符就需要两个参数,一元操作符需要一个参数,而且其中必须有一个参数是对象,好让编译器区分这是程序员自定义的运算符,防止程序员修改用于内置类型的运算符的性质。
v
6) 箭头运算符->、下标运算符[ ]、函数调用运算符( )、赋值运算符=只能以成员函数的形式重载。
重载<<, >>运算符
C++中,标准库本身已经对左移运算符<<和右移运算符>>分别进行了重载,使其能够用于不同数据的输入输出,但是输入输出的对象只能是 C++ 自带的数据类型,包括 int、float、bool 等基本类型,以及 string、complex 等标准库自定义的类型(也就是类)。
如果我们自己定义了一种新的数据类型,需要用输入输出运算符去处理,那么就必须对它们进行重载。本节以前面的 complex 类为例来演示输入输出运算符的重载。
其实 C++ 标准库已经提供了 complex 类,能够很好地支持复数运算,但是这里我们又自己定义了一个 complex 类,这样做仅仅是为了教学演示。
目标:让复数的输入输出和 int、float 等基本类型一样简单。假设 num1、num2 是复数,那么输出形式就是:
cout<<num1<<num2<<endl;
输入形式就是:
cin>>num1>>num2;
要想达到这个目标,就必须以全局函数的形式重载<<和>>。
C下面我们在全局范围内重载>>,使它能够读入两个 double 类型的数据,并转换为一个复数,保存到复数对象中:
istream & operator>>(istream &in, complex &A){
in >> A.m_real >> A.m_imag;
return in;
}
istream 表示输入流,cin 是 istream 类的对象,只不过这个对象是在标准库中定义的。之所以返回 istream 类对象的引用,是为了能够连续读取复数,让代码书写更加漂亮,例如:
cin>>num1>>num2;
如果不返回引用,那就只能一个一个地读取了:
cin>>num1;
cin>>num2;
另外,运算符重载函数中用到了 complex 类的 private 成员变量,必须在 complex 类中将该函数声明为友元函数:
friend istream & operator>>(istream & in , complex &a);
>>运算符可以按照下面的方式使用:
complex c;
cin>>c;
当输入1.45 2.34↙后,这两个小数就分别成为对象 c 的实部和虚部了。cin>> c;这一语句其实可以理解为:
operator<<(cin , c);
同样地,我们也可以模仿上面的形式对输出运算符进行重载,让它能够输出复数。重载函数的实现如下:
ostream & operator<<(ostream &out, complex &A){
out << A.m_real <<" + "<< A.m_imag <<" i ";
return out;
}
cout<<A<<endl
ostream 表示输出流,cout 是 ostream 类的对象。由于采用了引用的方式进行参数传递,并且也返回了对象的引用,所以重载后的运算符可以实现连续输出。
为了能够直接访问 complex 类的 private 成员变量,同样需要将该函数声明为 complex 类的友元函数:
friend ostream & operator<<(ostream &out, complex &A);
下标运算符[]
必须以类的成员函数的形式进行重载。该函数在类中的声明格式如下:
返回值类型 & operator[] (参数)
或者:
const 返回值类型 & operator[] (参数)
使用第一种声明方式,运算符重载函数不仅可以访问对象,同时还可以修改对象。使用第二种声明方式,运算符重载函数只能访问而不能修改对象。
默认情况下,通过下标访问数组中的元素并不具有检查边界溢出功能,我们可以通过运算符重载实现该功能。
按照函数重载的定义,函数名相同而形参表有本质不同的函数称为重载。在类中,由于隐含的this形参的存在,const版本的 function函数使得作为形参的this指针的类型变为指向const对象的指针,而非const版本的使得作为形参的this指针就是正常版本的指针。此处是发生重载的本质。重载函数在最佳匹配过程中,对于const对象调用的就选取const版本的成员函数,而普通的对象调用就选取非const版本的成员函数。
(注:this指针是一个const指针,地址不能改,但能改变其指向的对象或者变量)
int & operator[]( int );
const int & operator[]( int )const;
第一个函数最后不带 const,加上 const 意味着该成员函数是常成员函数,如果第一个函数后面也加上了const,则两个函数仅有返回值不同,编译器不能够区分这是函数重载,会报错。这两个版本的重载函数其实很好理解,第一个能够修改对象,第二个只能访问对象而不能修改对象。
重载下标运算符[]后,arr[5]会被转换为:
arr.operator[]( 5 );
最后需要说明的是:即使没有定义 const 版本的重载函数,这段代码也是可以正确运行的,但是非 const 成员函数不能处理 const 对象,所以在编程时通常会提供两个版本的运算符重载函数
重载赋值运算符 =
示例程序:
#include "stdafx.h"
#include<iostream>
using namespace std;
class Book{
private:
double m_price; //书的价格
int *m_bookmark; //书签
int m_num; //书签的数量
public:
Book(): m_price(0.0), m_bookmark(NULL), m_num(0){}
Book(double price, int *bookmark, int num);
void setBookmark(int, int); //修改书签
void display();
};
Book::Book(double price, int *bookmark, int num): m_price(price), m_num(num){
int *bmTemp = new int[num];
for(int i=0; i<num; i++){
bmTemp[i] = bookmark[i];
}
this->m_bookmark = bmTemp;
}
void Book::setBookmark(int page, int index){
if(index >= m_num-1){
cout<<"Out of bound!"<<endl;
}else{
m_bookmark[index] = page;
}
}
void Book::display(){
cout<<"price: "<<m_price<<endl;
cout<<"bookmarks: ";
for(int i=0; i<m_num; i++){
if(i == m_num-1)
{
cout<<m_bookmark[i]<<endl;
}
else
{
cout<<m_bookmark[i]<<", ";
}
}
}
int main(){
int m_bookmark[] = { 1, 49, 56, 290 };
Book java, cpp(68.5, m_bookmark, 4);
cpp.display();
java = cpp; //对象之间赋值
java.setBookmark(100, 2);
cpp.display();
return 0;
}
这段代码定义了一个 Book 类,表示一本书,书有价格,也有书签。书签是我们所标记的页码,这些页码中往往包含重要的知识点,记录下这些页码能够方便以后查阅。书签可以有多个,所以需要将它放在数组中。setBookmark() 函数用来修改某个书签,display() 函数用来展示书签和价格。
Book 类的构造函数中不是直接接收参数的值,而是根据参数所指向的数组,再创建一个新的数组。这样做的好处是对象有属于自己的数组,在其他地方修改实参所指向的数组不会影响该数组,能够很好的隔离。
在 main() 函数中,我们创建了两个对象 java 和 cpp,并用 cpp 给 java 赋值。两次调用 display() 的结果不同表明,调用 java 对象的 setBookmark( ) 函数影响到了 cpp 对象。这是因为,执行java = cpp;语句时会将 cpp.m_bookmark 的值复制给 java.m_bookmark,不同对象的成员变量指向同一个数组,当然会相互影响。
要解决这个问题,就需要重载赋值运算符。
Book & Book::operator=(const Book &b){
if( this != &b){
this->m_price = b.m_price;
this->m_num = b.m_num;
//为bookmark赋值
int *bmTemp = new int[b.m_num];
for(int i=0; i<b.m_num; i++){
bmTemp[i] = b.m_bookmark[i];
}
this->m_bookmark = bmTemp;
}
return *this;
}
内存管理运算符 new、new[]、delete 和 delete[] 也可以进行重载,其重载形式既可以是类的成员函数,也可以是全局函数。一般情况下,内建的内存管理运算符就够用了,只有在需要自己管理内存时才会重载。
以成员函数的形式重载 new 运算符:
void * className::operator new( size_t size ){
//TODO:
}
以全局函数的形式重载 new 运算符:
void * operator new( size_t size ){
//TODO:
}
两种重载形式的返回值相同,都是void *类型,并且都有一个参数,为size_t类型。在重载 new 或 new[] 时,无论是作为成员函数还是作为全局函数,它的第一个参数必须是 size_t 类型。size_t 表示的是要分配空间的大小,对于 new[] 的重载函数而言,size_t 则表示所需要分配的所有空间的总和。
size_t 在头文件 <cstdio> 中被定义为typedef unsigned int size_t;,也就是无符号整型。
当然,重载函数也可以有其他参数,但都必须有默认值,并且第一个参数的类型必须是 size_t。
同样的,delete 运算符也有两种重载形式。以类的成员函数的形式进行重载:
void className::operator delete( void *ptr){
//TODO:
}
以全局函数的形式进行重载:
void operator delete( void *ptr){
//TODO:
}
两种重载形式的返回值都是 void 类型,并且都必须有一个 void 类型的指针作为参数,该指针指向需要释放的内存空间。
当我们以类的成员函数的形式重载了new 和 delete 操作符,其使用方法如下:
C * c = new C; //分配内存空间
//TODO:
delete c; //释放内存空间
如果类中没有定义 new 和 delete 的重载函数,那么会自动调用内建的 new 和 delete 运算符。