在C++里面所有的运算符号，如+、-、*、/、<<等等都是可以通过函数赋予其不同的功能的，而这种函数赋予的功能可以通过运算符号直接使用，这就是运算符重载

+运算符重载

class Car
{
public:
int a;
int b;
//成员函数进行运算符重载
Car operator+(const &c)
{
Car temp;
temp.a =this->a + c.a;
temp.b =this->b + c.b;
return temp;
}
};

Car c1;
c1.a=1;
c1.b=2;

Car c2;
c2.a=1;
c2.b=2;
//c3属性等于c1和c2对象属性相加
Car c3=c1+c2;
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

当然，全局函数的运算符重载也很好用

//注意加法可以没有先后顺序，但是像右移运算符这些不可以没有顺序，c1在前，c2在后
Car operator+(const &c1，const &c2)
{
Car temp;
temp.a =c1.a + c2.a;
temp.b =c1.b + c2.b;
return temp;
}
1
2
3
4
5
6
7
8

左移运算符重载<<

//左移运算符重载————全局函数的重载
//调用时应该是cout<<c;但是顺序不能反过来，不可以c<<cout,这是不对的
ostream & operator<<(ostream &out,Car &c)//引用只是别名，随便写，重点是使用运算符的时候是把ostream类型的cout这个输出用的对象传进来
{
out<<"a=\t"<<c.a<<"b=\t"<<c.b<<endl;
return out;
}

//左移运算符重载————成员函数的重载
//这种方法不合适，因为这种方法调用运算符时代码是这样：c1<<cout;输出用的cout竟然跑到后面去了，那肯定不行，
//所以用全局函数的时候可以改变顺序
ostream & operator<<(ostream &out)
{
out<<"a=\t"<<c.a<<"b=\t"<<c.b<<endl;
return out;
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

递增运算符重载++

++符号有前置和后置

class Integer
{
public:
Integer(){num=0;}
//类似++i的实现，先加1，再返回当前对象可以用链式操作如
//Integer i;++(++i);
Integer& operator++()
{
num++;
return *this;
}
//类似与i++的实现，由于两个函数本来都没有形参，无法形成函数重载的条件
//所以使用占位运算符int来区别不同的函数，有int代表的是后置运算符，但是这种后置的返回不是当前对象，所以无法链式操作，如(i++)++是不行的
Integer operator(int)
{
Integer temp=*this;
num++;
return temp;
}
private:
int num;
};
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

赋值运算符重载

class Car
{
public:
Car(int num)
{
num = new int(num);
}
Car& operator=(Car &c)
{
if(num != NULL)
{
delete num;
num = NULL;
}
//深拷贝，重新为本对象开辟堆内存
num = new int(*c.num);
//返回本对象
return *this;
}
int* num;
};
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

关系运算符重载

关系运算符有==、！=、<、>、>=、<=等等

class Car
{
public:
int num;
string name;
};
bool operator==(Car& c)
{
if(this->num==c.num && this.name==c.name)
{
return true;
}
return false;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14

函数调用运算符重载

函数调用运算符就是（）,运算符重载后调用方法和函数相似，称为仿函数

class Car
{
public:
int num;
int operator()(int num1,int num2)
{
return num1+num2;
}
};

Car c;
cout<<c(1,2);//输出结果为3
//仿函数和真正的函数不同的是，仿函数是通过类来调用的，小括号前面是类对象名称，而函数的小括号前面是函数名称
1
2
3
4
5
6
7
8
9
10
11
12
13