gistfile1.cpp

#include <iostream>
using namespace std;

class Numero {
    int val;
    int soma;
public:
    Numero(int n = 0, int sum = 0) : val(n), soma(sum) {}
    ~Numero() {}
    // Cria um novo valor somado, mas com o campo soma nos dizendo
    // que valor foi adicionado para o operador() saber o valor original.
    Numero operator+(int n) {
        return Numero(val + n, n);
    }
    const bool operator==(const Numero& l) {
        // Pega o valor original de b XD
        Numero b = Numero(l)();

        if (this->val == b.val)
            return true;
        return false;
    }
    // retorna o valor original subtraindo a soma
    Numero operator()() {
        return Numero(val - soma);
    }
};

int main()
{
    Numero a = 2;
    // Quando o compilador avaliar a+3 o que acontecerá:
    //   O operador+ será chamado implicitamente e nele será retornado
    //   um novo objeto Numero com a adição, porém ele também guarda o valor
    //   que foi adicionado
    // Então quando o compilador chamar o operador== implicitamente para comparar:
    //   O valor de a ainda é o original, só o que retornou da adição é diferente,
    //   isso retornaria falso, no entando quando o operador== for chamado, ele
    //   criara outro objeto Numero e subtraira o número que foi somado anteriormente
    //   chamando o operador(). Logo temos dois números iguais, pois:
    //   a+n == a-n
    if (a == a + 3)
        cout << "1" << endl;
    if (a == a + 10)
        cout << "1" << endl;
    return 0;
}