【c++】简单了解运算符重载

引例

class Integer{
public:
    Integer(int num):_num(num)
    {}
    int& getValue(){return _num;}
private:
    int _num;
};
1
2
3
4
5
6
7
8

现在有两个Integer对象a,b。想让a和b相加得到的结果给对象c，现在可以肯定的是c=a+b编译后肯定会报错

请注意这条信息no match for 'operator+' (operand types are 'Integer' and 'Integer')
现有的加法运算符无法对两个Integer对象进行操作，那么有什么方法可以让加法运算符可以对两个Integer对象进行操作？实现的方法就是运算符重载。

运算符重载

我们平常常见的算术运算符、逻辑运算符等运算符都是系统库函数里面已经存在的，所以运算符可以直接用于我们常用的数据类型。然而对于我们自定义的类实例化的对象，系统没有与之相关的运算符可以操作，但是为了使我们编写程序时更加便捷，C++提供了一种方式——运算符重载，来满足我们对于类对象进行的操作。

但是需要注意并不是所有的运算符都可以重载。

可以重载的运算符

• 算术运算符：+ - * / %
• 自增、自减运算符：++ –
• 位运算符：| & ~ ^ << >>
• 逻辑运算符：|| && !
• 关系运算符：== != < > <= >=
• 赋值运算符：= += -= /= %= &= |= ^= <<= >>=
• 单目运算符：+ - * &
• 动态内存分配：new delete new[] delete[]
• 其他运算符：() -> , []

不能重载的运算符

• . 成员访问运算符
• :: 域运算符
• .* ->* 成员指针访问运算符
• szieof 长度运算符
• ?: 条件运算符

运算符重载的语法形式

对于前面的Integer类，重载加法运算符

Integer operator +(Integer&other){
	return Integer(this->_num+other._num);
}
1
2
3

重载好了之后，c=a+b这个语句就不会报错了。

对于类的运算符重载的方式有3种

1. 重载为类的非静态成员函数
2. 重载为类的有元函数
3. 重载为普通函数

上面的那一种就是重载为类的非静态成员函数

重载为类的有元函数

Integer operator+(const Integer&left,const Integer&right){
	return Integer(left._num+right._num);
}
1
2
3

类的非静态成员函数方式重载的这个函数还是有点点问题的

Integer operator +(const Integer&other){
	return Integer(this->_num+other._num);
}
1
2
3

考虑这样的情况

const i1=Integer(1);
const i2=Integer(2);
auto i3=i1+i2
1
2
3

那么则个时候就会报错

其实这个错误很好理解，i1和i2都是常对象，常对象只能访问常成员，那i1就根本访问不了operator +()这个函数，当然会报错。改正的方法也很简单，operator +()加上一个const就可以了

Integer operator +(const Integer&other)const{
	return Integer(this->_num+other._num);
}
1
2
3

上面是在讨论对象+对象，除了这种情况是不是还会有 对象+数 数+对象
Integer count1=a+1 Integer count2=2+b

对于这种形式的Integer count1=a+1通过非静态成员函数进行重载就可以了

Intger operator+(int v)
{
	return Intger(this->number_ + v);
}
1
2
3
4

但是对于这个Integer count2=2+b，如果还通过非静态成员函数进行重载，那么就会出错

Integer operator+(int v,const Integer& right)
{
	return Integer(this->number_ + v);
}
1
2
3
4

因为加法运算符有左右两个操作数，那么重载加法运算符也要有两参数，声明为非静态成员函数，那么隐含的this指针算一个，那么函数的参数列表里写一个就可以了。上面那个加上隐含的this就三个参数了。解决的方法就是重载为类的有元函数

这篇文章就到这里了，希望你能对运算符重载有一个初步的了解。下面的代码是用到的例子

#include 
class Integer{
	friend Integer operator+(int v, const Integer& right);
public:
    Integer(int num):_num(num)
    {}
    int& getValue(){return _num;}
	Integer operator +(const Integer&other)const 
	{
		return Integer(this->_num+other._num);
	}
	//friend Integer operator+(const Integer&left,const Integer&right);
	Integer& operator =(const Integer&other){
		this->_num=other._num;
		return *this;
	}
	Integer operator+(int v)
	{
		return Integer(this->_num + v);
	}
	/* Integer operator+(int v,const Integer& right)
	{
	return Integer(this->number_ + v);
	} */
private:
    int _num;
};
/* Integer operator+(const Integer&left,const Integer&right){
	return Integer(left._num+right._num);
} */
Integer operator+(int v, const Integer& right)
{
	return Integer(right._num + v);
}
int main(){
    Integer a(1),b(2);
    Integer c=a+b;
	const Integer i1(1);
	const Integer i2(2);
	auto i3=i1+i2;
	Integer count1=a+1;
	Integer count2=2+b;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43

ger a(1),b(2);
Integer c=a+b;
const Integer i1(1);
const Integer i2(2);
auto i3=i1+i2;
Integer count1=a+1;
Integer count2=2+b;
}

1