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

有几件事要做:

• 定义 operator< ，而不是定义比较器类(在您的情况下为 comp_triple_key )对于 Triple_key

类似这样的东西:

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