我试图将一组整数中的项的默认顺序更改为lexicographic而不是numeric，并且我无法使用g ++进行以下编译：
file.cpp：
bool lex_compare(const int64_t &a, const int64_t &b)
{
stringstream s1,s2;
s1 << a;
s2 << b;
return s1.str() < s2.str();
}
void foo()
{
set<int64_t, lex_compare> s;
s.insert(1);
...
}
我收到以下错误：
error: type/value mismatch at argument 2 in template parameter list for ‘template<class _Key, class _Compare, class _Alloc> class std::set’
error: expected a type, got ‘lex_compare’
我究竟做错了什么？
您正在使用一个函数，因为您应该使用仿函数（一个重载（）运算符的类，因此可以像函数一样调用它。
struct lex_compare {
bool operator() (const int64_t& lhs, const int64_t& rhs) const {
stringstream s1, s2;
s1 << lhs;
s2 << rhs;
return s1.str() < s2.str();
}
};
然后使用类名作为类型参数
set<int64_t, lex_compare> s;
如果你想避免仿函数样板代码，你也可以使用函数指针（假设lex_compare是一个函数）。
set<int64_t, bool(*)(const int64_t& lhs, const int64_t& rhs)> s(&lex_compare);
auto cmp = [](int a, int b) { return ... };
std::set<int, decltype(cmp)> s(cmp);
我们使用lambda function作为比较器。像往常一样，比较器应该返回布尔值，指示作为第一个参数传递的元素是否被认为是在它定义的特定strict weak ordering中的第二个参数之前。
使比较器成为通常的布尔函数
bool cmp(int a, int b) {
return ...;
}
然后使用它
std::set<int, decltype(&cmp)> s(&cmp);
() operatorstruct cmp {
bool operator() (int a, int b) const {
return ...
}
};
// ...
// later
std::set<int, cmp> s;
采取布尔函数
bool cmp(int a, int b) {
return ...;
}
并使用std::integral_constant从中创建结构
#include <type_traits>
using Cmp = std::integral_constant<decltype(&cmp), &cmp>;
最后，使用struct作为比较器
std::set<X, Cmp> set;
Yacoby的回答激励我编写一个用于封装仿函数样板的适配器。
template< class T, bool (*comp)( T const &, T const & ) >
class set_funcomp {
struct ftor {
bool operator()( T const &l, T const &r )
{ return comp( l, r ); }
};
public:
typedef std::set< T, ftor > t;
};
// usage
bool my_comparison( foo const &l, foo const &r );
set_funcomp< foo, my_comparison >::t boo; // just the way you want it!
哇，我觉得那值得一试！
您可以使用函数比较器而不包装它，如下所示：
bool comparator(const MyType &lhs, const MyType &rhs)
{
return [...];
}
std::set<MyType, bool(*)(const MyType&, const MyType&)> mySet(&comparator);
每次需要一组该类型时输入会很烦人，如果不使用相同的比较器创建所有集合，则会导致问题。
与std::less<>一起使用自定义类时的operator<
如果您正在处理一组定义了operator<的自定义类，那么您可以使用std::less<>，例如：
正如在http://en.cppreference.com/w/cpp/container/set/find上提到的，C ++ 14增加了两个新的find API：
template< class K > iterator find( const K& x );
template< class K > const_iterator find( const K& x ) const;
允许你这样做：
#include <cassert>
#include <set>
class Point {
public:
// Note that there is _no_ conversion constructor,
// everything is done at the template level without
// intermediate object creation.
//Point(int x) : x(x) {}
Point(int x, int y) : x(x), y(y) {}
int x;
int y;
};
bool operator<(const Point& c, int x) { return c.x < x; }
bool operator<(int x, const Point& c) { return x < c.x; }
bool operator<(const Point& c, const Point& d) {
return c.x < d;
}
int main() {
std::set<Point, std::less<>> s;
s.insert(Point(1, -1));
s.insert(Point(2, -2));
s.insert(Point(0, 0));
s.insert(Point(3, -3));
assert(s.find(0)->y == 0);
assert(s.find(1)->y == -1);
assert(s.find(2)->y == -2);
assert(s.find(3)->y == -3);
// Ignore 1234, find 1.
assert(s.find(Point(1, 1234))->y == -1);
}
在Ubuntu 16.10上测试，g++ 6.2.0，用：
g++ -std=c++14 -Wall -Wextra -pedantic -o main.out main.cpp
./main.out
有关std::less<>的更多信息，请访问：What are transparent comparators?