我有一个 vector
struct Data {
size_t iLo;
size_t iHi;
};
我想分别对 iLo
和 iHi
的值进行排序,即如果我对 iLo
成员进行排序
'iHi'成员没有被触及。 iLo
是升序排列的,iHi
是降序排列的。例如:
{{1, 3}, {4, 66}, {0, 0}, {0, 1}};
首先按 iLo
升序排序会给我
{{0, 3}, {0, 66}, {1, 0}, {4, 1}};
然后对 iHi
进行降序排序会导致
{{0, 66}, {0, 3}, {1, 1}, {4, 0}};
我想这样做的原因是我正在处理大量数据并且可能没有足够的 RAM 将原始数组数据拆分为两个新数据。我想试试 先到位。
我不能使用 Boost,只能使用 c++03。
最佳答案
你必须写一个 random access iterator给你的vector<Data>
,返回对 iLo(或 iHi,resp.)的引用。
完整示例:
#include <vector>
#include <algorithm>
#include <iterator>
#include <functional>
#include <iostream>
using namespace std;
struct Data {
Data(size_t l, size_t h) : iLo(l), iHi(h) {}
size_t iLo;
size_t iHi;
};
// `MyIter` is the base for your iterators that return i->iLo / i->iHi.
template <class Impl> // Impl is the actual iterator type.
struct MyIter : public iterator<random_access_iterator_tag, size_t>
{
typedef vector<Data>::iterator Base;
Base base;
MyIter(Base i) : base(i) {}
// These are common operators that you have to define in GNU's std::sort.
// The standard actually requires more operators, see
// http://en.cppreference.com/w/cpp/concept/RandomAccessIterator
bool operator !=(const Impl &rhs) const {
return base != rhs.base;
}
bool operator ==(const Impl &rhs) const {
return base == rhs.base;
}
bool operator <(const Impl &rhs) const {
return base < rhs.base;
}
bool operator >(const Impl &rhs) const {
return base > rhs.base;
}
bool operator >=(const Impl &rhs) const {
return base >= rhs.base;
}
bool operator <=(const Impl &rhs) const {
return base <= rhs.base;
}
ptrdiff_t operator -(const Impl &rhs) const {
return base - rhs.base;
}
Impl operator +(ptrdiff_t i) const {
return base + i;
}
Impl operator -(ptrdiff_t i) const {
return base - i;
}
Impl &operator ++() {
++base;
return static_cast<Impl&>(*this);
}
Impl &operator --() {
--base;
return static_cast<Impl&>(*this);
}
Impl &operator +=(size_t n) {
base += n;
return static_cast<Impl&>(*this);
}
Impl &operator -=(size_t n) {
base -= n;
return static_cast<Impl&>(*this);
}
};
struct MyLoIter : public MyIter<MyLoIter>
{
MyLoIter(Base i) : MyIter(i) {}
size_t &operator [](int i) {
return base[i].iLo;
}
size_t &operator *() {
return base->iLo;
}
};
struct MyHiIter : public MyIter<MyHiIter>
{
MyHiIter(Base i) : MyIter(i) {}
size_t &operator [](int i) {
return base[i].iHi;
}
size_t &operator *() {
return base->iHi;
}
};
int main() {
// I like C++11 a lot better ...
vector<Data> data;
data.push_back(Data(1, 3));
data.push_back(Data(4, 66));
data.push_back(Data(0, 0));
data.push_back(Data(0, 1));
// This is the actual sorting, first the iLo part, then the iHi part.
// std::less and std::greater are used to sort descending and ascending-
sort(MyLoIter(data.begin()), MyLoIter(data.end()), less<size_t>());
sort(MyHiIter(data.begin()), MyHiIter(data.end()), greater<size_t>());
// Now the test if it worked:
for (vector<Data>::iterator i = data.begin(); i != data.end(); ++i) {
cout << i->iLo << "\t" << i->iHi << endl;
}
return 0;
}
关于c++ - C+ 对 vector 元素的各个成员进行排序,我们在Stack Overflow上找到一个类似的问题: https://stackoverflow.com/questions/15318412/