C++11 std:: fonction de comparaison lambda

je veux créer un std::set avec une fonction de comparaison personnalisée. Je pourrais le Définir comme une classe avec operator() , mais je voulais profiter de la possibilité de définir un lambda où il est utilisé, donc j'ai décidé de définir la fonction lambda dans la liste d'initialisation du constructeur de la classe qui a le std::set comme un membre. Mais je n'arrive pas à trouver le genre de lambda. Avant de poursuivre, voici un exemple:

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

j'ai trouvé deux solutions après recherche: un, en utilisant std::function . Il suffit d'avoir le type de fonction de comparaison de jeu std::function<bool (int, int)> et passer la lambda exactement comme je l'ai fait. La deuxième solution est d'écrire une fonction make_set, comme std::make_pair .

SOLUTION 1:

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

SOLUTION 2:

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

la question Est, ai-je une bonne raison de préférer une solution à l'autre? Je préfère la première parce qu'elle utilise des fonctionnalités standard (make_set n'est pas une fonction standard), mais je me demande si l'utilisation de std::function ralentit (potentiellement) le code? Je veux dire, est-ce que cela réduit la chance que le compilateur inlines la fonction de comparaison, ou il devrait être assez intelligent pour se comporter exactement comme il serait un type de fonction lambda et non std::function (je sais, dans ce cas, il ne peut pas être un type lambda, mais vous savez, je demande en général) ?

(J'utilise GCC, mais j'aimerais savoir ce que font les compilateurs populaires dans general)

RÉSUMÉ, APRÈS QUE J'AI EU BEAUCOUP DE GRANDES RÉPONSES:

Si la vitesse est critique, la meilleure solution est d'utiliser une classe avec operator() aka foncteur. Il est plus facile pour le compilateur d'optimiser et d'éviter toutes les indirectes.

pour un entretien facile et une meilleure solution polyvalente, utilisez les fonctionnalités C++11, utilisez std::function . C'est toujours rapide (juste un peu plus lent que le foncteur, mais il peut être négligeable) et vous pouvez utiliser la fonction std::function , lambda, tout objet appelable.

il y a aussi une option pour utiliser un pointeur de fonction, mais s'il n'y a pas de problème de vitesse, je pense que std::function est mieux (si vous utilisez++11).

il y a une option pour définir la fonction lambda ailleurs, mais alors vous ne gagnez rien de la fonction de comparaison étant une expression lambda, puisque vous pourriez aussi bien en faire une classe avec operator() et le l'emplacement de la définition ne serait pas la construction établie de toute façon.

il y a d'autres idées, comme l'utilisation de la délégation. Si vous voulez une explication plus complète de toutes les solutions, lisez les réponses:)