C++操作符重载

1.输入和输出操作符

　　对于输入和输出操作符，对其进行重载需要将操作符重载函数定义为非成员函数，否则操作符的左操作数只能是该类类型的对象。为了保证操作符重载函数能够正常访问类中定义的私有成员，需要将操作符重载函数定义为类的友元函数。下面是重载输入和输出操作符的一个简单例子。

#include <iostream>
using namespace std;
class point{
private:
int x;
int y;
public:
point(int x,int y){
this->x=x;
this->y=y;
}
friend ostream &operator<<(ostream &os,const point &p);
friend istream &operator>>(istream &is,point &p);
};
ostream & operator<<(ostream &os, const point &p) {
os<<p.x<<" "<<p.y;
return os;
}
istream & operator >>(istream &is,point &p){
is>>p.x>>p.y;
return is;
}
int main() {
point * p = new point(1,2);
cout<<*p<<endl;
cin>>*p;
cout<<*p<<endl;
return 0;
}

运行截图：



2.算术操作符和关系操作符

　　一般，将算术和关系操作符定义为非成员函数。如下定义了上述类point的加法操作符重载函数。

#include <iostream>
using namespace std;
class point{
private:
int x;
int y;
public:
point(int x,int y){
this->x=x;
this->y=y;
}
friend ostream &operator<<(ostream &os,const point &p);
friend istream &operator>>(istream &is,point &p);
//定义了友元函数,用于重载加法运算符号
friend point operator+(const point &p1,const point &p2);
};
ostream & operator<<(ostream &os, const point &p) {
os<<p.x<<" "<<p.y;
return os;
}
istream & operator >>(istream &is,point &p){
is>>p.x>>p.y;
return is;
}
//非成员函数,重载加法运算符
point operator+(const point &p1,const point &p2){
auto p = new point(p1.x+p2.x,p1.y+p2.y);
return *p;
}
int main() {
//在堆区实例化类成员
point * p1 = new point(1,2);
//在栈区实例化类成员
point p2(3,4);
auto p = *p1 +p2;
cout<<p<<endl;
return 0;
}

　　输出结果：

　　4 6

3.赋值操作符

　　对于赋值操作符的重载函数，必须要返回对*this的引用，返回赋值之后的对象。以下定义了类point的赋值重载函数。

#include <iostream>
using namespace std;
class point{
private:
int x;
int y;
public:
point(int x,int y){
this->x=x;
this->y=y;
}
friend ostream &operator<<(ostream &os,const point &p);
friend istream &operator>>(istream &is,point &p);
//定义了成员函数,用于重载赋值操作符
point &operator=(const point & p){
x=p.x;
y=p.y;
return *this;
}
};
ostream & operator<<(ostream &os, const point &p) {
os<<p.x<<" "<<p.y;
return os;
}
istream & operator >>(istream &is,point &p){
is>>p.x>>p.y;
return is;
}
int main() {
//在堆区实例化类成员
point * p1 = new point(1,2);
point p2 = *p1;
cout<<p2<<endl;
return 0;
}
//输出 ： 1  2

4.下标操作符

　　定义下标操作符比较复杂，需要保证它在用作赋值的左右操作数的时候都能够表现正常。下标操作符出现在左边，必须生成左值，可以指定引用作为返回类型而作为左值。

　　可以分为两种情况，const对象和非const对象来定义下标操作符重载函数。引用于const对象的时候，返回的值为const引用，不能被赋值。以下是一个简单的例子。

#include<iostream>
#include<vector>
using namespace std;
class fun {
private:
vector <int> data;
public:
void push(int x){
data.push_back(x);
}
//可以用作左值
int &operator[](const size_t index){
return data[index];
}
//类的成员函数之后使用const进行修饰,表明这个函数不会对这个类对象的数据成员
//（准确地说是非静态数据成员）作任何改变。
//用于右值
const int & operator[](const size_t index) const{
return data[index];
}
void print(){
for(auto a:data){
cout<<a<<" "<<endl;
}
}
};
int main() {
fun *test =new fun();
for(int i=0;i<3;i++)
test->push(i);
//右值
int value1 = (*test)[1];
//左值
(*test)[2]=-2;
test->print();

return 0;
}

输出：

0
1
-2

5.成员访问操作符重载

　　如下，我们实现了一个简单的采用引用计数方式实现的智能指针类。指针指向的真实数据对象是类别Screen。类Screen中的数据成员x和y表示像素点的位置坐标。为了实现类Screen的智能管理，我们进一步定义了类Scrptr和ScreenPtr。类Scrptr中的数据成员分别是指向Screen对象的指针和Screen对象的引用计数，如果引用计数等于0，就销毁Screen对象。每引用一次Screen对象，就对引用计数的值加上1。类Scrptr指定类ScreenPtr为友元类，类ScreenPtr可以自由访问类ScrPtr中的私有成员。我们不通过类ScrPtr来直接访问类Screen，这是因为在下述情况下：

class ScrPtr{
public:
//constructor use Screen*
Scrptr(Screen * ptr){
this->s_ptr=ptr;
use =0;
}
//constructor use ScrPtr &
Scrptr(ScrPtr & org){
++org.use;
this->s_ptr =org.s_ptr;
use =org.use;
}
private:
Screen * s_ptr;
int use;
}
Screen  * screen = new Screen(1,2);
ScrPtr p1 (screen);
ScrPtr p2(p1);
ScrPtr p3(p1);
//在这种情况之下，如何更新p2的引用计数成为了问题
//可以在p1中将计数增量并且复制到p3，但是怎样更新p2中的计数

