C++中的运算符重载

C++中的运算符重载

运算符(±*/ = == > < )重载
函数重载 ,一个函数名可以实现很多个 功能

  1.友元函数:
  	一个类,和很多个重载函数,  不方便 

​
2.类内重载

  						   age=  cat.setage(9)
  a =     b + c; --->    a  =    b.+  ( c  );    +函数是类内部的一个成员
  						   a  =    b.add( c )  -->  去该类中(b所在的类)找 函数 +(c类型)
  	
  	特点:发现类内实现运算符重载,少一个参数

  	//complex xiaohua;   xiaohua.setname("xiaohua");
  	
  	class complex {
  	public:
  		complex add(complex &c) 
  		{
  			complex r;
  			
  			r.shi = c.shi + this->shi;  //b本身使用this指针获取
  			r.xu=  c.xu+xu;
  		
  			return r;
  		}
  //void set_name(string name){this->name=name;}
  	private:
  		//string name;
  		int shi,xu;
  	};

  	complex c,b,a;

  	c=a+b;	--->  c=a.+   (b)  -->编译器去对象a中寻找 complex +(complex)这个函数
  		c=a+5;	--->  c=a.operator+( 5) -->  complex operator+(int)
  		
  			运算符本质上也是一个函数:
  	a = 5+6; ---->  a= + (5,6)  	  --> int +(int,int)
  	cat1=cat2+cat3; cat1= +(cat,cat) ---> cat  + (cat,cat)

​

类内重载

#include<iostream>
using namespace std;

class complex{
public:
	complex(){shi=xu=0;}
	complex(int xshi,int xxu):shi(xshi),xu(xxu) {}
	
	complex operator+( complex & b)
	{
		complex r;
		r.shi=this->shi+b.shi;
		r.xu=this->xu+b.xu;
		return r;
	}
	
	complex operator+(int m)
	{
		complex r;
		r.shi=shi+m;
		r.xu=xu;
		return r;
	}
	
	int operator==(complex &b)
	{
		if( (shi==b.shi ) && (xu==b.xu ) ){
			return 1;
		}else {
			return 0;
		}
		return 0;
	}
	
	void show(){cout<<shi<<"+"<<xu<<"i"<<endl;}
private:	
	int shi,xu;

};


int main()
{
	complex c;
	complex a(2,3);
	complex b(5,6);
	
	c=a+b;	// c = a.operator+ ( b )  -->去对象a中寻找   complex operator+( complex & b)
	c.show();
	
	c=c+3;  // c = c.operator(3)     ---> 去对象c中寻找  complex operator+(int )
	c.show();
	
	
	/*
		 a = ( c==6 )  ---> a=   c.==(6)  
	
	*/
	int x =  a==b ;   // x = a.operator== (b)   --> int operator==(complex &b)
	cout<<"a==b ?"<<x<<endl;
}

友元函数重载

首先介绍一下友元函数

#include<iostream>
using namespace std;

class cat{
public:

	cat(string name,int age,string xsex):sex(xsex)
	{
		this->name=name; this->age=age;
	}

	string set_name(string name) {this->name=name;}
	string get_sex() {return sex;}

private:
	friend void feed_cat( cat &mao);   //声明该函数为友元函数, 
	friend class feeder;				//声明该类为友元类,那么该类可以访问private

	int age;
	string name;
	const string sex;	
	
};

class feeder {
public:
	void care_about(cat &mao)		//原则上不可以的,因为这是类外访问 类private成员
	{
		cout<<"mao name="<<mao.name<<" age="<<mao.age<<" sex="<<mao.sex<<endl;
	}
	
private:
	string name;
};

/*
1.友元函数
	正常情况下, 类外不允许访问 类对象的私有成员
	但是: 朋友函数(友元函数可以)

	需要在类中声明 该函数为 友元函数.
		友元函数只会用在一个地方: 运算符重载
		
2.友元类
	一个类A去访问   另一个类B的私有成员,属于类外访问,不被允许的
	但是 如果类A是类B的朋友类( 友元类),那么可以的
		类B要声明 A是 友元类;

友元破坏了 类的安全性,不建议使用
	只会用在一个地方,运算符重载

*/

void feed_cat( cat &mao)
{
	cout<<"sex="<<mao.get_sex()<<endl;;
	 //类外访问,是不允许的
	cout<<"mao name="<<mao.name<<" age="<<mao.age<<" sex="<<mao.sex<<endl;
}

int main()
{
	cat xiaohua("xiaohua",2,"man");
	feed_cat(xiaohua);
	
	
	feeder xiaowang;
	xiaowang.care_about(xiaohua);
	
}

友元函数的构造不太好用，暂时就不多做介绍了