Czy powinienem przekazać funkcję std :: przez const-reference?

Question

Powiedzmy Mam funkcję, która bierze std::function:

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

powinienem przekazać x przez const odniesień zamiast ?:

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

Czy odpowiedź na tę zmianę zapytania w zależności od funkcji z nią robi? Na przykład, jeśli jest to funkcja lub konstruktor składowy klasy, który przechowuje lub inicjuje std::function do zmiennej składowej.

Answer 1

Jeśli martwisz się wydajnością i nie definiujesz funkcji wirtualnego elementu, najprawdopodobniej w ogóle nie powinieneś używać std::function.

Tworzenie typu funktora Parametr szablonu pozwala na większą optymalizację niż std::function, włączając w to wstawianie logiki funktora. Efekt tych optymalizacji prawdopodobnie znacznie przewyższa obawy dotyczące kopiowania w stosunku do nieokreślonego, dotyczące przekazywania std::function.

Szybsze:

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

Answer 2

Jak zwykle w C++ 11, przechodząc przez wartości/odniesienia/const odniesień zależy od tego, co zrobić ze swoim argumencie. std::function nie jest inaczej.

Przekazywanie przez wartość pozwala przenieść argument do zmiennej (zazwyczaj zmiennych członkiem klasy):

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

    Object m_o; 
}; 

Kiedy wiesz czynność przeniesie swój argument, to jest to najlepsze rozwiązanie ten sposób użytkownicy mogą kontrolować, jak nazywają swoją funkcję:

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 

wierzę już wiesz semantyki (nie) const odniesień, więc nie będę okładać punkt. Jeśli potrzebujesz więcej informacji na ten temat, po prostu zapytaj, a zaktualizuję.

Answer 3

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

Załóżmy, że masz funkcję o nazwie "uruchom to w wątku UI".

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

który działa kod, w „Ul” wątek, a następnie sygnalizuje future po zakończeniu. (Przydatne w ramach UI gdzie wątek UI jest, gdy ci mają bałagan z elementów UI)

Mamy dwa podpisy Rozważamy:

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

Teraz mogą z nich korzystać w sposób następujący:

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

który tworzy anonimowego zamknięcie (lambda) skonstruować std::function z niego, przekazać go do funkcji run_in_ui_thread, a następnie czekać na zakończenie pracy w głównym wątku.

W przypadku (A), std::function jest bezpośrednio skonstruowany z naszej lambda, która jest następnie używana w ramach run_in_ui_thread. Wartość lambda to move d do std::function, więc każdy ruchomy stan jest skutecznie przenoszony do niej.

W drugim przypadku, tymczasowy std::function jego tworzenia, lambda move d do niego, to tymczasowa std::function jest stosowany jako odniesienie w run_in_ui_thread.

Jak dotąd, tak dobrze - obaj wykonują identycznie. Z wyjątkiem run_in_ui_thread zrobi kopię swojego argumentu funkcji do wysłania do wątku interfejsu użytkownika do wykonania! (powróci, zanim zostanie zrobione, więc nie może po prostu użyć odniesienia do niego). Dla przypadku (A), po prostu move z std::function do jego długoterminowego przechowywania. W przypadku (B) jesteśmy zmuszeni skopiować std::function.

Ten sklep sprawia, że ​​przekazywanie według wartości jest bardziej optymalne. Jeśli istnieje możliwość zapisania kopii pliku std::function, podaj wartość. W przeciwnym razie, każda z nich jest mniej więcej równoważna: jedyną wadą wartości dodanej jest to, że używasz tego samego nieporęcznego obiektu std::function i używasz jednej metody podrzędnej za drugą. Poza tym, move będzie tak wydajny jak const&.

Teraz są pewne inne różnice między tymi dwoma, które najczęściej wskakują, jeśli mamy stały stan w ramach std::function.

Załóżmy, że std::function przechowuje jakiś obiekt z operator() const, ale ma również pewne elementy danych, które modyfikuje (jakże nieuprzejmość!).

W przypadku std::function<> const& zmodyfikowane zmienne danych mutable będą propagować poza wywołaniem funkcji. W przypadku std::function<> nie będą.

To stosunkowo dziwny przypadek narożny.

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