C++day4
1.算术运算符重载
#include
using namespace std;
//算术运算符
class Person
{
friend const Person operator+(const Person &L,const Person &R);
friend const Person operator-(const Person &L,const Person &R);
friend const Person operator*(const Person &L,const Person &R);
friend const Person operator/(const Person &L,const Person &R);
friend const Person operator%(const Person &L,const Person &R);
private:
int a;
int b;
public:
Person() {}
Person(int a,int b):a(a),b(b)
{}
void show();
//成员函数实现+运算符重载
// const Person operator+(const Person &p) const
// {
// Person temp;
// temp.a=a+p.a;
// temp.b=b+p.b;
// return temp ;
// }
//成员函数实现-运算符重载
// const Person operator-(const Person &p) const
// {
// Person temp;
// temp.a=a-p.a;
// temp.b=b-p.b;
// return temp ;
// }
//成员函数实现*运算符重载
// const Person operator*(const Person &p) const
// {
// Person temp;
// temp.a=a*p.a;
// temp.b=b*p.b;
// return temp ;
// }
//成员函数实现/运算符重载
// const Person operator/(const Person &p) const
// {
// Person temp;
// temp.a=a/p.a;
// temp.b=b/p.b;
// return temp ;
// }
//成员函数实现%运算符重载
// const Person operator%(const Person &p) const
// {
// Person temp;
// temp.a=a%p.a;
// temp.b=b%p.b;
// return temp ;
// }
};
//全局函数实现+运算符重载
const Person operator+(const Person &L,const Person &R)
{
Person temp;
temp.a=L.a+R.a;
temp.b=L.b+R.b;
return temp ;
}
//全局函数实现-运算符重载
const Person operator-(const Person &L,const Person &R)
{
Person temp;
temp.a=L.a-R.a;
temp.b=L.b-R.b;
return temp ;
}
//全局函数实现*运算符重载
const Person operator*(const Person &L,const Person &R)
{
Person temp;
temp.a=L.a*R.a;
temp.b=L.b*R.b;
return temp ;
}
//全局函数实现/运算符重载
const Person operator/(const Person &L,const Person &R)
{
Person temp;
temp.a=L.a/R.a;
temp.b=L.b/R.b;
return temp ;
}
//全局函数实现%运算符重载
const Person operator%(const Person &L,const Person &R)
{
Person temp;
temp.a=L.a%R.a;
temp.b=L.b%R.b;
return temp ;
}
void Person::show()
{
cout << "a= " << a << " b= " << b << endl;
}
int main()
{
Person p1(10,10);
Person p2(10,10);
Person p3=p1+p2;
p3.show();
Person p4=p1-p2;
p4.show();
Person p5=p1*p2;
p5.show();
Person p6=p1/p2;
p6.show();
Person p7=p1%p2;
p7.show();
return 0;
}
2.关系运算符重载
#include
using namespace std;
//关系运算符
class Person
{
friend bool operator>(const Person &L,const Person &R);
friend bool operator>=(const Person &L,const Person &R);
friend bool operator<(const Person &L,const Person &R);
friend bool operator<=(const Person &L,const Person &R);
friend bool operator!=(const Person &L,const Person &R);
friend bool operator==(const Person &L,const Person &R);
private:
int a;
int b;
public:
Person() {}
Person(int a,int b):a(a),b(b)
{}
void show();
//关系函数实现>运算符重载
// bool operator>(const Person &R) const
// {
// if(a>R.a && b>R.b)
// {
// return true;
// }
// else
// {
// return false;
// }
// }
//关系函数实现>=运算符重载
// bool operator>=(const Person &R) const
// {
// if(a>=R.a && b>=R.b)
// {
// return true;
// }
// else
// {
// return false;
// }
// }
//关系函数实现<运算符重载
// bool operator<(const Person &R) const
// {
// if(a运算符重载
bool operator>(const Person &L,const Person &R)
{
if(L.a>R.a && L.b>R.b)
{
return true;
}
else
{
return false;
}
}
//全局函数实现>=运算符重载
bool operator>=(const Person &L,const Person &R)
{
if(L.a>=R.a && L.b>=R.b)
{
return true;
}
else
{
return false;
}
}
//全局函数实现<运算符重载
bool operator<(const Person &L,const Person &R)
{
if(L.ap2)
{
cout << "p1>p2" << endl;
}
if(p1>=p2)
{
cout << "p1>=p2" << endl;
}
if(p2 3.赋值运算符重载
#include
using namespace std;
//赋值运算符
class Person
{
friend Person& operator+=(Person &L,const Person &R);
friend Person& operator-=(Person &L,const Person &R);
friend Person& operator*=(Person &L,const Person &R);
friend Person& operator/=(Person &L,const Person &R);
friend Person& operator%=(Person &L,const Person &R);
private:
int a;
int b;
public:
Person() {}
Person(int a,int b):a(a),b(b)
{}
void show();
//赋值函数实现+=运算符重载
// Person& operator+=(const Person &R)
// {
// a+=R.a;
// b+=R.b;
// return *this;
// }
// void show()
// {
// cout << "a= " << a << " b= " << b << endl;
// }
//赋值函数实现-=运算符重载
// Person& operator-=(const Person &R)
// {
// a-=R.a;
// b-=R.b;
// return *this;
// }
//赋值函数实*=运算符重载
// Person& operator*=(const Person &R)
// {
// a*=R.a;
// b*=R.b;
// return *this;
// }
//赋值函数实/=运算符重载
// Person& operator/=(const Person &R)
// {
// a/=R.a;
// b/=R.b;
// return *this;
// }
//赋值函数实%=运算符重载
// Person& operator%=(const Person &R)
// {
// a%=R.a;
// b%=R.b;
// return *this;
// }
//赋值函数实=运算符重载
Person& operator=(const Person &R)
{
a=R.a;
b=R.b;
return *this;
}
};
//全局函数实现+=运算符重载
Person& operator+=(Person &L,const Person &R)
{
L.a+=R.a;
L.b+=R.b;
return L;
}
//全局函数实现-=运算符重载
Person& operator-=(Person &L,const Person &R)
{
L.a-=R.a;
L.b-=R.b;
return L;
}
//全局函数实现*=运算符重载
Person& operator*=(Person &L,const Person &R)
{
L.a*=R.a;
L.b*=R.b;
return L;
}
//全局函数实现/=运算符重载
Person& operator/=(Person &L,const Person &R)
{
L.a/=R.a;
L.b/=R.b;
return L;
}
//全局函数实现%=运算符重载
Person& operator%=(Person &L,const Person &R)
{
L.a%=R.a;
L.b%=R.b;
return L;
}
void Person::show()
{
cout << "a= " << a << " b= " << b << endl;
}
int main()
{
Person p1(0,0);
Person p2(1,1);
p1+=p2;
p1.show();
Person p3(2,2);
Person p4(0,0);
p3-=p4;
p3.show();
Person p5(3,3);
Person p6(1,1);
p5*=p6;
p5.show();
Person p7(4,4);
Person p8(1,1);
p7/=p8;
p7.show();
Person p9(5,5);
Person p10(1,1);
p9/=p10;
p9.show();
Person p11(6,6);
Person p12(7,7);
p11%=p12;
p11.show();
p11=p12;
p11.show();
return 0;
}
思维导图：