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”之外一切都是相同的，那么两个＆lt;两个，两个＆lt;一个人会是假的。解决这个问题的唯一方法是为所有成员变量的所有可能组合编写比较。我很确定我错过了一些明显的东西，那么在这种情况下最好的解决方案是什么？

谢谢！

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

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

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);
}

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

3 个答案: