I have to overload a == operator in C++ for a class with many attributes.
The operator should return true, if and only if all attributes are equal. A shortcut might be useful, if these attributes change over time, to avoid bugs.
Is there a shortcut to compare every attribute in a class?
There is no shortcut. You will have to list everything.
Some sources of error can be reduced by introducing a member function named tied() like:
struct Foo {
A a;
B b;
C c;
...
private:
auto tied() const { return std::tie(a, b, c, ...); }
};
So that your operator== can just use that:
bool operator==(Foo const& rhs) const { return tied() == rhs.tied(); }
This lets you only list all your members once. But that's about it. You still have to actually list them (so you can still forget one).
There is a proposal (P0221R0) to create a default operator==, but I don't know if it will get accepted.
The above proposal was rejected in favor of a different direction regarding comparisons. C++20 will allow you to write:
struct Foo {
A a;
B b;
C c;
// this just does memberwise == on each of the members
// in declaration order (including base classes)
bool operator==(Foo const&) const = default;
};
Starting in C++11 with the introduction of tuples we also got std::tie(). This will let use make a tuple out of a bunch of variables and call a comparison function against all of them. You can use it like
struct Foo
{
int a,b,c,d,e,f;
bool operator==(const Foo& rhs) { return std::tie(a,b,c,d,e,f) == std::tie(rhs.a,rhs.b,rhs.c,rhs.d,rhs.e,rhs.f); }
};
You still have to list all the members you want to check but it makes it easier. You can also use this to make less than and greater than comparisons much easier.
It should also be noted that the variables are checked in the order you provide them to tie. This is important for less than and greater than comparisons.
std::tie(a,b) < std::tie(rhs.a, rhs.b);
Does not have to be the same as
std::tie(b,a) < std::tie(rhs.b, rhs.a);
At the moment, there is no shortcut but there are plans to add support for it (P0221R0).
Bjarne Stroustrup recently wrote a blog post about it: A bit of background for the default comparison proposal
In C++14, there is nothing better than listing all members and comparing them, which is error prone. To quote Bjarne:
The killer argument for default comparisons is not actually convenience, but the fact that people get their equality operators wrong.
The only way of doing it is unfortunatly to check all attributes. The good thing is if you combine all your checks using && it will stop evaluating after the first false statement. (short-circuit evaluation)
So e.g. false && (4 == 4). The program would never evaluate the 4 == 4 part since all statements combined by && need to be true to get true as a final outcome. Does this make sense?
There is a not to the operator==related solution possible. You can generate the related code from a definition table with the help of so called X-Macro. The table could look like
#define MEMBER_TBL \
/*type ,name ,default*/ \
X(int ,_(i) ,42 ) \
X(float ,_(f) ,3.14 ) \
X(std::string , t ,"Hello") \
The _()stuff is needed to avoid a trailing , on generation the std::tie() call. Make sure that the last element is w.o. _(). The usage to generate the members is:
struct Foo
{
#define _(x) x
#define X(type, name, default) type name{default};
MEMBER_TBL
#undef X
#undef _
}
This generates:
struct Foo
{
int i{42}; float f{3.14}; std::string t{"Hello"};
}
To generate the operator==you can use:
bool operator==(Foo const& other) const {
return std::tie(
#define _(x) x,
#define X(type, name, default) this->name
MEMBER_TBL
#undef X
) == std::tie(
#define X(type, name, default) other.name
MEMBER_TBL
#undef X
#undef _
);
}
which results into
bool operator==(Foo const& other) const {
return std::tie(
this->i, this->f, this->t
) == std::tie(
other.i, other.f, other.t
);
}
To add new members you can add simply a new entry to the first table. Everything else is generated automatically.
Another advantage is, you can add simply a dump() method like
void print(void) const {
#define STR(x) #x
#define _(x) x
#define X(type, name, default) \
std::cout << \
STR(name) << ": " << name << " ";
MEMBER_TBL
#undef X
#undef _
#undef STR
std::cout << std::endl;
}
which results into
void print() const {
std::cout << "i" << ": " << i << " "; std::cout << "f" << ": " << f << " "; std::cout << "t" << ": " << t << " ";
std::cout << std::endl;
}
Every information regarding to the members could be added to the table at one place (single point of information) and extracted elsewhere needed.
A working Demo.
