C++: Usando operador de dos tipos intrínsecos como objeto de función

Question

Tengo una clase similar a un vector que contiene una matriz de objetos de tipo "T", y quiero implementar 4 operadores aritméticos, que aplicarán la operación en cada elemento:

// Constructors and other functions are omitted for brevity. 
template<class T, unsigned int D> 
class Vector { 

public: 
    // Add a value to each item: naive implementation. 
    void operator += (const T&) { 
     for (int i = 0; i < D; ++i) { 
      data[i] += value; 
     } 
    } 
    void operator -= (const T&) { ... } 
    void operator *= (const T&) { ... } 
    void operator /= (const T&) { ... } 

private: 
    T items[D]; 
}; 

Debido a que los operadores contendrán el mismo código repetitivo (bucle sobre cada elemento y la aplicación de la operación apropiada), pensé que podía generalizar:

template<class T, unsigned int D> 
class Vector { 

public: 
    void operator += (const T& value) { do_for_each(???, value); } 
    void operator -= (const T& value) { do_for_each(???, value); } 
    void operator *= (const T& value) { do_for_each(???, value); } 
    void operator /= (const T& value) { do_for_each(???, value); } 

private: 
    void 
    do_for_each(std::binary_function<void, T, T>& op, T value) { 
     std::for_each(data, data + D, std::bind2nd(op, value)); 
    } 

    T data[D]; 
}; 

Ahora, el problema es, ¿cómo puedo pasar un operador que toma dos intrincaciones ic tipos y devuelve void a do_for_each, como se muestra en el ejemplo anterior? C++ no me deja hacer este truco para tipos intrínsecos ("T::operator+=" no funcionará si "T" es "int").

Answer 1

Primero, realmente debe devolver una referencia de su operador + =, ya que luego puede usarlos para implementar operator +, operator-, etc. Voy a cambiar eso en consecuencia.

Además, tu do_for_each tiene que ser una plantilla, ya que debe conocer el tipo exacto del objeto de función, ya que los objetos de función binaria no son clases polimórficas. Para la operación real, que desea utilizar std::transform:

template<class T, unsigned int D> 
class Vector { 

public: 
    Vector& operator += (const T& value) { 
     do_for_each(std::plus<T>(), value); 
     return *this; 
    } 

    Vector& operator -= (const T& value) { 
     do_for_each(std::minus<T>(), value); 
     return *this; 
    } 

    Vector& operator *= (const T& value) { 
     do_for_each(std::multiplies<T>(), value); 
     return *this; 
    } 

    Vector& operator /= (const T& value) { 
     do_for_each(std::divides<T>(), value); 
     return *this; 
    } 

private: 
    template<typename BinFun> 
    void do_for_each(BinFun op, const T& value) { 
     std::transform(data, data + D, data, std::bind2nd(op, value)); 
    } 

    T data[D]; 
}; 

std::transform se acaba de pasar cada elemento al objeto de función, y asigna el resultado de vuelta al iterador dado como el tercer argumento.

Answer 2

Debería echarle un vistazo a Boost Operators, una biblioteca de solo encabezado que realmente simplifica la creación de sobrecargas de operador aritmético ortogonal y consistente.

Específicamente: puede encontrar que derivar de boost::operators::integer_arithmatic<T> le ahorra mucha repetición de esta clase.

Answer 3

Creo que litb está en la pista correcta y respondió la pregunta exacta.
Pero creo que esta es la solución incorrecta.

yo preferiría no utilizar el do_for_each(), sino más bien utilizar el std :: transformo() directamente:

template<class T, unsigned int D> 
class Vector 
{ 

    public: 
    Vector& operator += (const T& value) { 
     std::transform(data, data + D, data, std::bind2nd(std::plus<T>(),value)); 
     return *this; 
    } 

    Vector& operator -= (const T& value) { 
     std::transform(data, data + D, data, std::bind2nd(std::minus<T>(),value)); 
     return *this; 
    } 

    Vector& operator *= (const T& value) { 
     std::transform(data, data + D, data, std::bind2nd(std::multiplies<T>(),value)); 
     return *this; 
    } 

    Vector& operator /= (const T& value) { 
     std::transform(data, data + D, data, std::bind2nd(std::divides<T>(),value)); 
     return *this; 
    } 

    private: 
    T data[D]; 
};