如何从指向父类的指针调用虚函数

Question

I am trying to call a virtual function from a pointer to a class from within another class. No matter what I do it just calls the original function. I think I am missing something simple. Here are is the smallest bit of code that reproduces the problem. Binary and LiteralExpression inherit from Expr. They each implement their own accept method.

template <typename T>
class LiteralExpression;

template <typename T>
class Unary;

template<typename T>
class Visitor {
public:
    virtual T visitLiteralExpressionExpr(LiteralExpression<T> expr) { T temp;  return temp; };
    virtual T visitUnaryExpr(Unary<T> expr) { T temp;  return temp; };
};

template<typename T>
class Expr {
public:
    virtual T accept(Visitor<T>* visitor) { std::cout << "base accept" << std::endl;  T temp; return temp; };
};

template<typename T>
class Unary : public Expr<T> {
public:
    Unary(Token oper, Expr<T> right) : oper(oper), right(&right) { }

    T accept(Visitor<T>* visitor) {
        std::cout << "unary accept" << std::endl;
        return visitor->visitUnaryExpr(*this);
    }

    Token oper;
    Expr<T> *right;
};

template<typename T>
class LiteralExpression : public Expr<T> {
public:
    LiteralExpression(Literal lit, TokenType type) : lit(lit), type(type) { }

    T accept(Visitor<T>* visitor) {
        std::cout << "literal accept" << std::endl;
        return visitor->visitLiteralExpressionExpr(*this);
    }

    Literal lit;
    TokenType type;
};

Here I test if the right accept methods are being called. I build a Unary expression object with a negative sign and a LiteralExpression object as it's right "leaf". If I call the unary expression's accept everything works fine, and if I call the LiteralExpression's accept method directly it works fine as well. But if I try to call the LiteralExpression's accept method through a pointer to it as an Expr object it calls the base accept method instead.

void AstPrinter::test()
{
    LiteralExpression<std::string> lit(Literal(123), INTEGER);
    Unary<std::string> unary(Token(MINUS, "-", Literal(true), 1), lit); // -123

    lit.accept(this);          // prints "literal accept"
    unary.accept(this);        // prints "unary accept"
    unary.right->accept(this); // prints "base accept"
}

Any help would be appreciated! (ignore the unencapsulated/non-const instance data, that's just for debugging stuff)

Answer 1

Unary(Token oper, Expr<T> right) : oper(oper), right(&right) { }

This initializes the field right to point to the constructor argument right . When the constructor exits, the arguments are destroyed and the field right becomes a dangling pointer.

The type of the argument should be Expr<T>& or Expr<T>* .