C++第六节之运算符重载（复数运算）

在C++中，运算符 + - * / 已有了规定，只能运算整数型，浮点型，其中+ - 在一定范围内可以对字符型进行运算，如果需要对复数，分数或者其他操作数作四则运算，就要对他们进行重新定义这就是运算符重载的含义
运算符重载是为了满足某种操作的需求，在原有运算符实现不了，又不增加新的运算符种类基础上，对相近意义上的运算符进行重载

大多数运算符都可以重载只有少数不可以 ，分别为：
.    成员访问运算符
.*   成员指针访问运算符
::   域运算符
sizeof   尺寸运算符
？:    条件运算符

运算符重载函数

两种形式：  成员函数形式
          <类型> operator <运算符> (< 参数表>)
          {      }
 一般来说，单目运算符采用成员函数重载时，参数表是无参数的，双目运算符重载时只有一个参数隐藏了一个参数，this指针，即指向该成员函数对象的指针
          友元函数形式
          friend <类型> operator <运算符> (< 参数表>)
          {      }
 一般来说，单目运算符采用友元函数重载时，参数表是有一个参数的，双目运算符重载时有两个参数，因为友元函数中没有this指针
        

#include <iostream>
using namespace std;
class complex
{
public:
	complex()
	{
		_real = 0.0;
		_imag = 0.0;
     }
	complex(double real)
	{
		_real = real;
		_imag = 0.0;
     }
	complex(double real, double imag)
	{
		_real = real;
		_imag = imag;
	}
	complex operator + (const complex& c);//运算符重载函数声明
	complex operator - (const complex& c);
	complex operator * (const complex& c);
	complex operator / (const complex& c);
	friend void print(const complex& c);//友元函数

private :
	double _real;
	double _imag;
};
inline complex complex::operator +(const complex& c)
{//  inline修饰成内联函数
            //complex R;
	        //R._real = _real + c._real;
	        //R._imag = _imag + c._imag;
	        //return R;
优化后：
    return complex(_real + c._real, _imag + c._imag);
}
inline complex complex::operator -(const complex& c)
{
	return complex(_real - c._real, _imag - c._imag);
}
inline complex complex::operator *(const complex& c)
{
	return complex(_real * c._real-_imag*c._imag, _real*c._imag + _imag*c._real);
}
inline complex complex::operator /(const complex& c)
{
	return complex((_real*c._real + _imag*c._imag)/(c._real*c._real+c._imag*c._imag),
		(_imag*c._real-_real*c._imag)/(c._real*c._real + c._imag*c._imag));
}
void print(const complex& c)
{
	if (c._imag < 0)
		cout << c._real << c._imag << "i";
	else
		cout << c._real <<"+"<< c._imag << "i";

}
void main()
{
	complex c1(2.0);
	complex c2(3.0, -1);
	complex c3 = c1 + c2;
	cout << "\n c1 + c2 = ";
	print(c3);
    c3 = c1 - c2;
	cout << "\n c1 - c2 = ";
	print(c3);
    c3 = c1 * c2;
	cout << "\n c1 * c2 = ";
	print(c3);
    c3 = c1 / c2;
	cout << "\n c1 / c2 = ";
	print(c3);

	cout << endl;
}

程序中c1+c2中加法为被重载后的复数加法运算 ，表达式可以理解为
c1.operator + (c2)//c1为第一操作数。c2为第二操作数

友元函数实现运算符重载

friend complex operator -(const complex& c1，const complex& c2)；//类内声明
  complex operator -(const complex& c1，const complex& c2)//类外定义
  {
  return complex(_real - c._real, _imag - c._imag);
  }
  
  程序中c1-c2中减法为被重载后的复数减运算 ，表达式可以理解为
     operator- (c1,c2)

一般来说，单目运算符重载常选用成员函数，双目运算符重载常选用友元函数

eg:
    1.0 + c1;    c1为类的对象
    成员函数理解为： 1.0.operator + （c1） 显然是错误的
    友元函数理解为：  operator +（complex(1.0) ，c1）