二进制表达式的无效操作数（常量点和常量点

Question

    map<pair<int,int>,int>pairOfNumbers;
pairOfNumbers.insert(pair<pair<int,int>,int>({1,2},2));

this is working, but

    map<pair<point,point>,int>PointsOnLine;
PointsOnLine.insert(pair<pair<point,point>,int>(make_pair(points[i],points[j]),count));

this doesn't.

point is just a structure of two ints x and y; I keep getting the error 'Invalid Operands to binary expression(const point and const point' this is the structure of point.

    struct point
{
    int x;
    int y;
public:
    bool operator==(const point& p)
    {
        if(x==p.x && y==p.y)
            return true;
        else
            return false;
    }
    bool operator!=(const point& p)
    {
        if(x==p.x &&y==p.y)
            return false;
        else
            return true;
    }
};

how do I insert two points and distance between them in the map? in Xcode I get this error

Answer 1

Your point type does not support weak-ordering. It has no method of determining is-less-than. You may think you don't need that because your point is actually tucked into a std::pair<point,point> but you do.

std::pair<T1,T2> supports weak ordering only if T1 and T2 do. In your case, they're the same type, so for a std::pair<point,point> to be used as key in a std::map<std::pair<point,pint>,T> , point must support weak ordering.

To support weak ordering, you must either provide an operator< that compares two of your objects in question, or a comparator functor type that does the same thing. The easiest way for you to do this would be:

#include <tuple>

struct point
{
    int x;
    int y;

    bool operator <(const point& p) const
    {
        return std::tie(x, y) < std::tie(p.x, p.y);
    }

    bool operator ==(const point& p) const
    {
        return !(*this < p || p < *this);
    }

    bool operator !=(const point& p) const
    {
        return *this < p || p < *this;
    }
};

I took liberty to redefine operator == and operator != to utilize the weak order properties of the proper operator < . It wasn't necessary, but ultimately it's just easier if operators root to as basic code as possible. With the above change you should be able to use both point and std::pair<point,point> as key types in std::map and std::set . In truth, a strict weak ordering can define all of the basic comparators (<=, >, >=, ,=, ==) as derivations from operator < in one form or another (or relative to something that does). I challenge you to consider them, try implementing them, and above all, writing some test harnesses that verify your implementation.