Question

PLEASE NOTE: These are code snippets depicting the general dilemma. The complete code DOES include “include guards” / #pragma once / whathaveyou.

I’m implementing the visitor pattern for traversing an AST and wondering what’s the C++ way to solve the following:

I have AST.h which has the base AST node class declaration:

    class Node
    {
    public:
        virtual void accept(Visitor* v) {v->visit(this);}
    };

Along with all concrete node subclasses for declarations, expressions,etc..

And then I have ASTVisitor.h which declares the visitor interface, along the lines of:

    class Visitor
    {
    public:
        Visitor() {}
        virtual ~Visitor() {}

        virtual void visit(StringElement* e) {}
        virtual void visit(RealElement* e) {}
        virtual void visit(IntegerElement* e) {}
        ...

The problem is, AST.h needs ASTVisitor.h so that the accept method knows that Visitor objects have a visit method. That is, so that both Visitor and visit() are declared for virtual void accept(Visitor* v) {v->visit(this);}. But at the same time, ASTVisitor.h needs AST.h so that the Visitor class knows that all concrete subclasses of Node exist. That is, so that, for instance, StringElement is declared for the signature in virtual void visit(StringElement* e)

But including ASTVisitor.h in AST.h and AST.h in ASTVisitor.h results in the Visitor class not being “seen” by the Node class and therefore, not being valid as a type for accept’s parameter. Also, doing a forward declaration, like class Visitor; in AST.h only solves the type problem for the method signature, but inside the method v->visit(this) is still invalid since the forward declaration says nothing about the methods for the Visitor class.

So what’s the C++ way of solving this?

Answer 1

Yes, there is a way to do this in C++. You need to use forward declarations and, if required, split declarations and definitions. Here is an example (please read comments for explanation):

#include <cstdio>
#include <string>

/// --- A.hpp ---

// First, you have to forward declare a visitor type.
class Visitor;

// Then declare/define a node base class (interface).
class Node {
  public:
    Node() {}
    virtual ~Node() {}

    // Note that Visitor, as a type, is referenced here, but none of its
    // "body" is used, so forward declaration is enough for us.
    virtual void accept(Visitor & v) = 0;
};

/// --- B.hpp (includes A.hpp) ---

// Then, to declare the actual interface for a visitor, we must play the same
// trick with forward declaration, but for specific node types:
class NodeA;
class NodeB;

// And once those types are "pre-declared", declare visitor interface.
class Visitor {
  public:
    Visitor() {}
    virtual ~Visitor() {}

    virtual void visit(const Node & node);
    virtual void visit(const NodeA & node);
    virtual void visit(const NodeB & node);
};

/// --- C.hpp (includes B.hpp) ---

// Once visitor is declared, declare/define specific nodes.
class NodeA : public Node {
  public:
    std::string node_name;

    NodeA() : node_name("I am a node of type A!") {}
    virtual ~NodeA() {}
    virtual void accept(Visitor & v) { v.visit(*this); }
};

class NodeB : public Node {
  public:
    std::string node_name;

    NodeB() : node_name("B node here!") {}
    virtual ~NodeB() {}
    virtual void accept(Visitor & v) { v.visit(*this); }
};

// --- B.cpp (includes B.hpp and C.hpp) ---

// Now, nodes are declared, so that we can define visitor's methods.
// Note that if you don't need to use "node" parameters, this can
// as well go with declaration and there is no need to "define" this later.
void Visitor::visit(const Node & node) {
    printf("Base visitor got base node\n");
}

void Visitor::visit(const NodeA & node) {
    printf("Base visitor got node A\n");
}

void Visitor::visit(const NodeB & node) {
    printf("Base visitor got node B\n");
}

// --- YourProgram.[cpp|hpp] includes at most C.hpp --

// Than, at any point in your program, you can have a specific visitor:
class MyVisitor : public Visitor {
  public:
    MyVisitor() {}
    virtual ~MyVisitor() {}

    virtual void visit(const Node & node) {
        printf("Got base node...\n");
    }

    virtual void visit(const NodeA & node) {
        printf("Got %s\n", node.node_name.c_str());
    }

    virtual void visit(const NodeB & node) {
        printf("Got %s\n", node.node_name.c_str());
    }
};

// And everything can be used like this, for example:
int main()
{
    Visitor generic_visitor;
    MyVisitor my_visitor;

    NodeA().accept(generic_visitor);
    NodeA().accept(my_visitor);
    NodeB().accept(generic_visitor);
    NodeB().accept(my_visitor);
}

… and by the way, don’t forget to use include guards or else you may end up including the same file multiple times which will result in a lot of errors.