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

我有一个密钥类型：

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

结构键{
uint32_t时间戳；
//榜样！
uint32_t a；
uint32_t b；
uint32_t c；
uint32_t d；
uint32_t e；
// ...
布尔运算符==（常数键和键）常数
{
if（timestamp==key.timestamp&&a==key.a&&b==key.b&&d==key.d&&c==key.c&&e==key.e）
返回true；
返回false；
}
布尔运算符<（常数键和键）常数
{
if（时间戳<键时间戳）
返回true；
else if（timestamp==key.timestamp&&a

现在，我并不真正关心对成员变量a、b、c、d、e的排序，我只想确保映射是按时间戳排序的。我还刚刚意识到，如果我有两个KeyT one，two的实例，其中除了“d”之外，所有东西都是相同的，那么1<2和2<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;
}

bool运算符<（常数键和键）常数
{
if（timestamp！=key.timestamp）返回timestamp

---

这是一个合理的模式，如果你想在一个可比较的类中对变量进行排序，那么只要你有一个优先排序的列表，就可以使用它。

我认为这就是你需要的：

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

bool运算符<（常数键和键）常数
{
if（timestamp！=key.timestamp）返回timestamp

---

这是一个合理的模式，如果在一个可比较的类中有一个优先排序的变量列表，就可以使用它。

首先，您应该只比较下一个未被比较的小于的当前键，然后在

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

---

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

首先，您应仅比较未比较的下一个小于的当前密钥，并在

返回
后删除
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;
}

当您使用此运算符比较密钥时，具有相同时间戳的项将不会重新排序。
如果您只关心时间戳，而其他属性并不重要，则可以使用以下严格的弱排序。您永远不会知道相同时间戳的对象的显示顺序：

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

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

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

如果您有相同的项目，那么“一<二”和“二<一”的定义总是错误的。你能澄清这个问题吗？它们不相同，它们在成员变量d中不同。如果你有相同的项，那么“一<二”和“二<一”在定义上总是错误的。你能澄清这个问题吗？它们不一样，它们在成员变量d上不同。这也行得通，但它提供了Alex的答案吗？@KimSun wu不，这只是书写相同条件的不同方式。阅读起来可能更自然一些，因为它可以被翻译成人类语言，与人们在排序顺序中考虑解决关系时使用的术语完全相同，但除此之外，两者应该产生相同的结果。也许只有我一个人，但我发现Alex的版本更简单/更直观。这也很有效，但是它提供了亚历克斯的答案吗？@KimSun wu不，这只是一种写同样条件的不同方式。阅读起来可能更自然一些，因为它可以被翻译成人类语言，与人们在排序顺序中考虑解决关系时使用的术语完全相同，但除此之外，这两者应该产生相同的结果。也许只是我，但我发现Alex的版本更简单/更直观，这正是我想要的！我知道我错过了一些明显的东西。很高兴能为你服务。我已经写过好几次了。顺便说一下，它可以用来做这类事情。它在tuple_comparison.hpp中有一个排序函数，可以按元素排序。我经常使用它对数据进行快速而肮脏的排序，而不需要编写新的类或排序函数。我会将它打包到
std:：binary_function
类中，并将其添加为模板参数。@Naszta:我不认为这会使它更不冗长？@KimSun wu:.正是我想要的！我知道我错过了一些明显的东西。很高兴能为你服务。我已经写过好几次了。顺便说一下，它可以用来做这类事情。它在tuple\u comparison.hpp中有一个排序函数