C++运算符重载函数

运算符重载

C++为了增强代码的可读性, 让自定义类型可以直接使用运算符计算, 就需要运算符重载, 运算符重载是具有特殊函数名的函数，也具有其返回值类型，函数名字以及参数列表，其返回值类型与参数列表与普通的函数类似。

1. 定义:

• 函数名字为：关键字operator后面接需要重载的运算符符号。
• 函数原型：返回值类型 operator操作符(参数列表)

2. 注意：

• 自定义类型是不能直接使用运算符计算 基本类型可以
• 不能通过连接其他符号来创建新的操作符, 只能是语法支持的：比如operator@就不行,
• 重载操作符必须有一个类类型或者枚举类型的操作数, 不支持基本类型的运算符的修改: 比如两个整数的加法, 就不能重载运算符, 会出现错误
• 用于内置类型的操作符，其含义不能改变，例如：内置的整型+，不能改变其含义作为类成员的重载函数时，其形参看起来比操作数数目少1成员函数的
• 操作符有一个默认的形参this，限定为第一个形参
• .* 、:: 、sizeof 、?: 、. 注意以上5个运算符不能重载
• 不能修改内置类型, 至少有一个类类型或者枚举类型的非内置类型操作数

class A{
public:
	int _a;
	int _b;
};
void test(){
	A a1;
	A a2;
	A a3;
	a1._a = 1;
	a1._b = 2;

	a2._a = 3;
	a2._b = 4;
	
	a3 = a1 + a2;  // 这个是错的, 自定义类型是不能直接使用运算符计算, 但基本类型可以
}

初步实现运算符重载加法:

class A{
public:
	A(int a = 0){
		_a = a;
		_b = 0;
	}
	int _a;
	int _b;
};
// operator表示我要重载运算符啦, 后面跟的是啥 就是什么运算符重载
// 我们需要几个参数, 参数就写几个, 
// 我们这里定义的加法运算符重载函数是全局函数, 不属于类的成员函数, 但是也可以定义为类的成员函数
A operator+(A& a1, A& a2){ // a1 + a2 按参数声明的顺序去填充运算符的操作数的位置
	// return A(a1._a + a1._b + a2._a + a2._b);
	// 也可以写成下面这样:
	int a = a1._a + a1._b + a2._a + a2._b;
	A aobj(a);
	return aobj;
}
A add(A& a1, A& a2); // 也可以这样定义, 但是可读性也不高
void test(){
	A a1;
	A a2;
	A a3;
	
	a1._a = 1;
	a1._b = 2;
	a2._a = 3;
	a2._b = 4;
	// 下面这两个都走的是上面的加法运算符重载函数
	a3 = operator+(a1, a2); // 可读性不强
	a3 = a1 + a2;//在定义了运算符重载函数后就支持这样写了,像内置类型一样 且可读性高,
}

• 不支持基本类型的运算符的逻辑修改: 所以重载操作符必须有一个类类型或者枚举类型的操作数, 必须至少有一个自定义类型, 不能都是内置类型(基本类型)
• 参数传入的顺序按参数声明的顺序去填充运算符的操作数的位置

// 这是不支持的
int operator+(int a, int b)   // a + b 不能去修改基本类型的运算逻辑
{
	return a - b; // 里面却执行的是a - b,
}

我们上面定义的加法运算符重载函数是全局函数, 不属于类的成员函数, 但是也可以定义为类的成员函数,

• 在把运算符重载函数定义为普通函数时, 我们需要几个参数, 参数就写几个,
• 但把运算符的重载函数定义为类的成员函数时, 需要显式定义的参数个数要比操作符要求的个数少一个, 因为编译器会自动加入一个this指针作为第一个参数来占据成员函数参数列表的第一个位置, 我们只需要传剩余的一个参数

class A{
public:
	A(int a = 0){
		_a = a;
		_b = 0;
	}
	
	/* 下面这样写会报错, 导致运算符的参数太多, 
     由于当其变成成员函数后, 编译器会自动加一个this指针作为第一个参数, 所以现在相当于是由三个参数的, this指针, a, b
	A operator+(A& a1, A& a2){ 
		int a = a1._a + a1._b + a2._a + a2._b;
	*/
	A operator+(A& a1){// 底层是A operator+(A* this, A& a1)
		int a = _a + _b + a1._a + a1._b; // 相当于是int a = this->_a + this->_b + a1._a + a1._b
		A aobj(a);
		return aobj;
	}
	
	int _a;
	int _b;
};
void test(){
	A a1;
	A a2;
	A a3;
	
	a1._a = 1;
	a1._b = 2;
	a2._a = 3;
	a2._b = 4;
	
	// 在调用上述运算符重载成员函数时, 形式也变了
	a3 = a1.operator+(a2);
	a3 = a1 + a2;  // 等效于a1.operator+(a2);
}

• 还可以用来进行判等

: 比如判断两个日期是否相同, 最终返回我们判等的逻辑

// 这是一个普通函数的判等, 要是成员函数参数也会少一个, 也是由于第一个位置被我们的this指针占用了,
bool operator==(const Date& d1, const Date& d2) {
	return d1._year == d2._year;
	 && d1._month == d2._month
	 && d1._day == d2._day; 
}

//  这是作为成员函数的写法
bool operator==(const Date& d2) {
	 return _year == d2._year;
	 && _month == d2._month
	 && _day == d2._day;
 }
void test(){
	Date d1(2018, 9, 26);
	Date d2(2018, 9, 27);
	cout<<(d1 == d2)<<endl; 
}