Operator overloading

+,- Operator overloading

You need to access private functions , It can be placed in a class , You can also use friend functions , take operator+ Treat as friend .

com com::operator+(com &obj)
{
    com t;
    t.m_a = obj.m_a + m_a;
    t.m_b = obj.m_b + m_b;
    return t;
}

Operator overload rule

1. Cannot overload ： Scope qualifiers （：：）, Ternary operator （？ ：）, comma （,）,（.*）,(sizeof)

2. Overloading cannot change priority and associativity

3. Its operand cannot be changed

4. Cannot have default parameters

  Reload step

1. Write the function name

2. Write formal parameters according to operands

3. Write out the return value type according to the usage scenario

4. Operator overloading cannot have default parameters , Otherwise, the operator operands will be changed

Overload output , Input operator

Need to overload outside the class , Because there is ostream And istream

#include <iostream>

using namespace std;

class com
{
    friend ostream& operator<<(ostream &out, const com &obj);
private:
    int m_a;
    int m_b;
public:
    com():m_a(1), m_b(2)
    {

    }
    com(int a, int b)
    {
        m_a = a;
        m_b = b;
    }
    void print()
    {
        cout << m_a << " + " << m_b << endl;
    }
    void print1()
    {
        cout << m_a << " - " << m_b << endl;
    }
    com operator++();
    com operator++(int);
    bool operator&&(com& b);
    com operator+(com &obj);
    com operator-(com &obj);
};
com com::operator-(com &obj)
{
    com t;
    t.m_a = m_a - obj.m_a;
    t.m_b = m_b - obj.m_b;
    return t;
}

com com::operator+(com &obj)
{
    com t;
    t.m_a = obj.m_a + m_a;
    t.m_b = obj.m_b + m_b;
    return t;
}
bool com::operator&&(com& b)
{   
    if(m_a == 0 && m_b == 0)
        return false;
    else
        if(b.m_a == 0 && b.m_b)
            return false;
        else
            return true;

}
com com::operator++()
{
    this->m_a++;
    this->m_b++;
    return *this;
}
com com::operator++(int)
{
    com t = *this;
    m_a++;
    m_b++;
    return t;
}
ostream& operator<<(ostream &out, const com &obj)
{
    out << obj.m_a << "  " << obj.m_b;
    return out;
}
int main(int argc, char *argv[])
{
    com c1(2,0);
    com c2(0,1);
    com c3(0,0);
    // c1++;
    // ++c1;
    // cout <<++c1<< endl;
    if(c3 && (c2.operator+(c1)))
    {
        cout << "ss" << endl;
    }
    else
    {
        cout << "frue" << endl;
    }
}

 

  Overloaded logical operators

Can overload , But the short circuit principle cannot be realized