运算符的重载
- 类重载
- 友元重载
下边我将用结构体和类两种方式来展示他们各自的重载方式。其中结构体只有一种重载方式相当于类中的友元重载，而类中分为类重载和友元重载
一、结构体里面的运算符重载方式:(用到了+和<<的运算符重载)
#include <iostream>
using namespace std;
struct score
{
score(int math):math(math){}
score(int math=0,int english=0):math(math),english(english){}
//这里用了两个构造函数，只是为了说明，结构体里构造函数的个数也是可以不止一个的，第二个构造函数用到了缺省的方式，目的是为后边创造一个默认对象做准备(意思就是可以直接score C).
void print()//方便打印
{
cout << math << "\t" << english;
}
int math;
int english;
void test(); //这里只是为了演示，如果在结构体外写内容，需要 类型+ 结构体名::函数名。
};
//结构体函数在类外实现
void score::test()
{
}
//这里我们演示一下重载加法的方式：
score operator+(score A, score B)
{
score C;
C.math = A.math + B.math;
C.english = A.english + B.english;
return C;
}
//重载<<
ostream& operator<<(ostream& out, score C)
{
out << C.math << "\t" << C.english;
return out;
}
//说明一下，结构体的重载不能定义在结构体中，需要在外边说明，不能在结构体内定义。￥￥￥重点细节。
int main()
{
score num1(90, 98);
score num2(30, 60);
cout << num1 + num2;
//通过这一个cout<<就完美展示了+和<<的运算符重载效果。
//那么我们在用结构体自身函数试一下。
score num3=num1+num2;
cout<<num3.print();//这样打印出来的效果一样的。
system("pause");
return 0;
}
二、友元重载和类重载的区别
先简单说明一下，在类中，友元重载和类重载的区别，我们就以加法为例
若我们需要将两个类对象相加，还是用代码说明吧！
#include <iostream>
#include <string>
using namespace std;
class score
{
public:
score(int math, int english) :math(math), english(english) {}
//友元重载 比较常用
friend score operator+(score num1, score num2)
{
//参数个数为运算符数目。
score result(num1.math + num2.math, num1.english + num2.english);
return result;
}
//类重载
/*score operator+(score num2)
{
score result(this->math + num2.math,this->english + num2.english);
return result;
}*/
void Print()
{
cout << math << "\t" << english;
}
int math;
int english;
};
int main()
{
score num1(1, 2);
score num2(2, 3);
score num3 = num1 + num2;
num3.Print();
// $$$$$$$$$$$$$重点$$$$$$$$$$$$$
//如果我们要将num1,num2相加。num1+num2;
//友元重载中：friend score operator+(score num1,score num2)这两个数都是作为参数存在的。翻译过程是将两个参数的值相加。
//而在类重载中：score operator+(score num2)
//翻译过程是 num1.operator(num2);
system("pause");
return 0;
}
类中友元重载以及重载的封装方式：用的+和<<来进行演示
#include <iostream>
#include <string>
using namespace std;
class MM
{
public:
MM(string name="", int age=0) :name(name), age(age) {}
//用友元方式进行重载：
friend MM operator+(MM a, MM b)
{
MM c;
c.name = a.name + b.name;
c.age = a.age + b.age;
//MM c(a.name+b.name,a.age+b.age);
//这句话可以替代上边三句话。
return c;
}
friend ostream& operator<<(ostream& out, MM mm)
{
out << mm.age << "\t" << mm.name;
return out;
}
//采用封装的方式来实现一下。
//void add(MM a, MM b)
//{
// this->name = a.name + b.name;
// this->age = a.age + b.age;
//}
//friend MM operator+(MM a, MM b)
//{
// MM c;
// c.add(a, b);
// return c;
//}
//void output(ostream& out)
//{
// out << this->age << "\t" <<this->name;
//}
//friend ostream& operator<<(ostream & out, MM gg)
//{
// gg.output(out); //将功能封装给对象，
// return out;
//}
protected:
string name;
int age;
};
int main()
{
MM mm("wang",10);
MM gg("jiang",20);
MM h = mm + gg;
cout << mm+gg;
system("pause");
return 0;
}
接着说明一个比较常用的++运算符的重载
++分为了前置++和后置++，那么他们的区别是什么呢？
#include <iostream>
using namespace std;
class MM
{
public:
MM(int age=0) :age(age) {}
MM operator++() //前置++
{
MM jt = ++this->age;//前后置本质区别。
cout << "前置" << endl;
return jt;
}
MM operator++(int)//后置++ (int)只是作为标识符。
{
MM jt = this->age++;//前后置本质区别。
cout << "后置" << endl;
return jt;
}
int& getAge()
{
return this->age;
}
protected:
int age;
};
int main()
{
MM mm(3);
MM gg(0);
gg=mm++;//这句话的本质是，gg得到的值是mm原来的值，后mm+1；
cout << gg.getAge(); //结果是3
cout << mm.getAge();//结果是4；
system("pause");
return 0;
}