Supongamos que tengo un tipo invocable como este:
struct mutable_callable
{
int my_mutable = 0;
int operator()() { // Not const
return my_mutable++;
}
};
Tenga en cuenta que mutable_callable
tiene una no constante operator()
que modifica una variable miembro .....
Ahora suponga que creo un std::function
fuera de mi tipo:
std::function<int()> foo = mutable_callable{};
Ahora puedo hacer esto:
void invoke(std::function<int()> const& z)
{
z();
}
int main()
{
invoke(foo); // foo changed.....oops
}
Ahora, por lo que puedo decir, std::function
s operator()
es const
según:
https://en.cppreference.com/w/cpp/utility/functional/function/operator ()
Así que mi intuición es que no deberías poder hacer esto .....
Pero luego mirando: https://en.cppreference.com/w/cpp/utility/functional/function/function
Esto no parece poner ninguna restricción sobre si el tipo invocable tiene o no una constante operator()
......
Entonces mi pregunta es la siguiente: estoy en lo cierto al suponer que std::function<int()> const&
es esencialmente lo mismo, ya std::function<int()>&
que no existe una diferencia real entre el comportamiento de los dos ... y si ese es el caso, ¿por qué no es const
correcto?
std::function
implementación de MSVC : i.stack.imgur.com/eNenN.png donde using _Ptrt = _Func_base<_Ret, _Types...>
. Yo descanso mi caso.
std::function
tiene el equivalente a astruct a{ std::any x; };
en él .....