C++ 使用列表迭代器排序

问题：我有一个要在每个周期渲染的对象列表，但我希望按照y位置的顺序渲染它们，y位置是可变的

这是我的清单声明

std::list<Object *> objects;
std::list<Object *>::iterator iter;
std::list<Object *>::iterator iter2;

---

我想按y值的降序渲染对象。我想我真正的问题是如何对这个列表进行排序。

std:：list

有一个排序函数，您可以将一个比较器传递给它，因此请编写如下其中一个函数：

bool compareByGreaterY(const Object * lhs, const Object * rhs)
{
    return lhs->GetY() > rhs->GetY();
}

objects.sort(compareByGreaterY);

然后您可以对列表进行如下排序：

bool compareByGreaterY(const Object * lhs, const Object * rhs)
{
    return lhs->GetY() > rhs->GetY();
}

objects.sort(compareByGreaterY);

---

std:：list

有一个排序函数，您可以将一个比较器传递给它，因此请编写如下其中一个函数：

bool compareByGreaterY(const Object * lhs, const Object * rhs)
{
    return lhs->GetY() > rhs->GetY();
}

objects.sort(compareByGreaterY);

然后您可以对列表进行如下排序：

bool compareByGreaterY(const Object * lhs, const Object * rhs)
{
    return lhs->GetY() > rhs->GetY();
}

objects.sort(compareByGreaterY);

---

首先，为什么要使用列表？这几乎总是一个糟糕的选择。为什么要使用指针容器？这比使用

list

更为频繁，但我们仍然只讨论了0.05%的时间，而不是0.02%。谁知道呢，在这种情况下，它甚至可能是最好的

不管怎样，我们暂时假设，出于某种原因，这些确实是有道理的。我还假设您不能修改原始集合（不清楚这是否为真——如果不是，只需跳过复制它，并对原始集合进行排序——但是如果出于某种原因不需要维护顺序，几乎可以肯定您并不真的想要列表

在这些假设下，您可能希望复制集合，对其排序，然后呈现：

struct descY { 
    bool operator()(Object const *a, Object const *b) { 
        return b.GetY() < a.GetY();
    }
};

std::vector<Object *> sorted(objects.begin(), objects.end());
std::sort(sorted.begin(), sorted.end(), descY());

struct descY{
布尔运算符（）（对象常量*a，对象常量*b）{
返回b.GetY（）

如果您有可用的C++11，可以使用lambda将其缩短一点，并将逻辑保持在更容易看到发生了什么的位置，而无需在代码中寻找比较：

std::vector<Object *> sorted(objects.begin(), objects.end());
std::sort(sorted.begin(), sorted.end(), 
          [](Object const *a, Object const *b) { return b->GetY() < a->GetY();});

std:：向量排序（objects.begin（），objects.end（））；
排序（sorted.begin（），sorted.end（），
[]（对象常量*a，对象常量*b）{返回b->GetY（）GetY（）；}）；

---

请注意，为了获得降序，我们在比较中颠倒了通常的顺序。

首先，为什么要使用列表？这几乎总是一个糟糕的选择。为什么要使用指针容器？这有一个很好的理由，比使用

列表

更频繁一些，但我们仍然只讨论了0.05%的时间而不是0.02%。谁知道呢——在这种情况下，这可能是最好的结果

不管怎么说，我们暂时假设，出于某种原因，这些确实是有意义的。我还将假设您不能修改原始集合（不清楚这是不是真的——如果不是，就跳过复制它，对原始集合进行排序——但是如果出于某种原因不需要维护顺序，几乎可以肯定的是，它并不真的想要一个列表

在这些假设下，您可能希望复制集合，对其排序，然后呈现：

struct descY { 
    bool operator()(Object const *a, Object const *b) { 
        return b.GetY() < a.GetY();
    }
};

std::vector<Object *> sorted(objects.begin(), objects.end());
std::sort(sorted.begin(), sorted.end(), descY());

struct descY{
布尔运算符（）（对象常量*a，对象常量*b）{
返回b.GetY（）

如果您有可用的C++11，可以使用lambda将其缩短一点，并将逻辑保持在更容易看到发生了什么的位置，而无需在代码中寻找比较：

std::vector<Object *> sorted(objects.begin(), objects.end());
std::sort(sorted.begin(), sorted.end(), 
          [](Object const *a, Object const *b) { return b->GetY() < a->GetY();});

std:：向量排序（objects.begin（），objects.end（））；
排序（sorted.begin（），sorted.end（），
[]（对象常量*a，对象常量*b）{返回b->GetY（）GetY（）；}）；

注意，为了得到降序，我们在比较中颠倒了通常的顺序