- 实质：重载的实质就是写一个重载函数
- 语法：函数类型 operator 运算符名称 {对运算符的重载处理}
- 说明：如果要对加号进行重载，则 “operator +” 就是函数名。
方法：
（1）成员函数法
定义：把运算符重载的函数作为类的成员函数
说明：在该方法中，重载函数只有一个参数，因为由于重载函数是Complex类中的成员函数，因此有一个参数是隐含的，运算符函数是用this指针隐式访问类对象的成员。如：this –> real + c2.real。this –> real就是 c1.real。（2）非成员函数法
定义：运算符重载的函数不是类的成员函数（可以是一个普通函数），放在类外，在类中把它声明为友元函数。
优点：代码看起来更加清晰。
例1: 通过重载实现复数相加（i.e. 对运算符 “+” 的重载）
法一：成员函数法
#include <iostream>
using namespace std;//Step 1: 定义Complex类，及声明有关函数：复数相加函数
class Complex
{private:double real;double imag;public:Complex(){real=0;imag=0;} //定义构造函数Complex(double r,double i){real=r;imag=i;} //构造函数重载Complex operator + (Complex &c2); //声明重载运算符+的函数void display();//声明输出函数
};//Step 2: 定义重载运算符+的函数: operator +()
Complex Complex::operator +(Complex &c2)
{Complex c;c.real=real+c2.real;c.imag=imag+c2.imag;return c;
}//Step 3: 定义输出函数display()
void Complex::display()
{cout<<"("<<real<<","<<imag<<"i)"<<endl;}//Step 4: 在主函数内调用其他函数
int main()
{Complex c1(3,4),c2(5,-10),c3;c3=c1+c2;cout<<"c1="; c1.display();cout<<"c2="; c2.display();cout<<"c1+c2="; c3.display();return 0;
}输出：
法二：非成员函数法——友元函数法
#include <iostream>
using namespace std;//Step 1: 定义Complex类，及声明有关函数：复数相加函数
class Complex
{private:double real;double imag;public:Complex(double r=0,double i=0); //声明构造函数的同时初始化（即：赋初值）friend Complex operator + (Complex c1,Complex c2); //声明重载函数作为友元函数void display();//声明输出函数
};//Step 2: 定义构造函数
Complex::Complex(double r,double i)
{ real=r;imag=i;
} //Step 3: 定义重载运算符+的函数: operator +()
Complex operator +(Complex c1,Complex c2){return Complex(c1.real+c2.real,c1.imag+c2.imag);}//Step 4: 定义输出函数display()
void Complex::display()
{cout<<"("<<real<<","<<imag<<"i)"<<endl;}//Step 5: 在主函数内调用其他函数
int main()
{Complex c1(3,4),c2(5,-10),c3;c3=c1+c2;cout<<"c1="; c1.display();cout<<"c2="; c2.display();cout<<"c1+c2="; c3.display();return 0;
}
//ps：这里之所以要初始化对象数据成员，是因为最后建立对象c3时，没有传递实参，因此必须要有初始化的值才行例2: 通过重载实现复数相乘（i.e. 对运算符 “*” 的重载）
这里用友元函数法来实现
#include <iostream>
using namespace std;//Step 1: 定义Complex类，及声明有关函数：复数相加函数
class Complex
{private:double real;double imag;public:Complex(double r=0,double i=0); //声明构造函数friend Complex operator * (Complex c1,Complex c2); //声明重载函数作为友元函数void display();//声明输出函数
};//Step 2: 定义构造函数
Complex::Complex(double r,double i)
{ real=r;imag=i;
} //Step 3: 定义重载运算符*的函数: operator *()
Complex operator *(Complex c1,Complex c2)
{Complex c;c.real=c1.real*c2.real-c1.imag*c2.imag;c.imag=c1.real*c2.imag+c1.imag*c2.real;return c;
}//Step 4: 定义输出函数display()
void Complex::display()
{cout<<"("<<real<<","<<imag<<"i)"<<endl;}//Step 5: 在主函数内调用其他函数
int main()
{Complex c1(3,4),c2(5,-10),c3;c3=c1*c2;cout<<"c1="; c1.display();cout<<"c2="; c2.display();cout<<"c1*c2="; c3.display();return 0;
}
例3: 有两个矩阵a和b，均为2行3列。求两个矩阵之和。重载运算符“+”，使之能用于矩阵相加（如c=a+b）
#include <iostream>
using namespace std;//Step 1: 定义Matrix类，及声明有关函数：矩阵相加函数
class Matrix //定义Matrix类{public:Matrix(); //声明构造函数friend Matrix operator+(Matrix ,Matrix ); //重载运算符“+”void input(); //输入数据函数void display(); //输出数据函数private:int mat[2][3];};//Step 2: 定义构造函数
Matrix::Matrix()
{for(int i=0;i<2;i++)for(int j=0;j<3;j++)mat[i][j]=0; //初始化对象们的公有成员mat[i][j]
}//Step 3: 定义重载运算符+的函数: operator +()
Matrix operator+(Matrix a,Matrix b) //定义重载运算符“+”函数
{Matrix c;for(int i=0;i<2;i++)for(int j=0;j<3;j++){c.mat[i][j]=a.mat[i][j]+b.mat[i][j];}return c;
}//Step 4: 定义输入函数input()和输出函数display()
void Matrix::input() //定义输入数据函数
{cout<<"input value of matrix:"<<endl;for(int i=0;i<2;i++)for(int j=0;j<3;j++)cin>>mat[i][j];
}void Matrix::display() //定义输出数据函数
{for (int i=0;i<2;i++){for(int j=0;j<3;j++){cout<<mat[i][j]<<" ";}cout<<endl;}
}//Step 5: 在主函数内调用其他函数
int main()
{Matrix a,b,c;a.input();b.input();cout<<endl<<"Matrix a:"<<endl;a.display();cout<<endl<<"Matrix b:"<<endl;b.display();c=a+b; //用重载运算符“+”实现两个矩阵相加cout<<endl<<"Matrix c = Matrix a + Matrix b :"<<endl;c.display();return 0;
}
