Question

我正在从Foo类型的数据库中读取对象，如下所述。该对象是Foo成员的向量，其中Foo成员由字符串id和容器对象组成。

typedef std::pair<std::string, Container> FooMember;
typedef std::vector<FooMember> Foo;

我希望以其排序形式迭代一个Foo对象，其中对id进行排序。为此，我使用以下函数首先创建对象的排序版本。如您所见，对象以不区分大小写的方式排序。与我目前的做法相比，我有更好的方法来迭代这个对象吗？

Foo sortedFoo(Foo& value) const {
    Foo returnValue;
    returnValue.reserve(value.size());

    // use a map to sort the items
    std::map<std::string, FooMember> sortedMembers;
    {
        Foo::iterator i = value.begin();
        Foo::iterator end = value.end();
        for(; i!=end; ++i) {
            std::string name = i->first;
            boost::algorithm::to_lower(name);
            sortedMembers[name] = *i;
        }
    }

    // convert the map to a vector of its values in sorted order
    std::map<std::string, FooMember >::iterator i = sortedMembers.begin();
    std::map<std::string, FooMember >::iterator end = sortedMembers.end();
    for(; i!=end; ++i) {
        returnValue.push_back(i->second);
    }
    return returnValue;
}

Answer 1

是：复制向量，然后将std::sort与自定义比较谓词一起使用：

struct ByIdCaseInsensitive {
  bool operator ()(const FooMember& lhs, const FooMember& rhs) const {
    return boost::algorithm::to_lower_copy(lhs.first) <
           boost::algorithm::to_lower_copy(rhs.first);
  }
};

比填充地图更有效，然后复制回矢量。

如果使用正确的Unicode排序规则算法，谓词会更好，但在标准库或Boost中不可用。

Answer 2

最好的方法是将std::sort与FooMembers的自定义比较器一起使用：

bool cmp(const FooMember& lhs, const FooMember& rhs);

Foo sortedFoo(const Foo& value) const
{
  Foo tmp = value;
  return std::sort(tmp.begin(), tmp.end(), cmp);
}

可以在std::lexicographical_compare和tolower的帮助下实施比较：

#include <cctype> // for std::tolower

bool ci_cmp(char a, char b)
{
  return std::tolower(a) < std::tolower(b);
}

#include <algorithm> // for std::sort, std::lexicographical_compare

bool cmp(const FooMember& lhs, const FooMember& rhs) 
{
  return std::lexicographical_compare(lhs.first.begin(),
                                      lhs.first.end(),
                                      rhs.first.begin(),
                                      rhs.first.end(),
                                      ci_cmp);
}

Answer 3

您可以使用std::sort

#include <algorithm>

bool comparator(const FooMember& i, const FooMember& j)
{
    std::string str1 = i.first;
    boost::algorithm::to_lower(str1);
    std::string str2 = j.first;
    boost::algorithm::to_lower(str2);
    return (str1 < str2); 
}

void sortFoo(Foo& value) {
    std::sort (value.begin(), value.end(), comparator);
}

或者，您可以从Foo开始将std::map<std::string, Foo>个对象保留在{{1}}中，以便始终对其进行排序。

Answer 4

您还可以将std :: sort与lambda表达式一起使用：

std::sort(value.begin(), value.end(), [](const FooMember &lhs, const FooMember &rhs)
{
    std::string str1 = i.first, str2 = j.first;
    boost::algorithm::to_lower(str1);
    boost::algorithm::to_lower(str2);
    return str1 < str2; 
});

或使用erelender提供的版本。它取决于你。

Answer 5

语义std::vector<std::pair<T,U> >是std::map<T,U>（但实现通常不同）。如果你可以重新设计Foo，你最好这样做。作为副作用，您将免费进行分类。

typedef std::map<std::string, Container> Foo;

在std :: vector <std :: pair <t，u>＆gt;上以排序方式迭代对象</性病::对<T，U>

5 个答案: