C ++ 11 std :: встановити функцію порівняння лямбда-сигналу

Я хочу створити std::setспеціальну функцію порівняння. Я міг би визначити це як клас з operator(), але я хотів насолодитися можливістю визначати лямбда-де, де він використовується, тому я вирішив визначити лямбда-функцію в списку ініціалізації конструктора класу, який є std::setчленом. Але я не можу зрозуміти тип лямбди. Перш ніж продовжувати, ось приклад:

class Foo
{
private:
     std::set<int, /*???*/> numbers;
public:
     Foo () : numbers ([](int x, int y)
                       {
                           return x < y;
                       })
     {
     }
};

Після пошуку я знайшов два рішення: одне, використання std::function. Просто нехай встановлений тип функції порівняння буде std::function<bool (int, int)>і передає лямбду точно так, як це робив я. Друге рішення - написати функцію make_set, наприклад std::make_pair.

РІШЕННЯ 1:

class Foo
{
private:
     std::set<int, std::function<bool (int, int)> numbers;
public:
     Foo () : numbers ([](int x, int y)
                       {
                           return x < y;
                       })
     {
     }
};

РІШЕННЯ 2:

template <class Key, class Compare>
std::set<Key, Compare> make_set (Compare compare)
{
     return std::set<Key, Compare> (compare);
}

Питання в тому, чи є у мене поважна причина віддавати перевагу одному рішенню перед іншим? Я віддаю перевагу першому, оскільки він використовує стандартні функції (make_set не є стандартною функцією), але цікаво: чи робить використання std::functionкоду (потенційно) повільнішим? Я маю на увазі, чи зменшує це шанс компілятор вбудувати функцію порівняння, або він повинен бути досить розумним, щоб поводитись точно так само, як якщо б це був тип лямбда-функції, а ні std::function(я знаю, у цьому випадку це не може бути тип лямбда, але ви знаєте, я взагалі запитую)?

(Я використовую GCC, але хотів би знати, що взагалі роблять популярні компілятори)

РЕЗЮМЕ, ПІСЛЯ Я ОТРИМАВ БАГАТО ВЕЛИКИХ ВІДПОВІДЬ

Якщо швидкість є критичною, найкращим рішенням буде використання класу з operator()ака-функтором. Компілятору найпростіше оптимізувати та уникнути будь-яких побічних дій.

Для зручності обслуговування та кращого рішення загального призначення, використовуючи функції C ++ 11, використовуйте std::function. Це все ще швидко (лише трохи повільніше, ніж функтор, але може бути незначним), і ви можете використовувати будь-яку функцію - std::function, лямбда, будь-який об’єкт, що викликається.

Також є можливість використовувати покажчик функції, але якщо проблеми зі швидкістю немає, я думаю, що std::functionце краще (якщо ви використовуєте C ++ 11).

Існує можливість визначити лямбда-функцію в іншому місці, але тоді ви нічого не отримуєте від функції порівняння, яка є лямбда-виразом, оскільки ви також можете зробити її класом operator() а розташування визначення все одно не буде конструкцією набору.

Є більше ідей, таких як використання делегування. Якщо ви хочете отримати більш ретельне пояснення всіх рішень, прочитайте відповіді :)

Так, a std::functionвводить майже неминучий непрямий вплив на ваш set. Хоча компілятор завжди може, теоретично, з'ясувати , що використання Вашого set«S std::functionвключає в себе виклик його на лямбда , який завжди точно такий же лямбда, який є одночасно твердим і дуже тендітні.

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

Це може бути можливо в деяких випадках, але відносно нешкідливі зміни можуть зламати його, навіть якщо ваш компілятор зумів це довести.

З іншого боку, функтор з безгромадянством operator()легко доводить поведінку та оптимізацію, що включає щоденні речі.

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

make_setмає серйозний недолік, що будь-який такий setтип повинен бути виведений із заклику до make_set. Часто setзберігається стійкий стан, а не те, що ви створюєте в стеку, тоді виходить з поля зору.

Якщо ви створили статичну або глобальну лямбда-форму без стану auto MyComp = [](A const&, A const&)->bool { ... }, ви можете використовувати std::set<A, decltype(MyComp)>синтаксис для створення такого, setякий може зберігатися, але компілятору легко оптимізувати (оскільки всі екземпляри decltype(MyComp)є функторами без стану) та вбудованим. Я вказую на це, тому що ви дотримуєтеся символу seta struct. (Або ваш компілятор підтримує

struct Foo {
  auto mySet = make_set<int>([](int l, int r){ return l<r; });
};

що я б знайшов дивовижним!)

Нарешті, якщо ви турбуєтесь щодо продуктивності, вважайте, що std::unordered_setце набагато швидше (за рахунок того, що ви не можете переглядати вміст по порядку, і вам потрібно написати / знайти хороший хеш), і що сортування std::vectorкраще, якщо у вас є Двофазне "вставити все", потім "повторно запитувати вміст". Просто запхайте його в vectorперший, потім sort unique erase, а потім скористайтеся безкоштовним equal_rangeалгоритмом.

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

Ви можете використати, decltypeщоб отримати тип компаратора лямбди:

#include <set>
#include <iostream>
#include <iterator>
#include <algorithm>

int main()
{
   auto comp = [](int x, int y){ return x < y; };
   auto set  = std::set<int,decltype(comp)>( comp );

   set.insert(1);
   set.insert(10);
   set.insert(1); // Dupe!
   set.insert(2);

   std::copy( set.begin(), set.end(), std::ostream_iterator<int>(std::cout, "\n") );
}

Які відбитки:

1
2
10

Подивіться, як це працює в прямому ефірі Coliru.

Лямбда без стану (тобто така, яка не захоплює) може перетворитися на покажчик функції, тому ваш тип може бути:

std::set<int, bool (*)(int, int)> numbers;

Інакше я піду на make_setрішення. Якщо ви не будете використовувати однорядкову функцію створення, оскільки вона нестандартна, ви не збираєтеся писати багато коду!

З мого досвіду, коли я бавився з профайлером, найкращим компромісом між продуктивністю та красою є використання власної реалізації делегатів, таких як:

/codereview/14730/impossibly-fast-delegate-in-c11

Як std::functionправило, це трохи занадто важко. Однак я не можу коментувати ваші конкретні обставини, оскільки я їх не знаю.

Якщо ви вирішили мати setяк члена класу ініціалізацію його компаратора під час конструктора, то принаймні один рівень опосередкованості не уникнути. Врахуйте, що, наскільки відомо компілятору, ви можете додати ще один конструктор:

 Foo () : numbers ([](int x, int y)
                   {
                       return x < y;
                   })
 {
 }

 Foo (char) : numbers ([](int x, int y)
                   {
                       return x > y;
                   })
 {
 }

Після того, як у вас є об'єкт типу Foo, тип setне несе інформації про те, який конструктор ініціалізував його компаратор, тому для виклику правильної лямбди потрібна опосередкованість до вибраної лямбди часу виконання operator().

Оскільки ви використовуєте лямбди без захоплення, ви можете використовувати тип покажчика функції bool (*)(int, int)як тип порівняння, оскільки лямбди без захоплення мають відповідну функцію перетворення. Це, звичайно, передбачає опосередкування через покажчик функції.

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