C++：运算符重载

最新推荐文章于 2024-04-20 16:58:27 发布

原创最新推荐文章于 2024-04-20 16:58:27 发布 · 269 阅读

0 ·

CC 4.0 BY-SA版权

文章标签：

#C++

C++ 专栏收录该内容

3 篇文章

订阅专栏

运算符重载方法

定义格式：

函数类型 operator 运算符名称【形参列表】

#include<iostream>
using namespace std;
#include<string>
class Money
{
	public:
	Money(){};
	Money(int,int,int);
	Money operator+(Money &);//对+运算符重载
	void Display(string);
    private:
    	int yuan,jiao,fen;
    	void Optimize();   //优化函数 
 };
 void Money:: Optimize()
 {
 	if(fen>10)
	 {
	 	jiao++;
	 	fen=fen-10;
	 }
	 if(jiao>10)
	 {
	 	yuan++;
	 	jiao=jiao-10;
	 }
  } 
 Money::Money(int i,int j,int k)
  {
 	yuan=i;
 	jiao=j;
 	fen=k;
	 Optimize();
  } 
  Money Money::operator+(Money &c2)    //类外定义运算符重载函数 
  {
  	return Money(yuan+c2.yuan,jiao+c2.jiao,fen+c2.fen);
  }
  void Money::Display(string str)
  {
  	cout<<str<<"="<<yuan<<"."<<jiao<<fen<<endl;
  }
  int main()
  {
  	Money cost1(300,2,4),cost2(200,34,44),total1,total2;
  	total1=cost1+cost2;               //直接使用重载运算符 
  	total2=cost1.operator+(cost2);    //调用运算符重载函数 
  	total1.Display("total1=cost1+cost2");
  	total2.Display("total2=cost1+cost2");
  	return 0;
  }

运算符重载规则

1.只能对已有的运算符重载

2.不能被重载的运算符：“.”成员访问运算符

“.*”成员指针访问运算符

“：：”域运算符

“sizeof”长度运算符

“？：”条件运算符

3.重载运算符不能有默认的参数

运算符重载函数作为类的成员函数和友元函数

成员函数(有this指针)

#include<iostream>
using namespace std;
class Rational
{
	public:
	Rational(){}
	Rational(int i,int j)
	{
		nume=i;
		deno=j;
	}
	void print()
	{
		cout<<nume<<"/"<<deno<<endl;
	}	
	Rational operator*(Rational a);
	Rational operator/(Rational a);
	private:
		int nume,deno;
 };
 Rational Rational::operator*(Rational a)
 {
 	Rational r;
 	r.nume=a.nume*nume;
 	r.deno=a.deno*deno;
 	return r;
 }
  Rational Rational::operator/(Rational a)
 {
 	Rational r;
 	r.nume=a.nume*deno;
 	r.deno=a.deno*nume;
 	return r;
 }
 int main()
 {
 	Rational r1(1,3),r2(1,4),r3,r4;
 	r3=r1*r2;
 	r4=r1/r2;
 	r3.print();
 	r4.print();
 	return 0;
 }

友元函数（无this指针）

#include<iostream>
using namespace std;
class Rational
{
	public:
	Rational(){}
	Rational(int i,int j)
	{
		nume=i;
		deno=j;
	}
	void print()
	{
		cout<<nume<<"/"<<deno<<endl;
	}	
	friend Rational operator*(Rational a,Rational b);
	friend Rational operator/(Rational a,Rational b);
	private:
		int nume,deno;
 };
 Rational operator*(Rational a,Rational b)
 {
 	Rational r;
 	r.nume=a.nume*b.nume;
 	r.deno=a.deno*b.deno;
 	return r;
 }
  Rational operator/(Rational a,Rational b)
 {
 	Rational r;
 	r.nume=a.nume*b.deno;
 	r.deno=a.deno*b.nume;
 	return r;
 }
 int main()
 {
 	Rational r1(1,3),r2(1,4),r3,r4;
 	r3=r1*r2;
 	r4=r1/r2;
 	r3.print();
 	r4.print();
 	return 0;
 }

几种常用运算符重载

单目运算符++和--的重载

