c++ - 键比较的最佳方法(C++ 映射)

Question

在使用 map 时，我有时会遇到一些问题，因为我在定义用于使用我自己的数据类型插入到 map 中的比较函数时会遇到一些问题。例如，目前我有这样的结构:

typedef struct triple_key{
    int int_key;
    struct some_data;
    unsigned char char_array_key[16];
}triple_key;

some_data 是这样的:

struct some_data{
    int data_length;
    unsigned char* data;
}

为了进行比较，我覆盖了 operator()，我的想法是执行以下操作:

class comp_triple_key{
public:
bool operator()(const triple_key &x, const triple_key &y){
    if(x.int_key!= y.int_key){
        return x.int_key<y.int_key;
    }
    else{
       if(memcmp((x.some_data).data, (y.some_data).data, (x.some_data).data_length) != 0){
          return memcmp((x.some_data).data, (y.some_data).data, (x.some_data).data_length) < 0;
       }
       else{
           return memcmp((x.char_array_key), (y.char_array_key), 16*sizeof(char))<0;
       }
   }
};

};

那么 map 会变成这样:

 std::map<triple_key,int,comp_triple_key> my_map;

是否有更好的方法来比较这多个键值？在大多数情况下，这是有效的(并且工作正常)，但有时我会得到这样的断言:

Expression: invalid operator <

我过去曾处理过这个问题，但我不清楚一般情况下如何避免它，或者处理此类问题以确保它适用于每种情况的常用方法是什么。

Answer 1

有几件事要做:

• 而不是定义比较器类(在你的例子中是 comp_triple_key)，定义 operator<对于三键

像这样的东西可以工作:

  bool operator<(const triple_key &x, const triple_key &y){
    if(x.int_key!= y.int_key){
        return x.int_key<y.int_key;
    }
    else{
       if(memcmp((x.somedata).data, (y.somedata).data, (x.somedata).data_length) != 0){
          return memcmp((x.somedata).data, (y.somedata).data, (x.somedata).data_length) < 0;
       }
       else{
           return memcmp((x.char_array_key), (y.char_array_key), 16*sizeof(char))<0;
       }
    }
  }

然后你可以创建像这样的对象:

std::map<triple_key,int> my_map;

---

可编译示例(问题中的固定代码):

#include <map>
#include <iostream>
#include <string>
#include <string.h>


struct some_data{
    int data_length;
    unsigned char* data;
};

struct triple_key{
    int int_key;
    some_data somedata ;
    unsigned char char_array_key[16];
};

  bool operator<(const some_data &x, const some_data &y){
    if(x.int_key!= y.int_key){
        return x.int_key<y.int_key;
    }
    else{
       if(memcmp((x.somedata).data, (y.somedata).data, (x.somedata).data_length) != 0){
          return memcmp((x.somedata).data, (y.somedata).data, (x.somedata).data_length) < 0;
       }
       else{
           return memcmp((x.char_array_key), (y.char_array_key), 16*sizeof(char))<0;
       }
    }
  }

  bool operator<(const triple_key &x, const triple_key &y){
    if(x.int_key!= y.int_key){
        return x.int_key<y.int_key;
    }
    else{
       if(memcmp((x.somedata).data, (y.somedata).data, (x.somedata).data_length) != 0){
          return memcmp((x.somedata).data, (y.somedata).data, (x.somedata).data_length) < 0;
       }
       else{
           return memcmp((x.char_array_key), (y.char_array_key), 16*sizeof(char))<0;
       }
    }
  }

int main()
{
    std::map<triple_key,int> my_map;
}