如何实现像"QHash<int，Foo bar;“这样的数据结构，其中"bar[10]”返回属于10或更少的键的所有"Foo“？

Question

它不一定是一个QHash；只需要一个现有的数据结构(理想情况下是在Qt中)，它可以干净利落地完成这项任务，而不被认为是深奥的解决方案，因为我需要这段代码非常简短(适合一张小扑克牌)，并且易于理解。向量、多哈希、列表、映射或任何东西都是受欢迎的，只要它们被认为是良好的实践。

基本上，我有一个类，它有一个整数值与之关联。例如：

class Flowers { 
public: 
    const int m_Cost; 
    Flowers(int cost) { m_Cost = cost; }
}

Flowers roses{5};
Flowers violets{7};
Flowers tulips{9};
Flowers posies{3};

/* Place them in some sort of datastructure. */

flowerDataStructure[4]; // Returns Posies
flowerDataStructure[7]; // Returns Violets, Roses, Posies
flowerDataStructure[roses.m_Cost]; // Returns Roses, Posies

它们可能会支持一个范围，例如，

flowerDataStructure[5 ... 11]; // Returns Roses, Violets, Tulips

PS：int m_Cost;不一定要为const。我只是觉得如果是这样的话会更容易。

谢谢。

Answer 1

如何实现像“Foo bar；”这样的数据结构，其中“bar10”返回属于10或更少的键的所有“Foo”？

对于按整数值排序的非唯一项的集合，正确的数据结构应该是std::multimap或std::multiset，这取决于我们存储键的方式。根据作者上面的示例，键与数据类型一起存储，因此我选择了std::multiset

#include <set>
#include <string>
#include <QDebug>

struct Flower
{
public:
    const int m_cost;
    const std::string m_name;

    explicit Flower(int cost) : m_cost(cost) {}
    Flower(const char* name, int cost) : m_cost(cost), m_name(name) {}
};


int main()
{
    auto lessFunc = [](const Flower& l, const Flower& r) -> bool
                    {return l.m_cost < r.m_cost;};

    std::multiset<Flower, decltype(lessFunc)> multiSet(lessFunc);

    multiSet.emplace("roses", 5);
    multiSet.emplace("violets", 7);
    multiSet.emplace("tulips", 9);
    multiSet.emplace("posies", 3);

    // This is a request for items equal or below 7
    const auto& itEnd = multiSet.upper_bound(Flower{7});

    for(auto it = multiSet.begin(); it != itEnd; it++)
    {
        const Flower& flower{*it};
        qDebug() << flower.m_name.c_str() << flower.m_cost;
    }

    return 0;
}

​

​

如果操作符upper_bound需要，那么它可以完成，但我们必须重载std::multiset (更多工作)。