#include<iostream>
using namespace std;
class Point 
{
	public: 
	Point(){}
	Point(int vx,int vy)
	{
		x=vx;
		y=vy;
	}
	void display()
	{
		cout<<"<"<<x<<","<<y<<">"<<endl;	
	}
	Point &  operator++();    //前置自增 
	Point operator++(int);  //后置自增 
	friend Point & operator--(Point &p);  //前置自减 
	friend Point operator--(Point &p,int); //后置自减 
	private:
		int x,y;
 };
 Point &Point::operator++()   //前置自增 
 {
 	if(x<640)
 	x++;
 	if(y<480)
 	y++;
 	return *this;
 }
 Point Point::operator++(int) //后置自增 
 {
 	Point temp(*this);
 	if(x<640)
 	x++;
 	if(y<480)
 	y++;
 	return temp;
 }
 Point &operator--(Point &p)   //前置自减 
 {
 	if(p.x>0)
 	p.x--;
 	if(p.y>0)
 	p.y--;
 	return p;
 }
 Point operator--(Point &p,int)    //后置自减 
 {
 	Point temp(p);
 	if(p.x>0)
 	p.x--;
 	if(p.y>0)
 	p.y--;
 	return temp;
 }
 int main()
 {
 	Point p1(200,200),p2(300,300),p3(400,400),p4(50,50);
 	
	cout<<"p1=";  //测试前置自增 
	p1.display();
	++p1;
	cout<<"++p1=";
	p1.display();
	
	cout<<"p2=";    //测试前置自减 
	p2.display();
	++p2;
	cout<<"++p2=";
	p2.display();
	
	cout<<"p3=";   //测试后置自增 
	p3.display();
	p3++;
	cout<<"p3++=";
	p3.display();
	
	cout<<"p4=";    //测试后置自减 
	p4.display();
	p4--;
	cout<<"p4--";
	p4.display();
	
	return 0;
 }

赋值运算符解决指针悬挂问题（赋值运算符只能重载为成员函数，而且不能被继承）

流插入<<和流提取>>重载（必须重载为类的友元函数）

#include<iostream>
using namespace std;
class Timer
{
	public:
		Timer(){};
        Timer(int h,int m=0)
		{
		   hours=h;
		   minutes=m;	
		}		
		friend Timer operator+(Timer &t1,Timer &t2);
		friend Timer operator-(Timer &t1,Timer &t2);
		friend ostream & operator<<(ostream &out,Timer &t);
		friend istream & operator>>(istream &in,Timer &t);
    private:
    	int hours;
    	int minutes;
 };
Timer operator+(Timer &t1,Timer &t2)
{
	Timer sum;
	sum.minutes=t1.minutes+t2.minutes;
	sum.hours=t1.hours+t2.hours+sum.minutes/60;
	sum.minutes=sum.minutes%60;
	return sum;
 } 
 Timer operator-(Timer &t1,Timer &t2)
{
	Timer dif;
	int x1,x2;
	x1=t1.hours*60+t1.minutes;
	x2=t2.hours*60+t2.minutes;
	dif.minutes=(x1-x2)%60;
	dif.hours=(x1-x2)/60;
	return dif;
 }
 ostream & operator<<(ostream &out,Timer &t)  //out 引用cout对象 
 {
 	out<<t.hours<<"hours"<<t.minutes<<"minutes"<<endl;
 	return out;
  } 
  istream &operator>>(istream &in,Timer &t)
  {
  	cout<<"Input hours and minutes:";
  	in>>t.hours>>t.minutes;
  	return in;
  }
  int main()
{
	Timer t1,t2,t3,t4;
	cin>>t1>>t2;
	cout<<"t1="<<t1<<endl;
	cout<<"t2="<<t2<<endl;
	t3=t1+t2;
	cout<<"t3=t1+t2="<<t3<<endl;
	t4=t1-t2;
	cout<<"t4=t1-t2"<<t4<<endl;
	return 0;
}

成员函数有this指针，友元函数没有。

成员函数重载二目运算符只写一个在形参里。

所以函数如果重载二目运算符两个参数都写在形参列表里。