Elegantly comparing polymorphic trees in C++ - c++

Question

I have a tree of polymorphic objects. I need to traverse the two trees and compare the nodes. If the nodes have different types, they are not equal. Consider this hierarchy:
struct Visitor;
struct Base {
virtual ~Base() = default;
virtual void accept(Visitor &) = 0;
};
using BasePtr = std::unique_ptr<Base>;
struct A final : Base {
void accept(Visitor &) override;
int data;
};
struct B final : Base {
void accept(Visitor &) override;
BasePtr child;
};
struct C final : Base {
void accept(Visitor &) override;
std::vector<BasePtr> children;
};
struct Visitor {
virtual void visit(const A &) = 0;
virtual void visit(const B &) = 0;
virtual void visit(const C &) = 0;
};
I know how to implement these functions:
bool equalNode(const A &, const A &);
bool equalNode(const B &, const B &);
bool equalNode(const C &, const C &);
I'm asking about how I should implement this function:
bool equalTree(const Base *, const Base *);
How do I elegantly go from equalTree to equalNode possibly using the visitor pattern?

Answer 1

Something like
struct RhsVisitor : public Visitor
{
bool result;
};
struct AEqualVisitor : public RhsVisitor
{
void visit(const A & rhs) override { result = equalNode(lhs, rhs); }
void visit(const B &) override { result = false; }
void visit(const C &) override { result = false; }
const A & lhs;
};
And similar for B and C
struct LhsVisitor : public Visitor
{
void visit(const A & a) override { rhsVisitor = std::make_unique<AEqualVisitor>(a); }
void visit(const B & b) override { rhsVisitor = std::make_unique<BEqualVisitor>(b); }
void visit(const C & c) override { rhsVisitor = std::make_unique<CEqualVisitor>(c); }
std::unique_ptr<RhsVisitor> rhsVisitor;
};
bool equalTree(const Base * lhs, const Base * rhs)
{
LhsVisitor vis;
lhs->accept(vis);
rhs->accept(*vis.rhsVisitor);
return vis.rhsVisitor->result;
};

Answer 2

There are three approaches here.
The first is - you need to do double dispatch. You have one visitor for one side and one visitor for the other side. Once you pick one side, you "save" that type as a template parameter, which you can use to visit the other side:
template <typename T>
struct Right : Visitor {
Right(T const* lhs) : lhs(lhs) { }
T const* lhs;
bool result;
void visit(A const& x) override { visit_impl(x); }
void visit(B const& x) override { visit_impl(x); }
void visit(C const& x) override { visit_impl(x); }
void visit_impl(T const& x) { result = equalNode(*lhs, x); }
template <typename U> void visit_impl(U const&) { result = false; }
};
struct Left : Visitor {
Left(Base const* lhs, Base const* rhs) : rhs(rhs) {
lhs->accept(*this);
}
Base const* rhs;
bool result;
void visit(A const& x) override { visit_impl(x); }
void visit(B const& x) override { visit_impl(x); }
void visit(C const& x) override { visit_impl(x); }
template <typename U>
void visit_impl(U const& lhs) {
Right<U> right(&lhs);
rhs->accept(right);
result = right.result;
}
};
bool equalTree(const Base *lhs, const Base *rhs) {
return Left(lhs, rhs).result;
}
The second is - you cheat. You only care about the cases where the two sides are the same type, so you only need single dispatch:
struct Eq : Vistor {
Eq(Base const* lhs, Base const* rhs) : rhs(rhs) {
lhs->accept(*this);
}
Base const* rhs;
bool result;
void visit(A const& x) override { visit_impl(x); }
void visit(B const& x) override { visit_impl(x); }
void visit(C const& x) override { visit_impl(x); }
template <typename U>
void visit_impl(U const& x) {
result = equalNode(x, *static_cast<U const*>(rhs));
}
};
bool equalTree(Base const* lhs, Base const* rhs) {
if (typeid(*lhs) == typeid(*rhs)) {
return Eq(lhs, rhs).result;
} else {
return false;
}
}
The third is - you don't do this through OO and instead use a variant:
using Element = std::variant<A, B, C>;
struct Eq {
template <typename T>
bool operator()(T const& lhs, T const& rhs) const {
return equalNode(lhs, rhs);
}
template <typename T, typename U>
bool operator()(T const&, U const&) const {
return false;
}
};
bool equalTree(Element const& lhs, Element const& rhs) {
return std::visit(Eq{}, lhs, rhs);
}