Operator for Multiple Points in One Struct - c++

Question

I have a struct that stores two points that should be interchangeable.
struct Edge
{
unsigned short firstIndex;
unsigned short secondIndex;
Edge(unsigned short firstIndex, unsigned short secondIndex) :
firstIndex(firstIndex), secondIndex(secondIndex) {}
};
The operator== method should be as follows (To make them interchangeable)
bool operator == (const Edge& e2) const
{
return
first == e2.first && second == e2.second ||
first == e2.second && second == e2.first;
}
I am looking to create an operator< and operator> method in order to use the struct in a std::map
I have tried the following (using multiplication) but it does not work since there are many cases in which different edges return the same value
bool operator < (const Edge& e2) const
{
return first * second < e2.first * e2.second;
}
The code that I would like to use is the following:
std::map<Edge, unsigned int> edgePoints;
Edge e1(0, 1);
Edge e2(1, 2);
Edge e3(2, 0);
edgePoints[e1] = 2;
edgePoints[e2] = 0;
edgePoints[e3] = 1;
Although the code does not work with my operator< method because 0 * 1 == 2 * 0 so the map returns 2 when I call edgePoints[e3]
Does anyone know of an operator< and operator> method that I could use or even some other way of mapping the edges in order to use the std::map

Answer 1

I would store the indices of the edge in such a way, that the smaller index always is the first index. It looks like the internal representation is irrelevant in your application. You don't need operator== for maps. Here is the example struct:
struct Edge
{
typedef unsigned short Idx; // prefer strong typedef cf boost
Edge(Idx a, Idx b)
:
firstIndex(std::min(a, b)),
secondIndex(std::max(a, b))
{}
Idx firstIndex;
Idx secondIndex;
bool operator<(Edge const & other)
{
if (firstIndex != other.firstIndex)
return firstIndex < other.firstIndex;
return secondIndex < other.secondIndex;
}
}; // Edge
If you want to make your implementation even nicer, some minor suggestions:
Prefer std::array<unsigned short, 2> over separate variables firstIndex and secondIndex. Doing so allows iterating over the indices.
If you are using array, you can shorten the operator< using std::lexicographical_compare.

Answer 2

Consider compairing them as sorted pairs.
bool operator < (const Edge& e2) const
{
if (min(first, second) != min(e2.first, e2.second))
return min(first, second) < min(e2.first, e2.second);
return max(first, second) < max(e2.first, e2.second);
}
Edit: Of course that can be written nicelier with saving mins and maxes as local variables, but the idea should be clear.
Edit: The idea in other answer is better: force your struct to always have first less then second, and it will eliminate all mins and maxes, and make comparation run fast like hell)