Day 4 C++

算术运算符重载

种类： + - * / %

#include <iostream>using namespace std;class Cacu
{friend const Cacu operator+(const Cacu &l,const Cacu &r);friend const Cacu operator-(const Cacu &l,const Cacu &r);friend const Cacu operator*(const Cacu &l,const Cacu &r);friend const Cacu operator/(const Cacu &l,const Cacu &r);
//   friend const Cacu operator%(const Cacu &l,const Cacu &r);
private:int a;int b;
public:Cacu(){}Cacu(int a,int b):a(a),b(b){}//成员函数实现+号运算重载
//    const Cacu operator+(const Cacu &r) const
//    {
//        Cacu temp;
//        temp.a=this->a+r.a;
//        temp.b=this->b+r.b;
//        return temp;
//    }//成员函数实现-号运算符重载
//    const Cacu operator-(const Cacu &r) const
//    {
//        Cacu temp;
//        temp.a=this->a-r.a;
//        temp.b=this->b-r.b;
//        return temp;
//    }//成员函数实现✖号运算符重载
//    const Cacu operator*(const Cacu &r) const
//    {
//        Cacu temp;
//        temp.a=a*r.a;
//        temp.b=b*r.b;
//        return temp;
//     }//成员函数实现/号运算符重载
//    const Cacu operator/(const Cacu &r) const
//    {
//        Cacu temp;
//        temp.a=a/r.a;
//        temp.b=b/r.b;
//        return temp;
//    }//成员函数实现%号运算符重载const Cacu operator%(const Cacu &r) const{Cacu temp;temp.a=a%r.a;temp.b=b%r.b;return temp;}void show(){cout << "a= " << a << endl;cout << "b= " << b << endl;}
};//全局变量函数实现+运算符重载
const Cacu operator+(const Cacu &l,const Cacu &r)
{Cacu temp;temp.a=l.a+r.a;temp.b=l.b+r.b;return temp;
}
//全局变量函数实现-运算符重载
const Cacu operator-(const Cacu &l,const Cacu &r)
{Cacu temp;temp.a=l.a-r.a;temp.b=l.b-r.b;return temp;
}
//全局变量函数实现*运算符重载
const Cacu operator*(const Cacu &l,const Cacu &r)
{Cacu temp;temp.a=l.a*r.a;temp.b=l.b*r.b;return temp;
}
//全局变量函数实现/号运算符重载
const Cacu operator/(const Cacu &l,const Cacu &r)
{Cacu temp;temp.a=l.a/r.a;temp.b=l.b/r.b;return temp;
}
//全局变量函数实现%号运算符重载
//const Cacu operator%(const Cacu &l,const Cacu &r)
//{
//    Cacu temp;
//    temp.a=l.a%r.a;
//    temp.b=l.b%l.b;
//    return temp;
//}
int main()
{Cacu s1(100,100);Cacu s2(10,10);Cacu s3=s1+s2;s3=s1-s2;s3=s1*s2;s3=s1/s2;s3=s1%s2;s3.show();return 0;
}

2 关系运算符重载

种类： > 、< == !=

