所有运算符重载,都拥有一个统一的名称:operator# (#表示运算符号)
参数:根据运算符本身特点决定,如果是单目运算符,最多拥有一个参数,如果是双目运算符,最多拥有两个参数
返回值:由用户自己决定
1.调用原则及调用时机
1> 调用时机:使用该运算符时,系统自动调用,无需手动调用
2> 调用原则:左调右参 (运算符的左侧是函数调用者,右侧是该函数的参数) 例如:a = b; //a.operator=(b)
2. 重载版本
每个运算符重载,都可以实现两个版本的重载函数,分别是成员函数版和全局函数版
成员函数版比全局函数版本少一个参数,因为类对象本身就是一个参数
全局函数版和成员函数版只能实现一个,否则会造成调用时的混乱情况
全局函数版,需要使用友元函数来完成
3.算术类运算符重载
1> 种类:+、-、*、/、%
2> 表达式格式:L # R //L表示左操作数 #表示运算符 R表示右操作数
3> 左操作数:既可以是左值也可以是右值,运算过程中不会被修改
4> 右操作数:既可以是左值也可以是右值,运算过程中不会被修改
5> 结果:结果是一个同类的右值,不能被改变
6> 定义格式:
全局函数版:const 类名 operator# (const 类名 &L, const 类名 &R)
成员函数版:const 类名 operator# ( const 类名 &R)const
4.关系类运算符重载
1> 种类:>、=、
2> 表达式格式:L # R //L表示左操作数 #表示运算符 R表示右操作数
3> 左操作数:既可以是左值也可以是右值,运算过程中不会被修改
4> 右操作数:既可以是左值也可以是右值,运算过程中不会被修改
5> 结果:bool类型,表示真假
6> 定义格式:
全局函数版:bool operator# (const 类名 &L, const 类名 &R)
成员函数版:bool operator# ( const 类名 &R)const
5.赋值类运算符重载
1> 种类:=、+=、-=、*=、/=、%=
2> 表达式格式:L # R //L表示左操作数 #表示运算符 R表示右操作数
3> 左操作数:只能是左值
4> 右操作数:既可以是左值也可以是右值,运算过程中不会被修改
5> 结果:自身的引用
6> 定义格式:
全局函数版:类名 &operator# (类名 &L, const 类名 &R)
成员函数版:类名 & operator# ( const 类名 &R)
6.单目运算符重载
1> 种类:!、~、*、&、-
2> 表达式格式: # O // #表示运算符 O表示操作数
3> 操作数:既可以是左值也可以是右值,运算过程中不能更改
4> 结果:同类的右值
5> 定义格式:
全局函数版:类名 operator# (const 类名 &O)
成员函数版:类名 operator# ( )const
7.自增自减运算符
1> 前置自增运算
1、表达式格式:++O
2、操作数:只能是左值
3、结果:更改后自身的引用,是一个左值
4、定义格式
全局函数版:类名& operator++(类名 & other)
成员函数版:类名 & operator++()
2> 后置自增
1、表达式格式:O++
2、操作数:只能是左值
3、结果:临时值,是一个右值,更改之前的值
4、定义格式:为了区分跟前置自增的区别,后置自增多一个哑元进行占位
全局函数版:类名 operator++(类名 & other, int)
成员函数版:类名 operator++(int)
8.插入提取运算符的重载(>)
1> 这两个运算符的使用:cout>对象名 //cout.operator
2> cin和cout所在的类分别为istream和ostream类,如果想要实现成员函数版的运算符重载,需要对这两个类重新更改内容
3> 对于这两个运算符重载,只能使用全局函数版,借助友元的威力来实现
4> 由于不需要访问istream或ostream类中的私有成员或受保护成员,所以无需将该全局函数在istream和ostream类中设置成友元函数
5> 由于该函数要访问自定义类的私有成员,所以只需在自定义类中将该全局函数设置成友元函数即可
6> 表达式:L#R //L表示cin或cout #表示>运算符 R表示自定义的类对象
7> 左操作数:istream或ostream类对象
8> 右操作数:自定义的类对象
9> 结果:左操作数自身的引用
10> 定义格式
ostream &operator
istream &operator>>(istream &L, 类名 &R);
9.代码
#include <iostream>
using namespace std;
//定义一个复数类 5 + 3i
class Complex
{
private:
int real; //实部
int vir; //虚部
public:
Complex() {}
Complex(int r, int v):real(r), vir(v) {} //有参构造
//定义展示函数
void show()
{
if(vir>=0)
{
cout<<real<<" + "<<vir<<"i"<<endl;
}else
{
cout<<real<<vir<<"i"<<endl;
}
}
//全局函数版实现加运算符重载
friend const Complex operator+ (const Complex &L, const Complex &R);
//成员函数版实现运算符重载
const Complex operator- ( const Complex &R)const
{
Complex c;
c.real = this->real - R.real;
c.vir = this->vir - R.vir;
return c;
}
//成员函数版实现关系运算符的重载:实部>实部 && 虚部>虚部
bool operator>(const Complex &R)const
{
return this->real>R.real&&this->vir>R.vir;
}
//重载中括号运算符
int & operator[](int index)
{
if(index == 0)
{
return real; //返回实部
}else if(index == 1)
{
return vir; //返回虚部
}
}
//重载+=运算符:实部+=实部 虚部+=虚部
Complex & operator+=(const Complex &R)
{
this->real += R.real;
this->vir += R.vir;
return *this; //返回自身的引用
}
//重载负号运算符: 实部= -实部, 虚部 = -虚部
Complex operator-()
{
Complex c;
c.real = -this->real;
c.vir = -this->vir;
return c;
}
//重载前置自增运算符重载函数:实部 = 实部+1 虚部=虚部+1
Complex &operator++()
{
++this->real;
++this->vir;
return *this;
}
//重载后置自增运算符重载函数:实部 = 实部+1 虚部=虚部+1
Complex operator++(int)
{
Complex c;
c.real = this->real++;
c.vir = this->vir++;
return c;
}
//将全局函数版实现的输出运算符重载函数设置成友元
friend ostream &operator<<(ostream &L, Complex &c);
//重载小括号运算符,做一个仿函数
void operator()(string s)
{
cout<<s<<endl;
}
//重载小括号运算符,做一个仿函数
void operator()()
{
cout<<520<<" "<<1314<<endl;
}
//重写类型转换运算符
operator int()
{
return real; //将该数据类型向int类型转换后,使用的是real的值
}
};
//全局函数版实现加号运算符重载:实部+实部 虚部+虚部
const Complex operator+ (const Complex &L, const Complex &R)
{
//定义一个临时空间
Complex c;
c.real = L.real + R.real;
c.vir = L.vir + R.vir;
return c;
}
//重载输出运算符函数
ostream &operator<<(ostream &L, Complex &c)
{
if(c.vir>=0)
{
L<<c.real<<" + "<<c.vir<<"i"<<endl;
}else
{
L<<c.real<<c.vir<<"i"<<endl;
}
//返回左操作数自身的引用
return L;
}
int main()
{
Complex c1(5,3);
c1.show(); //5+3i
Complex c2(2,-1);
c2.show(); //2-1i
Complex c3 = c1-c2; //调用加法运算符重载函数 c1.operator-(c2)
c3.show(); //3+4i
if(c3 > c2) //调用关系运算符重载函数
{
cout<<"yes"<<endl;
}else
{
cout<<"no"<<endl;
}
c3[0] = 5; //将实部进行修改成5,调用中括号运算符重载
c3.show(); //5+4i
c3 += c2; //调用+=运算符重载函数
c3.show(); //7+3i
Complex c4 = -c3; //调用-号运算符重载
c4.show(); //-7 - 3i
c3.show(); //7+3i
Complex c5 = ++c3; //调用前置自增运算符重载函数
c5.show(); //8+4i
c3.show(); //8+4i
Complex c6 = c3++; //调用后置自增运算符重载函数
c6.show(); //8+4i
c3.show(); //9+5i
cout<<c3; //cout.operator<<(c3)
c3("hello world"); //c3.operator()("hello world");
c3();
int num = (int)c3; //调用类型转换运算符重载函数
cout<<"num = "<<num<<endl;
return 0;
}