Czy powinienem przekazać funkcję std :: przez odwołanie do stałej?

Powiedzmy, że mam funkcję, która przyjmuje std::function:

void callFunction(std::function<void()> x)
{
    x();
}

Czy powinienem xzamiast tego przejść przez const-reference ?:

void callFunction(const std::function<void()>& x)
{
    x();
}

Czy odpowiedź na to pytanie zmienia się w zależności od tego, co robi z nią funkcja? Na przykład, jeśli jest to funkcja składowa klasy lub konstruktor, który przechowuje lub inicjuje std::functionw zmiennej składowej.

Jeśli chcesz wydajności, podaj wartość, jeśli ją przechowujesz.

Załóżmy, że masz funkcję o nazwie „uruchom to w wątku interfejsu użytkownika”.

std::future<void> run_in_ui_thread( std::function<void()> )

który uruchamia kod w wątku „ui”, a następnie sygnalizuje zakończenie future. (Przydatne w strukturach UI, w których wątek UI jest miejscem, w którym powinieneś zadzierać z elementami UI)

Rozważamy dwa podpisy:

std::future<void> run_in_ui_thread( std::function<void()> ) // (A)
std::future<void> run_in_ui_thread( std::function<void()> const& ) // (B)

Teraz prawdopodobnie użyjemy ich w następujący sposób:

run_in_ui_thread( [=]{
  // code goes here
} ).wait();

co utworzy anonimowe zamknięcie (lambda), skonstruuje z niego std::functionwyjście, przekaże je do run_in_ui_threadfunkcji, a następnie zaczeka, aż zakończy się działanie w głównym wątku.

W przypadku (A), std::functionjest on konstruowany bezpośrednio z naszej lambdy, która jest następnie używana w run_in_ui_thread. Lambda jest moved do std::function, więc każdy ruchomy stan jest skutecznie przenoszony do niej.

W drugim przypadku std::functiontworzony jest tymczasowy , lambda jest movew nim d, a następnie ten tymczasowy std::functionjest używany przez odniesienie w run_in_ui_thread.

Jak na razie dobrze - obaj grają identycznie. Tyle run_in_ui_threadże program utworzy kopię swojego argumentu funkcji do wysłania do wątku interfejsu użytkownika w celu wykonania! (wróci, zanim zostanie z nim zakończony, więc nie może po prostu użyć odniesienia do niego). W przypadku (A), po prostu do jego długotrwałego przechowywania. W przypadku (B) jesteśmy zmuszeni skopiować plik .movestd::functionstd::function

Ten sklep sprawia, że ​​przekazywanie wartości jest bardziej optymalne. Jeśli istnieje możliwość, że przechowujesz kopię pliku std::function, podaj wartość. W przeciwnym razie obie metody są z grubsza równoważne: jedyną wadą wartości bocznej jest to, że bierzesz tę samą masę std::functioni jedną metodę podrzędną po drugiej. Poza tym, a movebędzie tak samo wydajne jak const&.

Teraz są pewne inne różnice między tymi dwoma, które najczęściej pojawiają się, jeśli mamy trwały stan w obrębie std::function.

Załóżmy, że std::functionprzechowuje jakiś obiekt z a operator() const, ale ma też kilka mutableczłonków danych, które modyfikuje (jakie niegrzeczne!).

W takim std::function<> const&przypadku mutablezmodyfikowane elementy składowe danych będą propagowane poza wywołanie funkcji. W takim std::function<>przypadku nie będą.

To stosunkowo dziwny przypadek narożny.

Chcesz traktować std::functionjak każdy inny potencjalnie ciężki, tani przenośny typ. Przenoszenie jest tanie, kopiowanie może być kosztowne.

Jeśli martwisz się o wydajność i nie definiujesz wirtualnej funkcji składowej, najprawdopodobniej w ogóle nie powinieneś jej używać std::function.

Uczynienie typu funktora parametrem szablonu pozwala na większą optymalizację niż std::functionwłączenie logiki funktora. Efekt tych optymalizacji prawdopodobnie znacznie przeważy nad obawami o kopiowanie kontra pośrednie, jak przejść std::function.

Szybciej:

template<typename Functor>
void callFunction(Functor&& x)
{
    x();
}

Jak zwykle w C ++ 11, przekazywanie przez wartość / referencję / stałą-referencję zależy od tego, co zrobisz z argumentem. std::functionnie jest inaczej.

Przekazywanie przez wartość umożliwia przeniesienie argumentu do zmiennej (zwykle jest to zmienna składowa klasy):

struct Foo {
    Foo(Object o) : m_o(std::move(o)) {}

    Object m_o;
};

Jeśli wiesz, że Twoja funkcja przeniesie swój argument, jest to najlepsze rozwiązanie, w ten sposób użytkownicy mogą kontrolować sposób wywoływania funkcji:

Foo f1{Object()};               // move the temporary, followed by a move in the constructor
Foo f2{some_object};            // copy the object, followed by a move in the constructor
Foo f3{std::move(some_object)}; // move the object, followed by a move in the constructor

Wydaje mi się, że znasz już semantykę (nie) odniesień stałych, więc nie będę się nad tym rozwodzić. Jeśli chcesz, żebym dodał więcej wyjaśnień na ten temat, po prostu zapytaj, a zaktualizuję.