没有虚函数的 class 的多态性？

Question

I'm building a parsing tree which works quite simply: there's a base class for Node and the derived classes for different types of nodes. Children nodes are stored in a list<Node*>.

The problem arises when you want to traverse such a tree and do some stuff with it. As we know, in C++ you can't perform a downcast if the type is non-polymorphic. However, in my situation I obviously need to be able to downcast from Node to the real class of the child node. How should I solve this problem? Do I really need to add a useless virtual function just to be able to do that (I don't really need any in my code)? Or is my approach towards designing this structure completely wrong?

Answer 1

You can impement polymorphic value types if you want.

Unless you need insane extendibility, dynamic cast is going to be a poor performing option; it is a nuclear bomb to kill a termite.

An easy way is to make your node a std::variant of possible node types. You can add a "get base class" helper if you need it (and cache it for speed).

For moderate extendibility, a std any is a value type that lets you cast to exact type.

Or you can implement your own downcast table if you prefer, and keep storing pointers.

Myself, I'd use the variant approach. Nodes containing nodes takea a bit of finess (as variant needs the full class definition, and a node is a variant of each node type), bit there are a lot of solutions (node is actually a thin class that inherits from, or contains a variant, for example).

Using C++ dynamic cast requires a virtual method. But you can make the destructor virtual to satisfy that.

template<class Base, class...Ts> requires (std::is_base_of_v<Base, Ts>&&...)
struct poly_variant:std::variant<Ts...>{
  Base& base(){ return std::visit([](auto&&elem)->Base&{return elem;}, *this); }
  Base const& base()const{ return std::visit([](auto&&elem)->Base const&{return elem;}, *this); }
  using std::variant<Ts...>::variant;
};

struct node;

// define base_avian
// define duck, chicken, flock

struct node : poly_variant<base_avian, chicken, duck, flock> {
  using poly_variant<base_avian, chicken, duck, flock>::poly_variant;
};

there. Now you can

std::vector<node> children;
for(auto&child:children){
  child.base().SomeAvianMethod();
  flock* f=std::fet_if<flock>(&child);
}

no vtable in sight.

Of course if your base_avian type is empty you can ignore most of this.

Answer 2

Just for examples sake, lets say you have a simple set of AST nodes to evaluate (interpret) very simple expressions using only addition and subtraction of integer values.

The classes needed for such an AST could be something like this:

// The basic root node type
struct Node
{
    // The (abstract) function to "evaluate" this node
    virtual int evaluate() = 0;
};

// Addition and subtraction are *binary* node, which means they each have two child-nodes
// Abstract this using this structure
struct BinaryNode : Node
{
    Node* left;   // The left-hand side of the binary expression
    Node* right;  // The right-hand side of the binary expression
};

// This is the node-type representing an addition
struct AddNode : BinaryNode
{
    // Here we need to perform something when evaluating the node
    // We evaluate each of the left and right nodes,
    // and return the result of adding them together
    int evaluate() override
    {
        return left->evaluate() + right->evaluate();
    }
};

// This is the node-type representing a subtraction
struct SubNode : BinaryNode
{
    // Here we need to perform something when evaluating the node
    // We evaluate each of the left and right nodes,
    // and return the result of subtracting them
    int evaluate() override
    {
        return left->evaluate() - right->evaluate();
    }
};

// A node-type representing values
struct ValueNode : Node
{
    // The actual value of this node
    int value;

    // The evaluate function just returns the value
    int evaluate() override
    {
        return value;
    }
};

To evaluate an expression such as 4 + 2 - 6 we would have a tree like this:

SubNode
|-- AddNode
|   |-- ValueNode (4)
|   `-- ValueNode (2)
`-- ValueNode (6)

Or if we set it up in code (assuming suitable constructors):

Node* root = new SubNode(
    new AddNode(
        new ValueNode(4),
        new ValueNode(2)
    ),
    new ValueNode(6)
);

Then we just call evaluate on the root node to get its result:

std::cout << "The result of 4 + 2 - 6 is " << root->evaluate() << '\n';

This will print

The result of 4 + 2 - 6 is 0

---

This code, complete and runable, can be found on the compiler explorer here .

The code can easily be modified to add more types of expressions as well as statements. And of course to generate code instead of direct evaluation.