#include <iostream>
 
using namespace std;
 
class Num 
{	
public:
    double a, b;
 
    /* Dentro del mismo objeto, o en el archivo de implementación
     * preparo una macro que contendrá el código al que solo deberé
     * pasarle el operador que quiero. Pero cuidado pues el operador
     * deberá ser compatible. Solo sirve para ahorrar código.
     */
 
    #define SET_OP(op)                                                 \
    Num operator op(const Num &p)                                      \
    {                                                                  \
        Num erg;                                                       \
        erg.a = a op p.a;                                              \
        erg.b = b op p.b;                                              \
        return erg;                                                    \
    }
 
    // Hora de usar la macro con cada uno de los operadores.
 
    SET_OP(+);
    SET_OP(-);
    SET_OP(*);
    SET_OP(/);
 
    /* Elimino el símbolo de la macro por si quiero usarla más
     * adelnate con otros operadores u otro tipo de dato.
     */
 
    #undef SET_OP
};
 
int main()
{
    Num num1;
	num1.a=1;
	num1.b=75;
 
    Num num2;
	num2.a=150;
	num2.b=175;
 
    Num num1und2 = num1 + num2;		// * Modificando acá el operador que cambie arriba la operación
 
   	cout << "num1und2 " << "a: " << num1und2.a << ", b: " << num1und2.b << endl;
 
    return 0;
}

#include <functional>
#include <iostream>
 
using namespace std;
 
// tu clase Num, con metodos adicionales para hacer mas corto el resto
class Num 
{	
public:
    double a, b;
    Num(double x, double y) : a(x), b(y) {}
    void show() { cout << a << ":" << b << endl; }
};
 
// la definicion del functor
struct Operador : public binary_function<Num,Num,Num> {
    virtual Num operator()(Num&n1, Num& n2) = 0;
};
 
// los operadores
struct Sumador : public Operador {
  Num operator() (Num& n1, Num& n2) {return Num(n1.a+n2.a,n1.b+n2.b);}
} sumador;
 
struct Multiplicador : public Operador {
  Num operator() (Num& n1, Num& n2) {return Num(n1.a*n2.a,n1.b*n2.b);}
} multiplicador;
 
// definir otros, si se quiere ...
 
// una funcion que aplica los operadores
Num apply_op(Num n1, Num n2, Operador& op) {
  return op(n1, n2);
}
 
int main() {
    Num num1(1,2), num2(3,4);
 
    apply_op(num1, num2, sumador).show();
    apply_op(num1, num2, multiplicador).show();
 
    // en vez de hacer .show(), como arriba, se puede asignar el resultado, si se quiere
    Num resultado = apply_op( num1, num2, sumador );
    resultado.show();
 
    return 0;
}