　　p1、p2和p3的背后只有一个Screen对象，但是计数器的值却有两种，这样无法追踪真实的对象到底被引用了几次。这种解决方式无法跟踪对象的实际引用情况，没有实现对象和引用计数的绝对绑定。

　　通过使用间接的友元类来访问类ScrPtr来间接的访问类Screen，能够解决上述问题，实现了对象和引用计数的绝对绑定，可以确定的追踪每一个对象的实际引用情况。

#include<iostream>
#include<vector>
using namespace std;
class Screen{
private:
int x;
int y;
public:
Screen(int x, int y) : x(x), y(y) { }
int getX() const {
return x;
}
void setX(int x) {
Screen::x = x;
}
int getY() const {
return y;
}
void setY(int y) {
Screen::y = y;
}
void print(){
cout<<x<<endl<<y<<endl;
}
};
class ScrPtr{
friend class ScreenPtr;
Screen *sp;
size_t use;
ScrPtr(Screen *p):sp(p),use(1){}
~ScrPtr(){delete sp;}
};
class ScreenPtr{
private:
ScrPtr *ptr;
public:
ScreenPtr(Screen *p):ptr(new ScrPtr(p)){}
ScreenPtr(const ScreenPtr &orig):ptr(orig.ptr){++ptr->use;}
ScreenPtr &operator=(const ScreenPtr & rhs) {
//右值的引用计数加1
++rhs.ptr->use;
//左值的引用计数减1
delete this;
//完成赋值操作
ptr = rhs.ptr;
//返回赋值之后对象的引用
return *this;
}
Screen &operator*(){
return *(ptr->sp);
}
Screen *operator->(){
return ptr->sp;
}
const Screen &operator*() const{
return *(ptr->sp);
}
const Screen *operator->() const{
return ptr->sp;
}
~ScreenPtr(){if(--ptr->use==0)
delete ptr;
}
};
int main() {
vector<ScreenPtr *> v ;
Screen *a = new Screen(1,2);
Screen *b = new Screen(3,4);
ScreenPtr *ptr_a = new ScreenPtr(a);
ScreenPtr *ptr_b = new ScreenPtr(b);
v.push_back(ptr_a);
v.push_back(ptr_b);
*ptr_a=*ptr_b;
for(int i=0;i<v.size();i++){
auto ptr =v[i];
(*ptr)->print();
}
}

　　因为采取这种间接的方式访问Screen对象，通过操作符*与->并不能够直接访问类Screen，为此我们可以重载这两个成员访问操作符，调用真实的Screen对象。上述标红代码就调用了重载之后的成员访问操作符函数。

6.重载自增和自减操作符

　　重载自增和自减操作符分为两种情况，分别是前缀操作符重载和后缀操作符重载，可以使用下述例子进行简要的说明。

　　重点：对于后缀自增和自减操作符，编译器会自动传入一个int类型的数0作为参数进行调用，从而与前缀自增和自减操作符进行区分。

#include<iostream>
using namespace std;
class Value{
private:
int a;
public:
Value (int a){
this->a =a ;
}
Value & operator ++ () {
a++;
return *this;
}
Value & operator ++ (int) {
Value ret(a);
++a;
return ret;
}
Value & operator -- (){
a--;
return *this;
}
Value &operator -- (int){
Value ret(a);
--a;
return ret;
}
void print(){
cout<<a<<endl;
}
};
int main(){
Value a(1);
//后缀自增
Value b = a++;
a.print();
b.print();
//前缀自增
b = ++a;
a.print();
b.print();
return 0;
}

输出：

2
1
3
3

7.转换操作符重载

　　转换操作符重载能够方便的利用类型转换来简化操作，如下所示：

#include<iostream>
using namespace std;
class SmallInt{
private:
int value;
public:
SmallInt(int value):value(value){
if(value <0||value>256){
throw out_of_range("bad smallint initializer!");
}
}
//转换操作符重载函数无需指明返回值的类型
operator int() const {
return value;
}
};
int main(){
SmallInt a (100);
//自动调用转换操作符,采用int数的方式输出SmallInt对象
cout<<a<<endl;
return 0;
}

　　但是转换操作符重载可能会引起二义性问题。如下所示，我们如果同时定义了SmallInt类型和double和int之间的转换关系，在发生下述操作的时候，就会引起二义性问题：

#include<iostream>
using namespace std;
class SmallInt{
private:
int value;
public:
SmallInt(int value):value(value){
if(value <0||value>256){
throw out_of_range("bad smallint initializer!");
}
}
//转换操作符重载函数无需指明返回值的类型
operator int() const {
return value;
}
operator double() const {
return value;
}
};
int main(){
long double a =1.0;
SmallInt b(1);
cout<<a+b<<endl;
return 0;
}

报错：

　　error: use of overloaded operator '+' is ambiguous (with operand types 'long double' and 'SmallInt')

　　错误在于从SmallInt转换成为long double类型是首先将SmallInt转换成int类型还是首先转换成double类型？这就存在歧义了！

参考：C++ Primer 4th