Angenommen, ich habe einen aufrufbaren Typ wie folgt:
struct mutable_callable
{
int my_mutable = 0;
int operator()() { // Not const
return my_mutable++;
}
};
Beachten Sie, dass mutable_callable
es eine Nicht-Konstante gibt operator()
, die eine Mitgliedsvariable ändert .....
Angenommen, ich erstelle ein std::function
Out aus meinem Typ:
std::function<int()> foo = mutable_callable{};
Jetzt kann ich das machen:
void invoke(std::function<int()> const& z)
{
z();
}
int main()
{
invoke(foo); // foo changed.....oops
}
Soweit ich das beurteilen kann, lautet std::function
s wie operator()
folgt const
:
https://en.cppreference.com/w/cpp/utility/functional/function/operator ()
Mein Bauchgefühl ist also, dass Sie dies nicht können sollten .....
Aber dann schauen Sie sich Folgendes an: https://en.cppreference.com/w/cpp/utility/functional/function/function
Dies scheint keine Einschränkungen dafür zu setzen, ob der aufrufbare Typ eine Konstante hat oder nicht operator()
......
Meine Frage lautet also: Ich gehe zu Recht davon aus, dass dies std::function<int()> const&
im Wesentlichen dasselbe ist, nämlich std::function<int()>&
dass es keinen tatsächlichen Unterschied zwischen dem Verhalten der beiden gibt. Wenn dies der Fall ist, warum ist es dann nicht const
richtig?
quelle
std::function
hat das Äquivalent zu einemstruct a{ std::any x; };
darin .....std::function
Implementierung: i.stack.imgur.com/eNenN.png whereusing _Ptrt = _Func_base<_Ret, _Types...>
. Ich ruhe meinen Fall aus.Antworten:
Dies läuft darauf hinaus
struct A { int* x; };
, wo Sie in a den Wert vonconst A a;
ändern können (aber nicht, wohin er zeigt). Es gibt eine Indirektionsebene in (vom Typ Löschen), durch die nicht weitergegeben wird.*(a.x)
std::function
const
Und nein,
std::function<int()> const& f
ist nicht sinnlos. In einemstd::function<int()>& f
könnten Sie einen anderen Funktor zuweisenf
, was Sie in diesemconst
Fall nicht tun können.quelle
std::vector
tut das,std::unique_ptr
nicht. Ich denke, esstd::function
geht nicht wirklich darum, Invarianten des Funktorzustands auszudrücken. Vielleicht könnten wir abscheuliche Funktionstypen (dhstd::function<int() const>
) zur Unterscheidung wiederverwenden ?unique_ptr
sollte keine Konstanz verbreiten, wie dies der reguläre Zeiger nicht tut. Undstd::function<int() const>
würde nicht kompilieren.std::function
fallen soll, ist mir nicht klar. Und dasstd::function<int() const>
war eine Hypothese - natürlich wird es jetzt nicht kompiliert, aber würde es zB das OP hier befriedigen, wenn dies gültig gemacht werden könnte und ausdrückt "kann nur Funktoren mit einemoperator() const
(oder staatenlosen) zugewiesen werden"? (Selbst wenn dies hinter den Kulissen aufgrund der Verwendung abscheulicher Funktionstypen ziemlich grausam wäre)?