1

我有一个密钥类型：

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

谢谢！

4

3 回答 3

6

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

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

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

于 2012-07-03T19:13:35.323 回答
1

首先，您应该只比较下一个尚未比较小于的当前键，并删除elseafter 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;
}

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

于 2012-07-03T19:15:55.850 回答
0

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

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);
}
于 2012-07-03T19:32:34.027 回答