c++ - programas - Haciendo que todos los operadores matemáticos de una estructura manipulen el mismo miembro.

operadores logicos c++ ejemplos

Question

Tengo una estructura que contiene una doble y varias banderas, pero me gustaría usarla en mi código como si fuera esa doble. ¿Hay alguna manera de simplificar el siguiente código para que todos los operadores matemáticos ejecutados en una instancia de esta estructura se ejecuten en el contenedor doble? Mi código se ejecuta pero sospecho que C ++ tiene una solución muy elegante y breve para mi problema.

struct SomeStruct
{
    double value;
    bool someFlag;
    bool someOtherFlag;

    operator double(){return value;}

    void operator=(double newValue){value = newValue;}
    void operator+=(double valueToAdd){value += valueToAdd;}
    void operator-=(double valueToSubtract){value-= valueToSubtract;}
    void operator/=(double divisor){value /= divisor;}
    void operator*=(double multiplier){value *= multiplier;}
    double operator+(double valueToAdd){return value + valueToAdd;}
    ...
}

Answer 1

Para convertir nuestra discusión en los comentarios en una respuesta ...

No creo que debas hacer esto en absoluto. Como mencionó en los comentarios, su estructura contiene información de una medición acústica, de modo que tiene tanto un valor como una bandera que indica si la medición de ruido sobrecargó al instrumento de grabación. Déjame simplificar tu estructura a esto:

struct Noise
{
  double noiseLevel;
  bool overload;
};

Ahora supongamos que agrega un operador de conversión para que obtenga la facilidad y comodidad que ofrece. Ahora tienes dos medidas de ruido quiet y loud . loud tiene la bandera de sobrecarga activada, mientras que quiet no. Ahora puede hacer estas dos operaciones que un lector debe esperar para producir un resultado igual:

loud += quiet;

y

quiet += loud;

pero como su adición no respeta la bandera, las dos operaciones producen valores diferentes. En el primero, el indicador de overload se establece mientras que en el segundo no lo está. Esto me parece un comportamiento altamente perturbador. Por lo tanto, le recomiendo que implemente sus propios operadores, que respetan el tipo, que conserven la bandera de overlaud manera natural, por ejemplo:

Noise& operator+=(Noise& lhs, const Noise& rhs)
{
  lhs.value += rhs.value;
  lhs.overload |= rhs.overload;
  return lhs;
}

De modo que el resultado de cualquier cálculo en el que un miembro tenga el conjunto de indicadores de sobrecarga también tiene el conjunto de indicadores de sobrecarga.

Answer 2

Si cambia el operador de conversión a operator double & , obtendrá todos los operadores en double gratis, con la excepción de operator= :

#include <iostream>

struct Foo {
    double d;
    bool flag;

    Foo() : d(0), flag(false) {}

    operator double &() { return d; }
};

int main()
{
    Foo x;  // initialized to (0, false)
    x.flag = true;
    x += 1.1;
    std::cout << x.d << " " << x.flag << std::endl;
    x *= 2;
    std::cout << x.d << " " << x.flag << std::endl;
}

huellas dactilares

1.1 1
2.2 1

(La segunda salida es la flag ).

Puede que valga la pena definir también el operator double() const .