如何实现像“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

如何实现类似“QHash bar”的数据结构；在哪里 “bar[10]”返回所有属于 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（更多工作）。