Can I compare 2 structures in C++?

Question

I have simply declared a structure like this -

struct data{
    int x,y;
};

Now I have declared 2 variables a & b of data type. I've assigned appropriate values to them. Now, I want to check if they are equal! I am trying to do like this -

data a,b;
a.x=12, a.y=24;
b.x=15, b.y=30;
if(a!=b)cout<<"a~b"<<endl;

But the compiler is giving me the following error on the 4th line ->

error: no match for 'operator!=' (operand types are 'data' and 'data')

Where is the problem actually? Isn't this compare supported in C++?? Or I'm making any mistakes??

What is the exact and easiest way to do this?? Do I need to compare each of the elements in the structure separately?? Or there's any other smarter way??

You have to implement `bool operator != (const data&, const data&);`. — Jarod42, Aug 10 '16 at 12:47
Possible duplicate of [No == operator found while comparing structs in C++](http://stackoverflow.com/questions/5740310/no-operator-found-while-comparing-structs-in-c) — bereal, Aug 10 '16 at 12:48
Assuming no alignment problems, `memcmp` can be used .. in all of the languages this question was tagged. — Andon M. Coleman, Aug 10 '16 at 13:00
@AndonM.Coleman With this in mind, in C++ it's not hard to make a generic comparison function that uses the comparison operator when available (detected with SFINAE), would fallback to `memcmp` if the type is trivial, or would fail to compile otherwise. — KABoissonneault, Aug 10 '16 at 13:08
C and C++ are **different** languages! There is no language "C/C++"! — too honest for this site, Aug 10 '16 at 13:20

6502 · Accepted Answer · 2020-02-26T07:32:25.610

C++ gives you attribute-by-attribute assignment implicitly, but no comparison for equality or ordering. The reason is "just because", don't look too hard into philosophy.

You must to provide those operators, if needed, by implementing them yourself explicitly, for example:

bool operator<(const Data& other) const {
    if (x < other.x) return true;
    if (x > other.x) return false;
    return y < other.y;
}

bool operator==(const Data& other) const {
    return x == other.x && y == other.y;
}

and so on.

Note also that defining for example == doesn't give you != automatically and defining < doesn't provide >= implicitly.

UPDATE

C++20 introduces (will introduce) a new operator <=> (friendly name "spaceship operator") exactly to remove the verbosity of having to define all possible relational operators. In this case adding:

std::strong_ordering operator<=>(const Data& other) const {
    if (auto cmp = x <=> other.x; cmp != 0) return cmp;
    return y <=> other.y;
}

will allow compilation of all relational tests (<, <=, >, >=, ==, !=) between elements of the class based on checking x first and, if that check doesn't resolve, checking y instead.

`return std::tie(lhs.x, lhs.y) < std::tie(rhs.x, rhs.y);` is so convenient, less error prone that the manual way. — Jarod42, Aug 10 '16 at 13:03

nshct · Answer 2 · 2016-08-10T13:01:36.737

You have to implement all operators explicitely that you intent to use. In your case, you will need to supply bool operator!=(const data&, const data&).

A nice way to implement it for PODs like this is to use std::tuple since it already implements ordering:

#include <tuple>

// ...

bool operator!=(const data& p_lhs, const data& p_rhs)
{
    return std::tie(p_lhs.x, p_lhs.y) != std::tie(p_rhs.x, p_rhs.y);
}

std::tie (documentation) creates a temporary tuple of references. Those two tuples can then be compared, since std::tuple defines all comparison operators, as shown here.

I chose to implement operator!= as a free function. You can, of course, choose to implement it as member of your class:

struct data
{
    bool operator!=(const data& p_rhs) const
    {
        return std::tie(x, y) != std::tie(p_rhs.x, p_rhs.y);
    }

    int x, y;
};

Of course you should define all other operators, too. Remember that you can implement most operators by delegating to others.

I didn't know about tie! Your answer helped me to learn that. But sadly my codeblocks ide didn't support it :( although I successfully run it in www.ideone.com :) — jbsu32, Aug 10 '16 at 13:27

score 3 · Answer 3 · answered Aug 06 '19 at 03:08

Automatic C++ comparisons are coming in C++20, so you can just add a special operator to indicate that you need default comparisons when new standard is out.

class Point {
 int x;
 int y;
public:
 auto operator<=>(const Point&) const = default;
 // ... non-comparison functions ...
};

https://en.cppreference.com/w/cpp/language/default_comparisons

Jarod42 · Answer 4 · 2016-08-10T17:08:46.407

0

You have to implement bool operator != (const data&, const data&);.

Possible implementation (in c++11):

#include <tuple>

//...

bool operator == (const data& lhs, const data& rhs) {
    return std::tie(lhs.x, lhs.y) == std::tie(rhs.x, rhs.y);
}

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

edited Aug 10 '16 at 17:08

answered Aug 10 '16 at 12:50

Jarod42

203,559
14
181
302

Why need to make temporary object ? – Inline Aug 10 '16 at 12:54
What temporary object? – paulm Aug 10 '16 at 12:54
@inline: Which temporary object do you think I create ? – Jarod42 Aug 10 '16 at 12:56
@Jarod42 `std::tuple` – Inline Aug 10 '16 at 12:57
1

@Inline: That allows to have uniform code, easy to read and maintain. And compiler may optimize that easily anyway. – Jarod42 Aug 10 '16 at 13:04

Can I compare 2 structures in C++?

4 Answers4

UPDATE