c++ - namespace - ¿Comparando std:: funciones para la igualdad?

std::cout

Question

¿Cómo puedo comparar dos std::function C ++ 11 std::function con el operator== , y devolver true si ambas de dichas function refieren al mismo puntero de función?

Answer 1

De hecho, puedes hacer que funcione con .target :

template<typename T, typename... U>
size_t getAddress(std::function<T(U...)> f) {
    typedef T(fnType)(U...);
    fnType ** fnPointer = f.template target<fnType*>();
    return (size_t) *fnPointer;
}

if (getAddress(f) == getAddress(g)) {...}

(Ref: C ++ tratando de obtener la dirección de la función de un std :: function )

Answer 2

Puede intentar comparar b primero comparando su .target_type() y si estos identificadores de tipo de destino son los mismos, puede comparar sus punteros .target() . Puede utilizar un tipo de destino no coincidente como un falso temprano.

Answer 3

Si std::function<T(U...)> f es una función miembro, el fnPointer será nulo.

Answer 4

Tenga en cuenta que la igualdad de funciones es un problema indecidible en el cálculo lambda (y es por eso que muchos lenguajes de programación no permiten comparar funciones).

Entonces, incluso si la prueba == compila, a lo sumo solo probaría que el código es idéntico (tiene la misma dirección), no que las funciones comparadas tengan el mismo comportamiento.

Answer 5

operator== para std :: function compara una función std :: con un puntero nulo, por lo que puedo decir, el estándar no proporciona ningún detalle sobre por qué.

Aunque, esta entrada de preguntas frecuentes de impulso, ¿por qué no puedo comparar objetos de función :: boost con operador == u operador! =? proporciona una justificación y, por lo que sé, debería ser aplicable a std::function también. Citando las preguntas frecuentes:

La comparación entre los objetos boost :: function no se puede implementar "bien" y, por lo tanto, no se implementará. [...]

luego describe las soluciones solicitadas similares a las de Preet y continúa diciendo:

El problema se produce cuando el tipo de objetos de función almacenados por f y g no tiene un operador == [...]

y explica por qué esto tiene que tratarse ya sea en el operador de asignación o en el constructor y luego continúa diciendo:

Todos estos problemas se traducen en fallas en los constructores boost :: function u operador de asignación, incluso si el usuario nunca invoca al operador ==. No podemos hacer eso a los usuarios.

Actualizar

Encontró una justificación de estándares en Acceder al objetivo de un objeto tr1 :: function , que es bastante antiguo pero es consistente con las preguntas frecuentes de impulso y dice:

operator == no es implementable para tr1 :: function dentro del lenguaje C ++, porque no tenemos una manera confiable de detectar si un tipo T dado es comparable a la igualdad sin la asistencia del usuario.