overload - operator[] c++

Operador pasajero como parámetro

Question

Quiero tener una función que evalúe 2 bool vars (como una tabla de verdad)

por ejemplo:

ya que

T | F: T

entonces

myfunc(''t'', ''f'', ||);  /*defined as: bool myfunc(char lv, char rv, ????)*/

debe devolver verdadero

¿Cómo puedo pasar el tercer parámetro? (Sé que es posible pasarlo como un char * pero luego tendré que tener otra tabla para comparar la cadena del operador y luego hacer la operación, que es algo que me gustaría evitar)

¿Es posible pasar un operador como ^ (XOR) o || (OR) o && (AND), etc. en una función / método?

Gracias por adelantado

Answer 1

@ybungalobill publicó una respuesta correcta en C ++ y debes apegarte a ella. Si desea pasar los operadores, las funciones no funcionarán, pero las macros harían el trabajo:

#define MYFUNC(lv, rv, op) ....

// Call it like this
MYFUNC(''t'', ''f'', ||);

Ten cuidado, las macros son malvadas .

Answer 2

Definir:

bool myfunc(char lv, char rv, boost::function<bool(bool,bool)> func);

si tienes impulso, o

bool myfunc(char lv, char rv, std::function<bool(bool,bool)> func);

si tienes compilador de C ++ 0x, o

template<class Func> bool myfunc(char lv, char rv, Func func);

Si quieres que sea una plantilla. Entonces puedes llamar:

myfunc(''t'', ''f'', std::logical_or<bool>());

Answer 3

Es difícil ser realizado. En C ++, el parámetro de función necesita una dirección memroy para encontrar su objeto, pero el operador se decide en tiempo de compilación. El operador no será un objeto. Así que puedes pensar en MACRO para terminar tu tarea.

Answer 4

Lo que puede hacer es definir los operadores de proxy que devuelven tipos específicos.

namespace detail {
    class or {
        bool operator()(bool a, bool b) {
            return a || b;
        }
    };
    class and {
        bool operator()(bool a, bool b) {
            return a && b;
        }
    };
    // etc
    class X {
        or operator||(X x) const { return or(); }
        and operator&&(X x) const { return and(); }
    };
};
const detail::X boolean;
template<typename T> bool myfunc(bool a, bool b, T t) {
     return t(a, b);
}
// and/or
bool myfunc(bool a, bool b, std::function<bool (bool, bool)> func) {
    return func(a, b);
}
// example
bool result = myfunc(a, b, boolean || boolean);

Puede, si está desesperado, encadenar este efecto utilizando plantillas para pasar expresiones lógicas complejas.

Además, el operador XOR es bit a bit, no lógico, aunque la diferencia es en realidad nada.

Sin embargo, hay una razón por la que las lambdas existen en C ++ 0x y es porque este tipo de cosas apesta en C ++ 03.