c++运算符重载

什么是运算符重载？

• 赋予运算符具有操作自定义类型数据的功能

• 运算符是操作基本数据类型的，对于自定义类型不能直接操作对象--->自定义类型数据是复合类型的数据，由多个部分组成--->需要引入运算符重载

运算符重载的目的

• 赋予运算符能够操作自定义类型的数据

运算符重载的实质

• 实质就是函数调用，运算符重载函数的写法&函数组成是怎样的？

• 函数返回值类型：运算符运算完成后的值

• 函数返回值  函数名(函数参数)

函数返回值类型

由运算符运算完成后的值决定的 Complex

举一个复数的例子：复数由实部、虚部组成

+运算符重载函数的返回值应该是Complex类型：three=one+two，两个对象相加后赋给另一个对象--->表达式加完之后返回值应该是一个类的对象类型

函数名

operator + 重载运算符组成函数名 operator+      

参数个数

看运算符的操作数，实现加法：左边是什么类型？右边是什么类型？具体参数个数要看你重载函数的形式是怎么样的 (Complex one, Complex two)

重载函数的形式

• 友元函数重载运算符   （参数个数==操作数）

• 类成员函数重载运算符（参数个数==操作数-1）

class Complex 
{
public:
	Complex(int a=0, int b=0):a(a),b(b){}    //缺省处理
	void print() 
	{
		cout << a << endl;
		cout << b << endl;
	}
protected:
	int a;
	int b;
};

int main() 
{
	Complex one(1, 1);
	Complex two(2, 0);
    Complex three;
    three=one+two;    //报错:未重载
    return 0;
}

友元函数重载运算符（参数个数==操作数）

把重载函数写成友元函数

friend Complex  operator+ (Complex one, Complex two);
/*    返回值类型  函数名    函数参数(两个对象相加)   */    

加法需要两个Complex对象相加，直接把这两个类型当做函数参数，重载后，可以直接把这两个对象当做函数参数相加

小知识：

函数体中写什么？

写运算符具体想要实现的操作  加法想要实现两个对象的相加：a+a，b+b

class Complex 
{
public:
	Complex(int a=0, int b=0):a(a),b(b){}                //缺省处理
	void print() 
	{
		cout << a << endl;
		cout << b << endl;
	}
	friend Complex  operator+ (Complex one, Complex two);//类中声明
protected:
	int a;
	int b;
};

//友元重载: 参数个数==操作数                              //类外实现
//通过构造函数创建无名对象,返回新对象的a和b
Complex  operator+ (Complex one, Complex two)
{
	return Complex(one.a+two.a,one.b+two.b);            //构建无名对象返回
}

int main() 
{
	Complex one(1, 1);
	Complex two(2, 0);
	Complex three;
    //隐式调用
	three = one + two;                                 //重载函数隐式调用
	three.print();        
	//显式调用
	Complex result;
	result = operator+(one, two);                     //显示调用和普通函数方式一样
    result.print();
	return 0;
}
/*输出*/

3
1
3
1 

对（运算符重载+）显式调用方式的理解：

        显示调用就是一个函数调用的过程

对（运算符重载+）隐式调用方式的理解：

        运算符重载函数就是函数，只是说多了一种隐式调用而已，对于  three = one + two；  编译器会将其翻译为   three= operator+(one， two)；的调用形式，再调用函数operator+ (Complex one, Complex two)  --->存在隐式调用的原因：为了写起来简单，本质没变

类成员函数方式重载运算符（参数个数==操作数-1）

举一个比较大小的例子：类成员函数重载和普通成员函数写法一样：函数返回值 函数名(函数参数)

if (one > two)	
{
	cout << "one 比较大" << endl;	
}

one > two：两个类不能做比较，做重载的表达式最终想要得到的结果是布尔类型（或者也可以返回int类型）

小知识：
为什么会少一个参数？通过对象调用成员函数（对象可以表示一个参数），参数应该少一个

//显示调用
if (one.operator>(two)) 
{
		cout << "one比较大" << endl;
}

class Complex 
{
public:
	Complex(int a=0, int b=0) :a(a), b(b) {}
	void print() 
	{
		cout << a << endl;
		cout << b << endl;
	}
	//类成员函数重载： 参数个数==操作数-1
	bool operator> (Complex  object) 
	{
		if (this->a > object.a) 
		{
			return true;
		}                                              //相等也是不成立-->大于||不大于
		else if (this->a==object.a && this->b > object.b)
		{                                              //如果a相等,比较b
			return true;
		}
		else 
		{
			return false;    //其他情况返回false
		}
	}
protected:
	int a;
	int b;
};

int main() 
{
    Complex one(1, 1);
	Complex two(2, 0);
//隐式调用
	if (one > two)	        //one > two  是bool类型
	{
		cout << "one 比较大" << endl;
	}
	return 0;
}