9

I wonder if operator!= is automatically provided when operator== is defined within my class? When I have operator== defined in class A, obviously A a, A b, a == b works, but a != b doesn't. However I am not sure if it always happens. Are there any exceptions from this?

thatsme
  • 325
  • 1
  • 2
  • 10
  • See: http://stackoverflow.com/questions/4421706/operator-overloading?rq=1 – Joe Jul 24 '14 at 15:54
  • 2
    This might be possible in a future version of the language: http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2014/n4114.htm – chris Jul 24 '14 at 15:56
  • 1
    Related Q : [relational operators generator](http://stackoverflow.com/q/23388739/2567683) (actually you only need `<` to have all of them) – Nikos Athanasiou Jul 24 '14 at 16:44

7 Answers7

13

No, operators (apart from assignment) are never automatically generated. It's easy enough to define it in terms of ==:

bool operator!=(A const & l, A const & r) {return !(l == r);}
Mike Seymour
  • 249,747
  • 28
  • 448
  • 644
12

The operator != is not automatically provided for you. You may want to read about rel_ops namespace if you want such automation. Essentially you can say

using namespace std::rel_ops;

before using operator !=.

Wojtek Surowka
  • 20,535
  • 4
  • 44
  • 51
  • 6
    But be careful to limit the scope of the using directive. It will provide operators for all types, not just the one you're interested in, which could have surprising consequences. – Mike Seymour Jul 24 '14 at 15:59
5

This is true since C++20. Earlier C++ standard versions do not provide operator!= from operator== automatically.

ivan.ukr
  • 2,853
  • 1
  • 23
  • 41
  • In C++20 and over, you should actually use the `<=>` operator then all the other 6 operators are defined in one swoop. – Alexis Wilke May 29 '23 at 16:07
3

What you're after isn't provided by the language for obvious reasons. What you want is provided for by boost::operators:

class MyClass : boost::operators<MyClass> {
    bool operator==(const MyInt& x) const;
}

will get you an operator!=() based on your operator==()

T.C.
  • 133,968
  • 17
  • 288
  • 421
Paul Evans
  • 27,315
  • 3
  • 37
  • 54
1

If you #include <utility>, you can specify using namespace std::rel_ops.

Doing this will automatically define operator != from operator ==, and operator <=, operator >=, operator > from operator <.

axnsan
  • 888
  • 10
  • 16
  • 1
    `std::rel_ops` is a bit... [broken](https://stackoverflow.com/questions/6225375/idiomatic-use-of-stdrel-ops). – chris Jul 24 '14 at 16:04
1

Nope. You have to define it explicitly.

Code:

#include <iostream>

using namespace std;

class a
{
    private:
        int b;
    public:
        a(int B): b(B)
        bool operator == (const a & other) { return this->b == other.b; }
};

int main()
{
    a a1(10);
    a a2(15);
    if (a1 != a2)
    {
        cout << "Not equal" << endl;
    }
}

Output:

[ djhaskin987@des-arch-danhas:~ ]$ g++ a.cpp
a.cpp: In constructor ‘a::a(int)’:
a.cpp:11:9: error: expected ‘{’ before ‘bool’
         bool operator == (const a & other) { return this->b == other.b; }
         ^
a.cpp: In function ‘int main()’:
a.cpp:18:12: error: no match for ‘operator!=’ (operand types are ‘a’ and ‘a’)
     if (a1 != a2)
            ^
a.cpp:18:12: note: candidates are: ...
djhaskin987
  • 9,741
  • 4
  • 50
  • 86
0

No, != is not defined automatically in terms of ==. There are some generics define in that help to define all the operators in term of == and <, though.

manuBriot
  • 2,755
  • 13
  • 21