作用:给运算符重新进行定义,赋予其另一种功能,以适应于不同的数据类型。
加号运算符重载“+”
对于内置的数据类型,编译器知道如何进行运算。例如int a=10, int b=20, c=a+b这种的。若有两个对象相加,那怎么办呢?可以用加号运算符重载。
两个自定义数据类型相加的运算需要进行重载。
例:两个对象的相加。
case 1:通过成员函数实现两个对象的相加
#include<iostream>
#include<string>
using namespace std;
class Person
{
public:
Person PersonAddPerson(Person& p)
{
Person temp;
temp.m_A = this->m_A + p.m_A;
temp.m_B = this->m_B + p.m_B;
return temp;
}
int m_A;
int m_B;
};
int main()
{
Person p1;
p1.m_A = 10;
p1.m_B = 10;
Person p2;
p2.m_A = 20;
p2.m_B = 20;
p2.PersonAddPerson(p1);
cout << p2.m_A << endl;
cout << p2.m_B << endl;
}
case 2:成员函数重载+号运算符
成员函数重载本质的调用
Person p3=p1.operator+(p2);
#include<iostream>
#include<string>
using namespace std;
class Person
{
public:
//通过成员函数重载加号运算符
Person operator+ (Person& p)
{
Person temp;
temp.m_A = this->m_A + p.m_A;
temp.m_B = this->m_B + p.m_B;
return temp;
}
int m_A;
int m_B;
};
int main()
{
Person p1;
p1.m_A = 10;
p1.m_B = 10;
Person p2;
p2.m_A = 20;
p2.m_B = 20;
Person p3 = p1 + p2;
//等价于Person p3=p1.operator+(p2);
}
case 3:全局函数重载+
全局函数重载的本质调用:Person p3=operator+(p1,p2);
#include<iostream>
#include<string>
using namespace std;
class Person
{
public:
int m_A;
int m_B;
};
//通过全局函数重载加号运算符
Person operator+ (Person& p1,Person& p2)
{
Person temp;
temp.m_A = p1.m_A + p2.m_A;
temp.m_B = p1.m_B + p2.m_B;
return temp;
}
int main()
{
Person p1;
p1.m_A = 10;
p1.m_B = 10;
Person p2;
p2.m_A = 20;
p2.m_B = 20;
Person p3 = p1 + p2;
}
对于内置的数据类型的表达式的运算符是不可以改变的,且不要滥用运算符重载。
左移运算符重载“<<”
作用:配合友元,可以输出自定义的输出类型。
#include<iostream>
#include<vector>
using namespace std;
class Person {
public:
friend ostream& operator<< (ostream& cout, Person& p);
Person(int a, int b)
{
m_A = a;
m_B = b;
}
private:
int m_A;
int m_B;
};
//利用全局函数重载左移运算符
ostream& operator<< (ostream& cout, Person &p)
{
//cout对象只能有一个,因此传个引用
cout << p.m_A << p.m_B;
return cout;
}
void test01()
{
Person p(10,10);
cout<<p<<endl;//第2个<<是链式编程,因此第一次重载时需要返回cout的值
}
int main()
{
test01();
}
递增运算符重载“++”
作用:通过递增运算符,实现自己的整形数据。具体地,包括前置递增和后置递增。后置递增返回值,前置递增返回引用。
#include<iostream>
using namespace std;
//重载递增运算符
//自定义整形
class MyInteger
{
public:
MyInteger()
{
n_Num = 10;
}
friend ostream& operator<< (ostream& cout, MyInteger& myint);
//重载++运算符(前置)
MyInteger& operator++ ()
{
//先进行++运算。再返回自己的引用,返回引用是为了一直对一个数据进行递增操作
n_Num++;
return *this;
}
//重载++运算符(后置)
MyInteger operator++ (int) //int的作用是代表占位参数,可以用于区分前置和后置递增
{
//先记录当时的结果
MyInteger temp = *this;
//后递增
n_Num++;
//最后将记录结果返回,由于返回的是局部变量,因此不能返回引用
return temp;
}
private:
int n_Num;
};
ostream& operator<< (ostream& cout, MyInteger& myint)
{
cout << myint.n_Num;
return cout;
}
void test01()
{
MyInteger myint;
cout << ++(++myint)<< endl;
}
void test02()
{
MyInteger myint;
cout << (myint++) << endl;
}
int main()
{
test02();
}