如果没有逻辑方法定义比较运算符，如何将自定义类用作std :: map的键？

Question

I'm trying to use std::map with a custom class and in the course of the process the program has to call std::map::find in order to resolve a key to a pair. The custom class doesn't seem to fit well in terms of comparisons.

This is probably better explained in code; I have a class that I want to use as a key:

 class index_t
    {
       int vertex_index;
       int normal_index;
       int texture_index;
     }

     std::map<index_t, int> reindexer;

I would like to use

   reindexer.find(index_to_find);

In order to find a key with exactly same parameters (exactly same vertex/normal/texture indices) exists in the map already.

So technically I want the std::map::find function to behave like this:

bool find(key_to_find) //this is what I'm expecting from a find function of std::map
{
    if(existing_key.vertex == key_to_find.vertex && existing_key.texture == key_to_find.texture && existing_key.normal == key_to_find.normal)
         return true;
    else return false;
}

However, I'm not sure how to overload the comparison operator appropriately in this situation for it to behave like that (since I can think of no logical less than operator that would suit this class). This is the current operator I'm using:

   bool operator<(const index_t& rhv)
   {
     if(vertex_index < rhv && normal_index < rhv && texture_index < rhv)
       return true;
     else return false;
    }

It doesn't work, since the find relies on the function returning "false" reflexively when comparison orders reversed.

How can I get around this?

This is some more specific, compilable code that reproduces the problem:

 class index_t
     {
     public:
    int vertex;
    int normal;
    int texture;

    bool operator< (const index_t& rhv) const
    {
        if (vertex < rhv.vertex && normal < rhv.normal && texture < rhv.texture)
            return true;
        else return false;
    }
};



map<index_t, int> indexMap;

int main()
{
    index_t i;
    i.vertex = 0;
    i.normal = 0;
    i.texture = 0;

    index_t i2;
    i2.vertex = 1;
    i2.normal = 0;
    i2.texture = 3;

    index_t i4;
    i4.vertex = 1;
    i4.normal = 0;
    i4.texture = 3;

    index_t i5;
    i5.vertex = 6;
    i5.normal = 0;
    i5.texture = 3;

    index_t i8;
    i8.vertex = 7;
    i8.normal = 5;
    i8.texture = 4;

    indexMap.insert(pair<index_t, int>(i, 0));
    indexMap.insert(pair<index_t, int > (i2, 1));


    if (indexMap.find(i5) != indexMap.end())
        cout << "found" << endl;
    else
        cout << "not found" << endl;

    system("pause");
    return 0;
} 

This results in "found" even though i5 is not a part of the map

I also tried this:

class index_t
{
public:
    int vertex;
    int normal;
    int texture;
};

class index_comparator
{
public: 
    bool operator()(const index_t& lhv, const index_t& rhv) const
    {
        if (lhv.vertex == rhv.vertex && lhv.normal == rhv.normal && lhv.texture == rhv.texture)
            return true;
        else return false;
    }
};

map<index_t, int, index_comparator> indexMap;

int main()
{
    index_t i;
    i.vertex = 0;
    i.normal = 0;
    i.texture = 0;

    index_t i2;
    i2.vertex = 1;
    i2.normal = 0;
    i2.texture = 3;

    index_t i4;
    i4.vertex = 1;
    i4.normal = 0;
    i4.texture = 3;

    index_t i5;
    i5.vertex = 6;
    i5.normal = 0;
    i5.texture = 3;

    index_t i8;
    i8.vertex = 7;
    i8.normal = 5;
    i8.texture = 4;

    indexMap.insert(pair<index_t, int>(i, 0));
    indexMap.insert(pair<index_t, int > (i2, 1));


    if (indexMap.find(i5) != indexMap.end())
        cout << "found" << endl;
    else
        cout << "not found" << endl;

    system("pause");
    return 0;
}

This also results in "found"

The expected results are that when I call std::map::find on a custom class it compares it other keys in the map and only returns true if an exactly same class (containing the same parameters) exists. Otherwise it should return false.

Answer 1

You have to define a strict order to use class index_t as key in a std::map .

It doesn't need to make sense to you – it just has to provide a unique result of less-than for any pairs of index_t instances (and to grant a < b && b < c => a < c).

The (in question) exposed attempt doesn't seem to fulfil this but the following example would:

bool operator<(const index_t &index1, const index_t &index2)
{
  if (index1.vertex != index2.vertex) return index1.vertex < index2.vertex;
  if (index1.normal != index2.normal) return index1.normal < index2.normal;
  return index1.texture < index2.texture;
}

Answer 2

Your comparison function doesn't have to be logical, it just has to impose a strict weak ordering . Here's a version that works.

bool operator<(const index_t& rhv) const
{
    if (vertex < rhv.vertex)
        return true;
    if (vertex > rhv.vertex)
        return false;
    if (normal < rhv.normal)
        return true;
    if (normal > rhv.normal)
        return false;
    if (texture < rhv.texture)
        return true;
    if (texture > rhv.texture)
        return false;
    return false;
}

Since this is not a reasonable operator< for your class it would be better to rename it, to avoid confusion.

struct IndexLT
{
    bool operator()(const index_t& lhs, const index_t& rhs)
    {
        // logic as before
    }
};

Then use this newly declared functor like this

std::map<index_t, whatever, IndexLT> my_map;

Yet another alternative would be to use a std::unordered_map since ordering doesn't seem to be significant.

Answer 3

Your ordering doesn't fulfill the requirements, it has to be what is called a "strict weak ordering relation". It's easiest to not implement that yourself, but instead use existing functionality. Examle:

#include <tuple>

bool operator()(const index_t& lhv, const index_t& rhv) const
{
    return std::tie(lhv.vertex, lhv.normal, lhv.texture) <
       std::tie(rhv.vertex, rhv.normal, rhv.texture);
}

Answer 4

The simplest way to implement the operator is with tuples, it does all the hard work for you:

bool operator<(const index_t& rhv)
{
   return std::tie(vertex_index, normal_index, texture_index) < std::tie(rhv.vertex_index, rhv.normal_index, rhv.texture_index);
}

This is equivalent to the required logic:

bool operator<(const index_t& rhv)
{
   if (vertex_index != rhv.vertex_index)
   {
      return vertex_index < rhv.vertex_index;
   }
   if (normal_index!= rhv.normal_index)
   {
      return normal_index< rhv.normal_index;
   }
   return texture_index< rhv.texture_index;
}

In c++20 this gets even easier with the spaceship operator which does everything for you:

auto operator<=>(const index_t&) const = default;