我想用自定义比较函数创建一个std::set。我可以将它定义为带有operator()的类，但我想享受定义使用它的lambda的能力，所以我决定在类的构造函数的初始化列表中定义lambda函数，该类具有std::set作为会员。但我无法得到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()使它成为一个类，并且定义的位置无论如何都不是set结构。
有更多的想法，例如使用委托。如果您想要对所有解决方案进行更全面的解释，请阅读答案:)
是的，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更好有一个2阶段“插入一切”然后“重复查询内容”。只需将它首先填入vector，然后sort unique erase，然后使用免费的equal_range算法。
编译器不太可能内联std :: function调用，而任何支持lambdas的编译器几乎肯定会内联functor版本，包括该functor是否是一个未被std::function隐藏的lambda。
您可以使用qazxsw poi来获取lambda比较器类型：
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
上现场直播。
无状态lambda（即没有捕获的lambda）可以衰减为函数指针，因此您的类型可以是：
Coliru
否则我会选择std::set<int, bool (*)(int, int)> numbers;
解决方案。如果你不使用单行创建函数，因为它是非标准的，你不会得到很多代码！
根据我使用剖析器的经验，性能和美观之间的最佳折衷是使用自定义委托实现，例如：
make_set
由于https://codereview.stackexchange.com/questions/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的类型不包含哪个构造函数初始化其比较器的信息，因此调用正确的lambda需要间接到运行时选择的lambda set。
由于你使用无捕获的lambdas，你可以使用函数指针类型operator()作为比较器类型，因为无捕获的lambdas具有适当的转换函数。这当然涉及通过函数指针的间接。
差异在很大程度上取决于编译器的优化。如果它优化了bool (*)(int, int)中的lambda，那么它们是等价的，如果不是，你在前者中引入了一个你不会在后者中的间接。