1. 双目运算符类成员函数重载
观察下列程序，掌握双目运算符的类成员函数重载方式。
#include<iostream>
using namespace std;
class complex {
double real, imag;
public:
complex(double r = 0, double i = 0) { real = r; imag = i; }
complex operator + (complex&); //运算符重载的成员函数原型
//运算符结果类型 operator @(参数表列); 其中，@表示运算符
void print();
};
/*运算符重载实现：
函数返回类型 类名::operator @(参数表列)
{
//代码
}*/
complex complex::operator+(complex& c) { //operator+ 是类complex的成员函数
complex sum;
sum.real = real + c.real;
sum.imag = imag + c.imag;
return sum;
}
void complex::print() {
cout << "real=" << real << endl;
cout << "imag=" << imag << endl;
}
void main() {
complex a(5.0, 6.0), b(4.0, 5.0);
complex c;
c = a + b;
//c=5+a;
c.print();
}
说明：+是双目运算符，成员函数operator+(complex &c)的参数c是+的右操作数。在main函数中，c=a+b等价c=a.operator+(b);
编写程序：（运算符重载的成员函数）
定义people类，具有数据成员name(姓名)、id(身份证号)，均为字符数组或string类型。定义成员函数：
（1）带参构造函数，实现给数据成员赋初值；
（2）重载运算符==，实现对象比较（如果两个people类对象的身份证id相等，则结果为1，否则结果为0）。
在main函数中，通过if语句测试程序正确性。
#include <iostream>
#include <cstring>
using namespace std;
class people
{
private:
string name;
string id;
public:
people(string name_1, string id_1)
{
name == name_1;
id = id_1;
}
bool operator==(people& p);//重载的成员函数声明
};
bool people::operator==(people& p)
{
if (id == p.id)
return 1;
return 0;
}
int main()
{
people p1("HUAHUA", "123432"), p2("HUGFFY", "234143");
cout << "nanaa:" << "123432" << endl;
cout << "lili:" << "234143" << endl;
if (p1 == p2)
{
cout << "ID相等." << endl;
}
cout << "ID不相等！" << endl;
return 0;
}
2、双目运算符的非成员函数的重载
class complex;//需要类的原型声明 VC++编辑器需要
complex operator+(int, complex);//需要友元普通函数声明VC++编辑器需要
class complex {
private:
double real, imag;
public:
complex(double r = 0, double i = 0) { real = r; imag = i; }
friend complex operator + (int, complex); //运算符重载普通友元函数原型
//函数返回值类型 friend operator @(参数表列); 其中@表示运算符
void print();
};
/*运算符重载普通友元函数实现部分格式：
函数返回类型 operator @(参数表列) { //代码 } */
complex operator +(int c, complex d) {
complex sum;
sum.real = c + d.real;
sum.imag = d.imag;
return sum;
}
class people
{
private:
string name;
string id;
public:
people(string name_1, string id_1)
{
name == name_1;
id = id_1;
}
friend bool operator==(people& p3, people& p);
};
bool operator==(people& p3, people& p)
{
if (p3.id == p.id)
return 1;
return 0;
}
3、单目运算符的重载
#include<iostream>
using namespace std;
class complex {
private:
double real, imag;
public:
complex(double r = 0, double i = 0) { real = r; imag = i; }
complex& operator++(); //前缀形式原型
complex operator++(int); //后缀形式原型
void print();
};
complex& complex::operator++() {//前缀形式定义
++real;
++imag;
return (*this);
}
complex complex::operator++(int c) {//后缀形式定义
complex temp = *this;
++real;
++imag;
return temp;
}
void complex::print() {
cout << "real=" << real << endl;
cout << "imag=" << imag << endl;
}
void main() {
complex a(5.0, 6.0), b(4.0, 5.0);
complex c, d, f, g;
f = ++c; //等价形式c.operator++();
g = d++; //等价形式d.operator++(0);
f.print();
g.print();
}
注意：前缀 ++ 函数返回的是*this，后缀++返回的是一个局部对象。
自增++运算符的重载
++前缀运算符的重载原型（++a，a为对象）
complex& operator++(); //前缀形式原型
++后缀运算符重载原型（a++，a为一个对象）
complex operator++(int); //后缀形式 原型
例：编程：
定义Point类，有坐标_x,_y两个私有数据成员。
对Point类重载++(自增)、--（自减）运算符，实现对坐标值的改变；
定义成员函数print，输出成员_x,_y的值。用main函数验证结果。
#include <iostream>
using namespace std;
class Point {
public:
Point() { }
Point(int _x, int _y);
~Point() { }
Point& operator++();//对应于a++
Point& operator--();//对应于a--
Point operator++(int);//对应于a++
Point operator--(int);//对应于a--
void print();
private:
int x;
int y;
};
Point::Point(int _x, int _y) {
x = _x;
y = _y;
}
Point& Point::operator++() {//++a
x++;
y++;
return *this;
}
Point Point::operator++(int) {//a++
Point p=* this;
++(*this);
return p;
}
Point& Point::operator--() {//--a
x--;
y--;
return *this;
}
Point Point::operator--(int) {//a--
Point p=*this;
--(*this);
return p;
}
void Point::print()
{
cout << "(" << x << "," << y << ")" << endl;
}
int main()
{
Point a(3,5);
a.print();
cout << endl;
(a++).print();//测试后置++
a.print();
cout << endl;
(++a).print();//测试前置++
a.print();
cout << endl;
(a--).print();//测试后置--
a.print();
cout << endl;
(--a).print();//测试前置--
a.print();
return 0;
}
4、编程：定义一个矩阵类Matrix
class Matrix { //定义Matrix类
public:
int &operator [] ( int i ); //重载下标运算符[]
void input(); //输入数据函数
void display(); //输出数据函数
private:
int mat[5];
};
input函数实现对数据成员mat数组的输入，display函数实现对数据成员mat的输出。重载运算符[ ]，取得数据成员mat指定下标的元素值，比如：
Matrix m;
cout<<m[2]; //取得数据成员mat中，下标为2的值
#include<iostream>
#include<iostream>
using namespace std;
class Matrix { //定义Matrix类
public:
int& operator [] (int i); //重载下标运算符[]
void input(); //输入数据函数
void display(); //输出数据函数
private:
int mat[5];
};
void Matrix::input() {
for (int i = 0; i < 5; i++)
{
cout << "输入第" << i << "个元素：";
cin >> mat[i];
}
}
void Matrix::display() {
for (int i = 0; i < 5; i++)
{
cout << mat[i] << " ";
}
}
int& Matrix::operator[](int i) {
return this->mat[i];
}
void main() {
Matrix m;
m.input();
m.display();
cout << "Mat[2]=";
cout << m[2];
}
总结：
1. 将复数的加减法这样的运算重载为类的成员函数，除了使用了关键字operator外，运算符重载成员函数与类的普通成员函数没有什么区别。
2. 使用友元函数。即运算符重载为非成员函数
3. 一般在C++中只要定义非成员函数，就使用友元函数。（可以访问私有成员）
4. 单目运算符分为前置++和后置++。所以规定：对于前置单目运算符，重载函数没有形参；对于后置单目运算符，重载函数有一个int型形参。