std::map，自定义键类型，仅对一个变量进行排序

Question

我有一个密钥类型：

struct KeyT {
    uint32_t timestamp;

    // example!
    uint32_t a;
    uint32_t b;
    uint32_t c;
    uint32_t d;
    uint32_t e;
    // ...

    bool operator== (const KeyT& key) const
    {
        if(timestamp == key.timestamp && a == key.a && b == key.b && d == key.d && c == key.c && e == key.e)
            return true;
        return false;

    }
    bool operator< (const KeyT& key) const
    {
        if(timestamp < key.timestamp)
            return true;
        else if(timestamp == key.timestamp && a < key.a && b < key.b && c < key.c && d < key.d && e < key.e)
            return true;
        else if(timestamp == key.timestamp && a == key.a && b < key.b && c < key.c && d < key.d && e < key.e)
            return true;
        else if(timestamp == key.timestamp && a == key.a && b == key.b && c < key.c && d < key.d && e < key.e)
            return true;
        else if(timestamp == key.timestamp && a == key.a && b == key.b && c == key.c && d < key.d && e < key.e)
            return true;
        else if(timestamp == key.timestamp && a == key.a && b == key.b && c == key.c && d == key.d && e < key.e)
            return true;
        // ..
        return false;
    }
};

现在，我并不真正关心成员变量 a、b、c、d、e 的排序，我唯一要确保的是地图按时间戳排序。我也刚刚意识到，如果我有两个 KeyT 实例一，二，除了“d”之外一切都相同，那么一

谢谢！

Answer 1

我认为这可以满足您的需要：

bool operator< (const KeyT& key) const
{
    if(timestamp != key.timestamp) return timestamp < key.timestamp;
    else if ( a != key.a ) return a < key.a;
    else if ( b != key.b ) return b < key.b;
    else if ( c != key.c ) return c < key.c;
    else if ( d != key.d ) return d < key.d;
    else return e < key.e;
}

当您有一个要在可比较的类中排序的变量的优先列表时，这是一个明智但丑陋的模式。

Answer 2

首先，您应该只比较下一个尚未比较的当前键小于，并在return 之后删除else，如下所示：

bool operator< (const KeyT& key) const
{
    if(timestamp < key.timestamp)
        return true;
    if(timestamp == key.timestamp && a < key.a)
        return true;
    if(timestamp == key.timestamp && a == key.a && b < key.b)
        return true;
    if(timestamp == key.timestamp && a == key.a && b == key.b && c < key.c)
        return true;
    if(timestamp == key.timestamp && a == key.a && b == key.b && c == key.c && d < key.d)
        return true;
    if(timestamp == key.timestamp && a == key.a && b == key.b && c == key.c && d == key.d && e < key.e)
        return true;
    // ..
    return false;
}

如果只需要比较时间戳，留下第一个if，其余的删除：

bool operator< (const KeyT& key) const
{
    return timestamp < key.timestamp;
}

当您使用此运算符比较您的密钥时，具有相同时间戳的项目不会被重新排序。

Answer 3

如果您只关心时间戳，而其他属性无关紧要，您可以使用以下严格的弱排序。你永远不会知道相同时间戳的对象会出现什么顺序：

bool operator< (const KeyT& key) const
{
    return timestamp < key.timestamp;
}

如果您需要订购我建议的所有属性boost::tie：

bool operator< (const KeyT& key) const
{
    return boost::tie(timestamp, a, b, c, d, e) < boost::tie(key.timestamp, key.a, key.b, key.c, key.d, e.key);
}