C++运算符重载

感觉得乱，看上面的目录就清对了 ^_^ ^_^ ^_^

知识点 1-运算符符重载该有返回值

1.重载操作符时至少要有一个对象参与，而且最好带返回值；
带返回值的好处就是，能实现表达式的连续运算，
比如下面的例子，如果重载函数无返回值则重载后运算符只能实现 a=123;
无法实现形如a=b=100这类赋值
代码如下如下：

例1-1 运算符重载无返回值

在这里插入代码片

#include<iostream>
using namespace std;
class CNum
{
public:
	int a;
public:
	CNum()
	{
		a=100;
	}
  void operator= (int num)
  {
	this->a=num;
  }
};
int main()
{
	CNum num1;
	num1=123; //理解为num1调用操作符，将123作为参数传进去
	cout<<num1.a<<endl	;
return 0;
}

此时num1,调用了重载的运算符，123作为参数传进了重载函数，实现了通过重载后的运算符对类对象的赋值。但主函数中如果如下则会出错：

int main()
{
CNum num1;
CNum num2;
num2=num1=123;//由于重载的“=”运算符无返回值，表达式没结果，所以出错。其中num1=123可以完成操作的
}

所以为了实现连续的操作做如下改动：

例1-2运算符重载有返回值

#include<iostream>
ing namespace std;
class CNum
{
public:
	int a;
public:
	CNum()
	{
		a=100;
	}	
  int operator= (int num)
  {
		this->a=num;
		return a;
  }
};
int main()
{
	CNum num1;
	CNum num2;
	num2=num1=666; //先执行num1=666,再执行num2=返回值（a）
	cout<<num1.a<<endl	;
 	cout<<num2.a<<endl	;
return 0;
}

当我们重载运算符是时，一定要合理适应返回值，这样能实现连续运算，连接其他符号：
比如：a+b+c;ab+cd/f …之类的

知识点2：双目运算符重载：

- 对象在左边：类内重载； - 对象在右边：类外重载（需要两个参数)； 因为全局函数不需要类对象，第一个参数符号左边的，第二个参数是符号右边的。

• 两边都有对象，考虑实际情况 ；

例2-1、对象在左边 ， 类内重载

实现 b=a+100;

#include<iostream>
using namespace std;
class CNum
{
public:
	int a;
public:
	CNum()
	{
		a=100;
	}
	int operator+(int num)
	{
		 return  this->a+num  ;
	}
  int operator= (int num)
  {
		this->a=num;
		return a;
  }

};
int main()
{
	CNum num1;
	CNum num2;
	num1=666;
	num2=num1+100;
	cout<<num1.a<<endl	;
 	cout<<num2.a<<endl	;
return 0;
}

运行结果如图：

例2-2、对象在右 ， 类外重载

实现b=100+a;

#include<iostream>
using namespace std;
class CNum//定义一个类
{
public:
	int a;
public:
	CNum()//构造器
	{
		a=100;
	}
	int operator+(int num)//重载+，有返回值
	{
		 return  this->a+num  ;
	}
  int operator= (int num)//对象在左，类内重载
  {
		this->a=num;
		return a;
  }
	
};	  
int operator +(int tem,CNum & num)//对象在右，类外重载
{
	 return tem+num.a;
}
int main()
{
	CNum num1;
	CNum num2;
	CNum num3;
	num1=666;
	
	num2=num1+100; 
	num3=100+num2;

	cout<<num1.a<<endl	;
 	cout<<num2.a<<endl	;
	cout<<num3.a<<endl	;
return 0;
}

运行结果如图：

例2-3 两边都有对象，考虑实际情况

实现：对 << 的重载
比如： cout << a
对象 << 对象
cout 是ostream类的对象；
a 是CNum类的对象；
考虑到，如果要是在类内重载，应该将代码写到ostream类中，显然这样很不好，所有毫不犹豫选择了，类外重载，代码如下；

#include<iostream>
using namespace std;
class CNum
{
public:
	int a;
public:
	CNum()
	{
		a=100;
	}
	int operator+(int num)
	{
		 return  this->a+num  ;
	}
  int operator= (int num)
  {
		this->a=num;
		return a;
  }
	
};	
 /*------------类外重载-----------*/
int operator +(int tem,CNum & num)
{
	 return tem+num.a;
}
//下面这个实现了    cout<<a;
//但是没实现    cout<<a<<endl;因为没有返回值继续传递
//void  operator <<(ostream & os,CNum &num)
//				//输出流只能引用
//{
//	  os<<num.a;
//	  
//
//} 
//
ostream &  operator <<(ostream & os,CNum &num)
	             
{
	os<<num.a;

	return os;
}
int main()
{
	CNum num1;
	CNum num2;
	CNum num3;
	num1=666;
	
	num2=num1+100; 
	num3=100+num2;
  //未重载前的输出
	cout<<num1.a<<endl	;
 	cout<<num2.a<<endl	;
	cout<<num3.a<<endl	;
//重载后的输出，注意有返回值，才能连续使用<< ，看代码
	cout<<num1<<endl	;
	cout<<num2<<endl	;
	cout<<num3<<endl	;
return 0;
}

输出如图所示：

知识点3-单目运算符重载

单目运算符重载，类内类外都可以

例3-1、实现对单目运算符++的重载 ：

a++；++a；

include<iostream>
using namespace std;
class CNum
{
public:
	int a;
	CNum()
	{
		a=100;
	}
//同一作用域有两个名字一样的函数，只能通过函数重载解决
public:
	int operator ++()  //  ++a
	{
		  a=a+1;
		  return a;
	}
	int operator ++(int tem)  //  ++a
	{
		tem =a;
		a=a+1;
		return tem;
	}
};
int main()
{
 	CNum num1;
	CNum num2;
	cout<<num1++<<endl;
 	cout<<++num2<<endl;
 
return 0;
}

输出结果如图：