incorrect function call on overload operator

Question

In the code, why is (10 != i) calling == instead of !=? The other two call !=

#include <iostream>

class Integer
{
  int x;

public:
  bool
  operator== (const Integer &i)
  {
    std::cout << "==";
    return x == i.x;
  }
  bool
  operator!= (const Integer &i)
  {
    std::cout << "!=";
    return x != i.x;
  }
  Integer (int t = 0) { x = t; }
};

int
main ()
{
  Integer i;
  std::cout << (i != i) << '\n';   // calls !=
  std::cout << (i != 100) << '\n'; // calls !=
  std::cout << (10 != i) << '\n';  // calls ==
}

Answer 1

Prior to C++20, you'd need to add two free functions for the comparison where the int is on the left-hand side:

bool operator==(int lhs, const Integer& rhs) {
    return rhs == lhs;
}

bool operator!=(int lhs, const Integer& rhs) {
    return rhs != lhs;
}

You should also make the member comparison operators const qualified:

class Integer {
public:
    //...
    bool operator==(const Integer &i) const { // note const
        std::cout << "==";
        return x == i.x;
    }
    bool operator!=(const Integer &i) const { // note const
        std::cout << "!=";
        return x != i.x;
    }
    //...
};

You could also remove the member operators to simplify things. Now the left-hand side int will be implicitly converted to Integer and then compared with the right-hand side:

class Integer {
    int x;

public:
    Integer(int t = 0) : x{t} {}

    friend bool operator==(const Integer& lhs, const Integer& rhs) {
        return rhs.x == lhs.x;
    }

    friend bool operator!=(const Integer& lhs, const Integer& rhs) {
        return !(rhs == lhs);
    }    
};

---

Since you've tagged this C++20, you can let operator== do all the work. See Default comparisons. It'll be used for operator!= too.

class Integer {
    int x;

public:
    bool operator==(const Integer &i) const {
        std::cout << "==";
        return x == i.x;
    }
    
    Integer(int t = 0) : x{t} {}
};

... and it'll correctly show that it used operator== for all your != comparisons (and negated it).

More from Defaulted equality comparison:

A class can define operator== as defaulted, with a return value of bool. This will generate an equality comparison of each base class and member subobject, in their declaration order. Two objects are equal if the values of their base classes and members are equal. The test will short-circuit if an inequality is found in members or base classes earlier in declaration order.

Per the rules for operator==, this will also allow inequality testing

This means that you will in fact get away with the below only since C++20:

class Integer {
    int x;

public:
    bool operator==(const Integer &i) const = default;
    
    Integer(int t = 0) : x{t} {}
};

or even better, get all the comparison operators for free by defaulting the spaceship operator <=>:

class Integer {
    int x;

public:
    auto operator<=>(const Integer &i) const = default;
    
    Integer(int t = 0) : x{t} {}
};