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

Question

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

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

我搜索后发现了两种解决方案：一种，使用std::function。只需将设置比较函数类型设为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() aka functor 的类。编译器最容易优化和避免任何间接。

为了便于维护和更好的通用解决方案，使用 C++11 功能，请使用std::function。它仍然很快（只是比仿函数慢一点，但可以忽略不计）并且您可以使用任何函数 - std::function、lambda、任何可调用对象。

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

有一个选项可以在其他地方定义 lambda 函数，但是如果比较函数是 lambda 表达式，您将一无所获，因为您也可以使用 operator() 将其设为一个类，并且定义的位置不会是无论如何设置构造。

还有更多的想法，比如使用委托。如果您想更全面地解释所有解决方案，请阅读答案:)

Answer 1

编译器不太可能内联 std::function 调用，而任何支持 lambda 的编译器几乎肯定会内联仿函数版本，包括如果该仿函数是未被 std::function 隐藏的 lambda。

您可以使用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 上的实时运行。

Answer 2

是的，std::function 向您的set 引入了几乎不可避免的间接寻址。虽然编译器在理论上总是可以找出所有使用你的set 的std::function 都涉及在一个总是完全相同的 lambda 的 lambda 上调用它，它既坚硬又极其脆弱。

脆弱，因为在编译器可以向自己证明对 std::function 的所有调用实际上都是对您的 lambda 的调用之前，它必须证明对您的 std::set 的任何访问都不会将 std::function 设置为除您的 lambda 之外的任何东西.这意味着它必须在所有编译单元中跟踪所有可能的路线以到达您的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 算法。

Answer 3

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

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

否则我会选择make_set 解决方案。如果你不使用单行创建函数，因为它是非标准的，你就不会编写太多代码！

Answer 4

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

https://codereview.stackexchange.com/questions/14730/impossibly-fast-delegate-in-c11

因为std::function 通常有点太重了。不过，我无法评论您的具体情况，因为我不知道。

Answer 5

如果您确定将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 具有适当的转换函数。这当然会涉及到函数指针的间接寻址。

Answer 6

差异很大程度上取决于编译器的优化。如果它在 std::function 中优化了 lambda，那么它们是等价的，如果不是，则在前者中引入间接，而在后者中则不会。