How to call a deriving class operator()?

Question

I want create an expression structure, to calculate value (by calling operator().

expr - base expression class, it should work like result = expression(100500). const_value - struct returns constant value. argument - returns it's argument (== function id). e_add, prod, sub, ... - different functions.

Why code calls base class operator(), but ignore derived structires?

output:

EXPR::operator() called
EXPR::operator() called

201000
const_value 1 called arg = 100
1

Full source code:

#include <iostream>
#include <cmath>

using namespace std;

struct expr {
    virtual double operator()(double) {
        cerr << "EXPR::operator() called\n";
        return 100500;
    };
};

struct const_value : public expr {
    double _value;
    const_value (double value = 0): _value(value) {};
    double operator()(double arg = 0) override {
        cout << "const_value " << _value << " called arg = " << arg << '\n';
        return _value;
    };
};

#define make_bin_op(_op_name, _op) struct e_##_op_name : public expr {     \
    expr _left;                                                            \
    expr _right;                                                           \
    e_##_op_name(expr left, expr right): _left(left), _right(right) {};    \
    double operator()(double arg) override {                               \
        return _left(arg) _op _right(arg);                                 \
    };                                                                     \
}

make_bin_op(add,  +);

#undef make_bin_op

int main()
{
    const_value c1{1};
    e_add e{c1, c1};

    cout << e(100) << endl;
    cout << c1(100) << endl;

    return 0;
}