Day 4 C++

news2024/9/21 22:28:11

算术运算符重载

种类： + - * / %

#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;
}