#include <iostream>using namespace std;
class Rela
{friend bool operator>(const Rela &l,const Rela &r);friend bool operator<(const Rela &l,const Rela &r);friend bool operator==(const Rela &l,const Rela &r);friend bool operator!=(const Rela &l,const Rela &r);
private:int a;int b;
public:Rela(){}Rela(int a,int b):a(a),b(b){}//成员函数实现>号关系运算符重载
//    bool operator>(const Rela &r) const
//    {
//        if(a>r.a && b>r.b)
//        {
//            return true;
//          }
//        else
//        {
//            return false;//        }
//    }//成员函数实现<号关系运算重载
//    bool operator<(const Rela &r) const
//    {
//        if(a<r.a&&b<r.b)
//        {
//            return true;
//        }
//        else
//        {
//            return false;
//        }
//    }//成员变量实现=号关系运算符重载
//    bool operator==(const Rela &r) const
//    {
//        if(a==r.a && b==r.b )
//        {
//            return true;
//        }
//        else
//        {
//            return false;
//        }
//    }//成员变量实现！=号关系运算符
//    bool operator!=(const Rela &r) const
//    {
//        if(a==r.a && b==r.b)
//        {
//            return false;
//        }
//        else
//        {
//            return true;
//        }
//    }
};//全局变量函数实现>号关系运算符重载
bool operator>(const Rela &l,const Rela &r)
{if(l.a>r.a && l.b>r.b){return true;}else{return false;}
}
//全局变量<实现关系运算符重载
bool operator<(const Rela &l,const Rela &r)
{if(l.a<r.a &&l.b<r.b){return true;}else{return false;}
}
//全局变量实现==号关系运算符重载
bool operator==(const Rela &l,const Rela &r)
{if(l.a==r.a && l.b==l.b){return true;}else{return false;}}
//全局变量实现!=号关系运算符重载
bool operator!=(const Rela &l,const Rela &r)
{if(l.a!=r.a || l.b!=l.b){return true;}else{return false;}}
int main()
{Rela r1(1,7);Rela r2(1,9);if(r1>r2){cout << "r1>r2" << endl;}else if(r1<r2){cout << "r1<r2" << endl;}else if(r1==r2){cout << "r1==r2" << endl;}else if(r1!=r2){cout << "r1!=r2" << endl;}return 0;
}

3 赋值运算符重载

种类： = 、+= 、 -= 、*= 、/= 、%=

#include <iostream>using namespace std;
//实现赋值运算符重载
class Assi
{friend Assi operator+=(Assi &l,const Assi &r);friend Assi operator-=(Assi &l,const Assi &r);friend Assi operator*=(Assi &l,const Assi &r);friend Assi operator/=(Assi &l,const Assi &r);friend Assi operator%=(Assi &l,const Assi &r);//  friend Assi operator=(Assi &l,const Assi &r);
private:int a;int b;
public:Assi(){}Assi(int a,int b):a(a),b(b){}
//    //成员实现赋值+=运算符的重载
//    Assi operator+=(const Assi &r)
//    {
//        a+=r.a;
//        b+=r.b;
//      return *this;
//    }
//    //成员实现赋值-=运算符的重载
//    Assi operator-=(const Assi &r)
//    {
//        a-=r.a;
//        b-=r.b;
//      return *this;
//    }
//    //成员实现赋值=运算符的重载
//    Assi operator=(const Assi &r)
//    {
//        a=r.a;
//        b=r.b;
//      return *this;
//    }
//     //成员实现赋值*=运算符的重载
//    Assi operator*=(const Assi &r)
//    {
//        a*=r.a;
//        b*=r.b;
//      return *this;
//    }
//    //成员实现赋值/=运算符的重载
//    Assi operator/=(const Assi &r)
//    {
//        a/=r.a;
//        b/=r.b;
//      return *this;
//    }
//    //成员实现赋值%=运算符的重载
//    Assi operator%=(const Assi &r)
//    {
//        a%=r.a;
//        b%=r.b;
//      return *this;
//    }void show(){cout << "a= " << a << endl;cout << "b= " << b << endl;}
};
//全局函数实现赋值+=运算符的重载
Assi operator+=(Assi &l,const Assi &r)
{l.a+=r.a;l.b+=r.b;return l;
}
//全局函数实现赋值+=运算符的重载
Assi operator-=(Assi &l,const Assi &r)
{l.a-=r.a;l.b-=r.b;return l;
}//全局函数实现赋值*=运算符的重载
Assi operator*=(Assi &l,const Assi &r)
{l.a*=r.a;l.b*=r.b;return l;
}
//全局函数实现赋值/=运算符的重载
Assi operator/=(Assi &l,const Assi &r)
{l.a/=r.a;l.b/=r.b;return l;
}//全局函数实现赋值%=运算符的重载
Assi operator%=(Assi &l,const Assi &r)
{l.a%=r.a;l.b%=r.b;return l;
}//成员实现赋值=运算符的重载
//Assi operator=( Assi &l, const Assi &r)
//{
//    l.a=r.a;
//    l.b=r.b;
//  return l;
//}int main()
{Assi w1(10,12);Assi w2(8,8);w1+=w2;w1-=w2;w1=w2;w1*=w2;w1/=w2;w1%=w2;w1.show();return 0;
}