Чи слід передавати функцію std :: через const-reference?

Скажімо, у мене є функція, яка займає std::function:

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

Чи слід xзамість цього пройти через const-reference ?:

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

Чи змінюється відповідь на це питання залежно від того, що функція робить з ним? Наприклад, якщо це функція або конструктор члена класу, який зберігає або ініціалізує std::functionзмінну члена.

Якщо ви хочете продуктивність, передавайте цінність, якщо ви зберігаєте її.

Припустимо, у вас є функція під назвою "запустити це в потоці інтерфейсу".

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

який виконує деякий код у потоці "ui", а потім сигналізує про futureзавершення. (Корисно в структурах інтерфейсу користувача, де потік користувальницького інтерфейсу знаходиться там, де ви повинні поплутатися з елементами інтерфейсу)

Ми маємо два підписи, які ми розглядаємо:

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

Тепер ми, ймовірно, використовуватимемо наступне:

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

який створить анонімне закриття (лямбда), побудує std::functionз нього, передасть його run_in_ui_threadфункції, а потім дочекайтеся її завершення в основному потоці.

У випадку (A), std::functionбезпосередньо побудований з нашої лямбда, який потім використовується в межах run_in_ui_thread. Лямбда moveперетворюється на std::function, тому будь-який рухливий стан ефективно переноситься в неї.

У другому випадку створюється тимчасовий std::function, лямбда moveвпадає в нього, тоді цей тимчасовий std::functionвикористовується за допомогою посилання в межах run_in_ui_thread.

Поки що так добре - вони обидва виступають однаково. За винятком того run_in_ui_thread, що збирається зробити копію свого аргументу функції, щоб надіслати потік ui для виконання! (він повернеться до того, як буде зроблено з ним, тому він не може просто використовувати посилання на нього). Для випадку (А), ми просто в його тривалого зберігання. У випадку (B), ми змушені копіювати .movestd::functionstd::function

Цей магазин робить проходження по вартості більш оптимальним. Якщо є якась можливість, ви зберігаєте копію документа std::function, передайте значення. В іншому випадку будь-який спосіб є приблизно еквівалентним: єдиний недолік побічної вартості - це якщо ви приймаєте ту саму об'ємну std::functionі маєте один під-метод за іншим. Якщо це забороняється, засіб moveбуде настільки ж ефективним, як і const&.

Зараз є деякі інші відмінності між цими двома, які здебільшого спричиняють ситуацію, якщо ми маємо стійкий стан всередині країни std::function.

Припустимо, що std::functionзберігає якийсь об’єкт з a operator() const, але він також має деякі mutableчлени даних, які він модифікує (як грубо!).

У std::function<> const&випадку, коли mutableмодифіковані члени даних поширюватимуться з виклику функції. У std::function<>випадку вони не стануть.

Це відносно дивний кутовий випадок.

Ви хочете поводитись так, std::functionяк до будь-якого іншого, можливо важкого, дешевого рухомого типу. Переміщення дешеве, копіювання може бути дорогим.

Якщо ви турбуєтесь про продуктивність і не визначаєте функцію віртуального члена, то, швидше за все, ви не повинні використовувати це std::functionвзагалі.

Створення типу функтора параметром шаблону дозволяє більшу оптимізацію, ніж std::function, включаючи вбудовану логіку функтора. Ефект від цих оптимізацій, ймовірно, значно переважатиме занепокоєння копії проти опосередкування щодо того, як пройти std::function.

Швидше:

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

Як зазвичай у C ++ 11, проходження за значенням / посиланням / const-посиланням залежить від того, що ви робите зі своїм аргументом. std::functionнічим не відрізняється.

Перехід за значенням дозволяє перемістити аргумент у змінну (як правило, змінну-члена класу):

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

    Object m_o;
};

Коли ви знаєте, що ваша функція перемістить свій аргумент, це найкраще рішення, таким чином ваші користувачі можуть контролювати, як вони називають вашу функцію:

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

Я вважаю, ви вже знаєте семантику (не) const-посилань, тому я не буду терпіти суть. Якщо мені потрібно додати більше пояснень щодо цього, просто запитайте, і я оновлю.