C ++ 11 std :: set lambda比较函数

我想std::set用自定义比较功能创建一个。我可以使用来将其定义为类operator()，但是我想享受在其中使用lambda的能力，因此我决定在具有std::set作为成员的类的构造函数的初始化列表中定义lambda函数。但是我无法获得lambda的类型。在继续之前，这里有一个例子：

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

搜索后，我发现了两种解决方案：一种是使用std::function。只需将设置比较函数类型设置为be，std::function<bool (int, int)>然后像我一样完全传递lambda即可。第二种解决方案是编写一个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代码会使（潜在地）速度变慢吗？我的意思是，这是否会降低编译器内联比较函数的机会，还是应该足够聪明以使其表现出完全相同的行为，就像它是lambda函数类型而不是那样std::function（我知道，在这种情况下，它不能是lambda类型，但您知道，我一般来说是问吗？

（我使用GCC，但是我想知道流行的编译器通常会做什么）

总结，在我得到很多答案之后：

如果速度至关重要，则最好的解决方案是使用带operator()函子的类。编译器最容易优化和避免任何间接调用。

要使用C ++ 11功能进行维护，并获得更好的通用解决方案，请使用std::function。它仍然很快（比函子慢一点，但可以忽略不计），您可以使用任何函数- std::function，lambda和任何可调用对象。

还有一个使用函数指针的选项，但是如果没有速度问题，我认为std::function更好（如果使用C ++ 11）。

有一个选项可以在其他地方定义lambda函数，但是随后您就无法从作为lambda表达式的比较函数中获得任何收益，因为您也可以将其作为一个类，operator()并且定义的位置也不会成为set构造。

还有更多想法，例如使用委托。如果您想对所有解决方案进行更彻底的解释，请阅读答案:)

是的，std::function几乎为您带来了不可避免的间接访问set。从理论上讲，尽管编译器总能弄清楚您set对的所有使用都std::function涉及在总是完全相同的lambda的lambda上调用它，这既困难又极其脆弱。

易碎，因为在编译器可以向自己证明std::function对它的所有调用实际上都是对您的lambda的调用之前，它必须证明对您的访问std::set永远不会将除std::functionlambda之外的任何值设置为。这意味着它必须跟踪所有可能的途径，以到达std::set所有编译单元中的路径，并证明它们中没有一个这样做。

在某些情况下这可能是可行的，但是即使编译器设法证明它，相对无害的更改也可能破坏它。

另一方面，具有无状态的函子operator()容易证明行为，而涉及到的优化是日常事务。

所以，是的，实际上我怀疑std::function会慢一些。另一方面，std::function解决方案比make_set一种解决方案更易于维护，并且交换程序员时间以提高程序性能是很容易实现的。

make_set具有严重的缺点，set必须从对的调用中推断任何这样的类型make_set。通常是set存储持久状态，而不是在堆栈上创建的持久状态，然后超出范围。

如果创建了静态或全局无状态lambda auto MyComp = [](A const&, A const&)->bool { ... }，则可以使用该std::set<A, decltype(MyComp)>语法创建set可持久存在的语法，但编译器很容易进行优化（因为的所有实例decltype(MyComp)均为无状态函子）和内联。我指出这一点，因为您坚持set使用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调用，而任何支持lambda的编译器几乎都可以内联functor版本，包括该functor是不被a隐藏的lambda std::function。

您可以decltype用来获取lambda的比较器类型：

#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。

无状态的lambda（即没有捕获的lambda）可以衰减到函数指针，因此您的类型可能是：

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

否则，我会寻求make_set解决方案。如果您不使用单行创建功能（因为它是非标准的），则不会编写太多代码！

根据我在探查器中玩耍的经验，性能和美观之间的最佳折衷方案是使用自定义委托实现，例如：

/codereview/14730/impossfully-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就不包含构造函数初始化其比较器的信息，因此要调用正确的lambda，需要对运行时选定的lambda进行间接调用operator()。

由于您正在使用不捕获的lambda，因此可以将函数指针类型bool (*)(int, int)用作比较器类型，因为不捕获的lambda具有适当的转换功能。当然，这将涉及通过函数指针的间接访问。

差异很大程度上取决于编译器的优化。如果它在std::function与lambda相同的情况下优化了lambda ，那么如果不优化，则您会在前者中引入一个间接值，而后者则不会。