我有一个std::vector，其中包含许多对象，每个对象都带有与之相关联的数字组标识符。对象还具有“大小”和“名称”等属性。
我需要能够按名称、大小和其他属性对对象向量进行排序，同时保持它们在一起（例如通过上述组标识符进行分组）。
如何实现这个目标？
我需要能够按名称、大小和其他属性对对象向量进行排序，同时保持它们在一起（例如通过上述组标识符进行分组）。
如何实现这个目标？
5个回答
7
使用STL，编写自定义比较函数非常简单。您需要定义一个比较函数，首先按组进行比较，然后再按其他属性进行比较。
static bool CompareWidget(const Widget& w1, const Widget& w2)
{
if(w1.GetGroupNumber() != w2.GetGroupNumber())
return (w1.GetGroupNumber() < w2.GetGroupNumber());
if(w1.GetHeight() != w2.GetHeight())
return (w1.GetHeight() < w2.GetHeight();
/// etc
return false;
}
static void SortWidgetVector(WidgetVector& widgetVector)
{
std::sort(widgetVector.begin(), widgetVector.end(), CompareWidget);
}
- Andrew Shepherd
5
首先，让我们重新表述这个问题。你真正想要的是按组 ID 对对象进行排序，然后按（名称、大小等）排序。如果首先按组 ID 对它们进行排序，则显然具有相同组 ID 的对象将粘在一起。
可以很容易地使用 std::sort 的自定义谓词来完成此操作。类似于以下内容：
可以很容易地使用 std::sort 的自定义谓词来完成此操作。类似于以下内容：
struct MyPredicate {
bool operator() (const MyClass& lhs, const MyClass& rhs) const {
if (lhs.groupID != rhs.groupID) {
return lhs.groupId < rhs.groupId;
} else if (lhs.name != rhs.name) {
return lhs.name < rhs.name;
else
return lhs.size < rhs.size.
}
}
};
std::sort(myObjects.begin(), myObjects.end(), MyPredicate());
- Pavel Minaev
4
2
将群组标识符用作主排序关键字。
例如，要按组、名称、大小排序，您可以使用比较对象，例如：
class my_comparison : public std::binary_function< object, object, bool >
{
public:
inline bool operator()(
object const &left,
object const &right ) const
{
return ( left.group_id < right.group_id ? true :
left.group_id > right.group_id ? false :
left.name < right.name ? true :
left.name > right.name ? false :
left.size < right.size );
}
};
然后将其作为第三个参数传递给
std::sort()函数的实例。- Boojum
2
我需要能够按名称、大小和其他属性对对象向量进行排序，同时保持它们分组在一起（例如通过上面提到的组标识符）。
实际上，我要尝试的是相反的。首先，我想通过次要属性（例如名称、大小等）对向量进行排序，然后确保所有向量元素都包含在组内。
无论如何，结果应该是相同的，除非您想在中间状态下使用未按组标识符排序的向量。如果不是这样，我看不出为什么不能使用两个条件的比较函数（其中组ID是主要条件，名称/大小/其他是次要条件）。您甚至可以创建一个通用的比较对象，结合使用两个谓词（by_two_criteria）。
实际上，我要尝试的是相反的。首先，我想通过次要属性（例如名称、大小等）对向量进行排序，然后确保所有向量元素都包含在组内。
无论如何，结果应该是相同的，除非您想在中间状态下使用未按组标识符排序的向量。如果不是这样，我看不出为什么不能使用两个条件的比较函数（其中组ID是主要条件，名称/大小/其他是次要条件）。您甚至可以创建一个通用的比较对象，结合使用两个谓词（by_two_criteria）。
#include <vector>
#include <iostream>
#include <algorithm>
#include <iterator>
#include <cstdlib>
template <class FirstCondition, class SecondCondition>
class by_two_criteria_t
{
FirstCondition first;
SecondCondition second;
public:
by_two_criteria_t(FirstCondition f, SecondCondition s): first(f), second(s) {}
template <class T>
bool operator()(const T& a, const T& b) const
{
return first(a, b) || (!first(b, a) && second(a, b));
}
};
template <class FirstCondition, class SecondCondition>
by_two_criteria_t<FirstCondition, SecondCondition> by_two_criteria(FirstCondition f, SecondCondition s)
{
return by_two_criteria_t<FirstCondition, SecondCondition>(f, s);
}
class X
{
int group;
int value;
public:
X(int g, int n): group(g), value(n) {}
friend bool compare_group(const X& a, const X& b);
friend bool compare_value(const X& a, const X& b);
friend std::ostream& operator<<(std::ostream& os, const X& x) { return os << x.group << ", " << x.value; }
};
bool compare_group(const X& a, const X& b) { return a.group < b.group; }
bool compare_value(const X& a, const X& b) { return a.value < b.value; }
X random_x()
{
return X(rand() % 10, rand() % 20);
}
int main()
{
using namespace std;
vector<X> vec;
generate_n(back_inserter(vec), 100, random_x);
sort(vec.begin(), vec.end(), by_two_criteria(compare_group, compare_value));
copy(vec.begin(), vec.end(), ostream_iterator<X>(cout, "\n"));
}
只是为了好玩，这里有一个函数对象，它结合了 n 个比较条件（仅适用于C++0x的可变模板和新式初始化语法）：
#include <functional>
template <class T, class ...Fun>
class n_criteria_t {};
template <class T, class Fun1, class ...FunN>
class n_criteria_t<T, Fun1, FunN...>: public std::binary_function<T, T, bool>
{
public:
n_criteria_t(Fun1 f1, FunN... fn): f1(f1), f2(fn...) {}
bool operator() (const T& a, const T& b) const
{
return f1(a, b) || (!f1(b, a) && f2(a, b));
}
private:
Fun1 f1;
n_criteria_t<T, FunN...> f2;
};
template <class T, class Fun1>
class n_criteria_t<T, Fun1>: public std::binary_function<T, T, bool>
{
public:
n_criteria_t(Fun1 f1): f1(f1) {}
bool operator() (const T& a, const T& b) const
{
return f1(a, b);
}
private:
Fun1 f1;
};
template <class T, class ...Fun>
n_criteria_t<T, Fun...> n_criteria(Fun... f)
{
return {f...};
}
- UncleBens
0
您可以使用partition或stable_partition将对象分成几个集合并单独对它们进行排序。我不确定它会更快还是更慢，但在我看来，代码会稍微更易于理解。
class GroupPredicate : std::unary_function<object, bool>
{
public:
GroupPredicate(INT group)
: m_group(group)
{
}
inline bool operator()(const object &object)
{
return object.group == m_group;
}
INT m_group;
};
class SizeSort : public std::binary_function<object, object, bool>
{
public:
inline bool operator()(const object &left, const object &right)
{
return left.size < right.size;
}
};
//...
std::vector<object> arVector;
for (INT i = 0; i < groupCount; ++i)
{
std::vector<object>::iterator pEndGroup = std::partition(pStartGroup, arVector.end(), GroupPredicate(i));
std::sort(pStartGroup, pEndGroup, SizeSort());
pStartGroup = pEndGroup;
}
- Eugene
网页内容由stack overflow 提供, 点击上面的可以查看英文原文，
原文链接
原文链接
std::map比较器）的地方重用它们。名称是随意的，这正是因为没有足够的输入信息来想出一个好的名称 :) - Pavel Minaevstruct，从而有效地创建一个本地函数。 - Frerich Raabe