c++面向对象编程——运算符重载

c++面向对象编程——>>>运算符重载

1.什么是运算符重载

#include <iostream>
using namespace std;
class Complex{
private:
	double r;
	double i;
public:
	Complex(double r, double i){
		this->r = r;
		this->i = i;
	}
	void print(void){
		cout << r << " + " << i << "i" << endl;
	}
};
int main(void){
	Complex a(1,2);
	Complex b(3,4);
	a.print();
	b.print();
	int x = 10;
	int y = 20;
	int z = x + y;
//	a+b; //想像x+y 实现Complex对象加运算 ＋运算符新的逻辑功能 要实现+运算符的重载
	return 0;
}

2.双目运算符重载

**双目运算符：**有左右两个操作数的操作符 L#R

• 算术运算：*、/、%、+、-

• 关系运算：>、>=、<、<=、==、!=

• 逻辑运算：&&、||

• 位运算：&、|、^、<< 、>>

• 赋值与复合赋值：=、+=、-=、*=、/=、%=、&=、|=、^=、<<= 、>>=

• … …

注意：

• 表达式结果是右值

• 左右操作数既可以是左值也可以是右值

实现方式：

• 成员函数形式：L.operator#®

• 友元函数形式：operator#(L,R)

#include <iostream>
using namespace std;
class Complex{
private:
	double r;
	double i;
public:
	Complex(double r, double i){
		this->r = r;
		this->i = i;
	}
	void print(void){
		cout << r << " + " << i << "i" << endl;
	}
	const Complex operator+(const Complex& c)
	{
		Complex tmp(r+c.r, i+c.i);
		return tmp;
	}
	friend const Complex operator-(const Complex& l, const Complex& r);
};

const Complex operator-(const Complex& l, const Complex& r)
{
	Complex tmp(l.r - r.r, l.i - r.i);
	return tmp;
}

int main(void){
	Complex a(1,2);
	Complex b(3,4);
	a.print();
	b.print();

	Complex c = a + b;
	c.print();

	Complex d = c - b;// operator-(c, a);
	d.print();
	return 0;
}

对赋值类双目运算符重载时需要注意的事项：

• 表达式的结果是左值，就是左操作数的自身

• 左操作数必须是左值，右操作数可以是左值也可以是右值

Complex & operator+=(const Complex &c){
	r = r + c.r;
	i = i + c.i;
	return *this;
}
*******************************************
Complex & operator-=(Complex &L, const Complex &R){
	L.r -= R.r;
	L.i -= R.i;
	return L;
}

3.单目运算符重载

单目运算符： 只有一个操作数的运算符 #O

• 相反数：-

• 位反：~

• 逻辑非：!

• 自增：++

• 自减：–

• … …

3.1 计算类单目运算符

注意：

• 表达式结果是右值

• 操作数可以是左值也可以是右值

实现方式：

• 成员函数形式：O.operator#();

• 友元函数形式：operator#(O);

#include <iostream>
using namespace std;
class Integer{
private:
	int i ;
public:
	Integer(int m=0):i(m){}
	void print(void){
		cout << i << endl;
	}
	const Integer operator-(){
	return Integer(-i);
	}
};
int main(void){
	Integer a(10);
	Integer b = -a;
	b.print();
	return 0;
}

3.2 前缀自增减单目运算符

注意：

• 表达式结果是左值, 而且是自身

• 操作数必须是左值

实现方式：

• 成员函数形式：O.operator#();

• 友元函数形式：operator#(O);

#include <iostream>
using namespace std;
class Integer{
private:
	int i ;
public:
	Integer(int m=0):i(m){}
	void print(void){
		cout << i << endl;
	}
	const Integer operator-(){
	return Integer(-i);
	}

	Integer& operator++()
	{
		++i;
		return *this;
	}
	friend Integer& operator--(Integer &o)
	{
		--o.i;
		return o;
	}
};
int main(void){
	Integer a(10);
	Integer b = -a;
	b.print();

	(++a).print();
	(--a).print();
	return 0;
}

3.3 后缀自增减单目运算符

注意：

• 表达式结果是右值，是操作数自增减前的副本

• 操作数必须是左值

实现方式：

• 成员函数形式：O.operator#(哑元);

• 友元函数形式：operator#(O,哑元);

