adding functionality onto polymorphic tree in c++ - c++

Question

I have a polymorphic tree and I'm trying to do add functionality like comparing two nodes without using RTTI like dynamic_cast The approach I'm taking is the visitor pattern.
The issue I'm having is that the visitor pattern isn't letting me operate on any parameters or getting return types out of the functions.
For example if I wanted to write a visitor that compares two nodes
class AbstractDispatch{
public:
virtual void visit(NodeFoo &operand) = 0;
virtual void visit(NodeBar &operand) = 0;
//...for all types.
};
class CompareVisitor{
public:
void visit(NodeFoo &operand) override;
//...
};
class SetVisitor{
public:
void visit(NodeFoo &operand) override;
//...
};
void CompareVisitor::visit(NodeFoo &operand){
//compare operand to what?
//get result of comparison how?
}
void SetVisitor::visit(NodeFoo &operand){
//set operand to what?
}
My current idea is to add other functions and members to the visitor classes. This would let me do something like this:
Base *object = new NodeFoo();
CompareVisitor compare;
compare.set_parameters(NodeFoo(/* */));
object->accept(compare);
bool result = compare.get_result();
I could set the parameters of the compare visitor and traverse the tree with it checking for the nodes and doing other such operations in this fashion.
Another solution would be to store node-type information in the node and do a get_type() check for safe-casting.
dynamic_cast is slow but if the node-type hierarchy is extremely simple could it be faster? Are there better design patterns for doing something like this?

Answer 1

You could write a visitor that compares the current node with the previous one.
class Node{...}
class NodeFoo : public Node {...}
class NodeBar : public Node {...}
class visitor{
public:
void visit( const NodeFoo& node ){
//First node: store relevant comparison information to private variables
if( foo == nullptr ){
foo = &node;
}
//Other nodes: Compare to the stored data and store comparison result
else {
...
}
}
void visit( const NodeBar& node ){
...
}
bool result() const{ return result; };
private:
bool result = false;
//variables for comparison, could be this simple but also a variant type
// or plain Node*
NodeFoo* foo = nullptr;
NodeBar* bar = nullptr;
}
You would use it like
Node node1;
Node node2;
Visitor v;
node1.accept( v );
node2.accept( v );
v.result();
Sure, this is a very basic implementation, you could use a plain Node* to store the first node, if you presume that alle visited nodes have the same type. You could also use a variant type or store the type as string... ( you know the type by the executed visit function )
If the Node lifetime is not sure, you can store some Node depending data, that you need for the comparisson instead of a pointer to the node.... there are hundreds of possibilities, this is just a small sketch of the basic framework

Answer 2

It can be done with double visit ( = two virtual calls) if you allow CompareVisitor to have a state. I don't think there's a way around that given your visitor API.
#include <iostream>
#include <string>
#include <vector>
#include <memory>
struct FooNode;
struct BarNode;
struct Visitor
{
virtual void visit(FooNode&)=0;
virtual void visit(BarNode&)=0;
};
struct Node{
virtual void accept(Visitor& v) = 0;
};
struct FooNode: public Node{
virtual void accept(Visitor& v) override { v.visit(*this);}
const char* print(){return "FooNode";}
};
struct BarNode: public Node{
virtual void accept(Visitor& v) override { v.visit(*this);}
const char* print(){return "BarNode";}
};
using ret_type=std::string;
//Feel free to specialize or overload
//Or create comparator class that allows partial specializations
template<typename Left, typename Right>
ret_type compare(Left &left, Right& right){
return std::string(left.print()) + "<=>" + right.print() + '\n';
}
//Compares (visited) and (rightNode)
class RightCompareVisitor : public Visitor {
public:
RightCompareVisitor(Node& right):rightNode(right){}
void visit(FooNode &left) override
{
visitRightNode(left);
}
void visit(BarNode &left) override
{
visitRightNode(left);
}
ret_type getRes() { return std::move(result);}
private:
template<typename Left>
void visitRightNode(Left& left){
struct CompareVisitor: Visitor
{
ret_type& result;
Left& left;
CompareVisitor(ret_type& result, Left& left):result(result), left(left){}
void visit(FooNode &right) override final{
result = compare(left, right);
}
void visit(BarNode &right) override final{
result = compare(left, right);
}
};
CompareVisitor v(result, left);
rightNode.accept(v);
}
ret_type result;
Node& rightNode;
};
//If you add this then you can always just use 'compare' to compare any two
//nodes.
template<>
ret_type compare<Node,Node>(Node& left, Node& right){
RightCompareVisitor rC{right};
left.accept(rC);
return rC.getRes();
}
int main()
{
std::vector<std::unique_ptr<Node>> nodes;
nodes.emplace_back(std::make_unique<FooNode>());
nodes.emplace_back(std::make_unique<BarNode>());
nodes.emplace_back(std::make_unique<FooNode>());
for(auto&& left : nodes)
for(auto&& right: nodes)
std::cout<<compare(*left,*right);
}
Add consts where you want. If you want RightCompareVisitor to be reused then use pointers for nodes.
Output:
FooNode<=>FooNode
FooNode<=>BarNode
FooNode<=>FooNode
BarNode<=>FooNode
BarNode<=>BarNode
BarNode<=>FooNode
FooNode<=>FooNode
FooNode<=>BarNode
FooNode<=>FooNode