#include <iostream>
using namespace std;
class Integer{
private:
	int i ;
public:
	Integer(int m=0):i(m){}
	void print(void){
		cout << i << endl;
	}
	const Integer operator-(){
	return Integer(-i);
	}
	/*前++*/
	Integer& operator++()
	{
		++i;
		return *this;
	}
	/*前--*/
	friend Integer& operator--(Integer &o)
	{
		--o.i;
		return o;
	}
	/*后++*/
	const Integer operator++(int)
	{
		Integer old = *this;
		++(*this);//++(this->i)
		return old;
	}
	/*后--*/
	friend const Integer operator--(Integer& o, int)
	{
		Integer old = o;
		--o; // --o.i
		return old;
	}
};
int main(void){
	Integer a(10);
	Integer b = -a;
	b.print();

	(++a).print();
	(--a).print();

	Integer c = a++;
	a.print();
	c.print();

	Integer d = a--;
	a.print();
	d.print();
	return 0;
}

实例：

Integer类以友元形式重载逻辑非运算符!

#include <iostream>
using namespace std;
class Integer{
private:
	int i ;
public:
	Integer(int m=0):i(m){}
	void print(void){
		cout << i << endl;
	}
	friend const Integer operator!(Integer& o){
		if(o.i <= 0)
		{
			return true;
		}
		return false;
	}
};
int main(void){
	Integer a(-1);
	Integer b = !a;
	b.print();
	return 0;
}

4.其他运算符重载

4.1 输入输出运算符重载

friend ostream& operato<<(ostream& os,const RIGHT& right){...}
	ostream, 标准库的类
	cout << a; //operator<<(cout,a)

friend istream& operato>>(istream& is,RIGHT& right){...}
	istream cin;//istream是标准库的类
	cin >> a;//operator>>(cin,a)

注：因为无法向标准库类添加成员函数，所以只能使用全局函数的形式

#include <iostream>
using namespace std;
class Complex{
	private:
		double r;
		double i;
	public:
		Complex(double r, double i){
			this->r = r;
			this->i = i;
		}
		const Complex operator+(const Complex& c){
			Complex tmp(r+c.r, i+c.i);
			return tmp;
		}
		Complex & operator+=(const Complex &c){
			r = r + c.r;
			i = i + c.i;
			return *this;
		}
		friend ostream& operator<<(ostream &os, const Complex& c){
			os << c.r << " + " << c.i << "i" << endl;
			return os; // cout << a << b << c << endl;
		}
		friend istream& operator>>(istream &is, Complex& c){
			is >> c.r >> c.i ;
			return is;
		}
		friend const Complex operator-(const Complex& l , const Complex& r);
		friend Complex & operator-=(Complex &L, const Complex &R);
};
const Complex operator-(const Complex& l, const Complex& r){
	Complex tmp(l.r - r.r, l.i - r.i);
	return tmp;
}
Complex & operator-=(Complex &L, const Complex &R){
	L.r -= R.r;
	L.i -= R.i;
	return L;
}
int main(void){
	Complex c1(2,3);
	cout << c1;
	Complex c2(0,0);
	cin >> c2;
	cout << c2;
	return 0;
}

4.2 new和delete运算符重载

通过new创建该类的对象时，将首先调用该操作符函数分配内存(可重载)，然后再调用该类的构造函数

通过delete销毁该类的对象时，将首先调用该类的析构函数，然后再调用该操作符函数释放内存（可重载）

#include <iostream>
#include <cstdlib>
using namespace std;
class A{
public:
	A(void){
		cout << "A construct" << endl;
	}
	~A(void){
		cout << "~A disconstruct" << endl;
	}
	void * operator new(size_t size){
		cout << "A new" << endl;
		return malloc(size);
	}
	void operator delete(void *p){
		cout << "A delete" << endl;
		free(p);
	}
};
int main(void){
	A *p = new A;
	delete p;
	return 0;
}

5.编程综合实例

实现一个3*3的矩阵类，支持如下操作符：

• 运算类双目操作符：+ - *

• 赋值类双目操作符：+= -= *=

• 单目操作符：-(相反数)

• 输出操作符：<<

注意：不是所有的操作符都能重载，下面操作符不能重载

::	 .	 ?:	 sizeof	 typeid