не существует подходящей функции преобразования

#include <iostream>
#include <string>
 
 
class VirTree {
 
public:
    VirTree(VirTree* l, VirTree* r) : l(l), r(r) {}
    VirTree* l;
    VirTree* r;
    void inOrder(
        const std::function<void(VirTree*)>& callback
    ) {
        if (l != nullptr) {
            l->inOrder(callback);
        }
        callback(this);
        if (r != nullptr) {
            r->inOrder(callback);
        }
    }
    void preOrder(
        const std::function<void(VirTree*)>& callback
    ) {
        callback(this);
        if (l != nullptr) {
            l->preOrder(callback);
        }
        if (r != nullptr) {
            r->preOrder(callback);
        }
    }
 
    void postOrder(
        const std::function<void(VirTree*)>& callback
    ) {
        if (l != nullptr) {
            l->postOrder(callback);
        }
 
        if (r != nullptr) {
            r->postOrder(callback);
        }
        callback(this);
    }
 
    virtual void view(std::ostream& out) = 0;
    virtual int calculate() = 0;
    virtual ~VirTree() = default;
 
};
 
 
void prefixForm(std::ostream& out, VirTree* tree) {
    tree->preOrder(
        [&](VirTree* node) {
            node->view(out);
            std::cout << " ";
        }
    );
    out << std::endl;
}
 
void removeTree(VirTree* tree) {
    tree->postOrder(
        [&](VirTree* node) {
            delete node;
        }
    );
}
 
class MultiplyTree : public VirTree {
public:
 
    MultiplyTree(VirTree* l, VirTree* r) : VirTree(l, r) {}
    int calculate() override {
        return l->calculate() * r->calculate();
    }
    void view(std::ostream& out) override {
        out << '*';
    }
    ~MultiplyTree() override = default;
};
 
class Sumtree : public VirTree {
public:
    Sumtree(VirTree* l, VirTree* r) : VirTree(l, r) {}
    int calculate() override {
        return l->calculate() + r->calculate();
    }
    void view(std :: ostream & out) override {
        out << '+';
    }
    ~Sumtree() override = default;
};
 
class SubtractionTree : public VirTree {
public:
    SubtractionTree(VirTree* l, VirTree* r) : VirTree(l, r) {}
    int calculate() override {
        return l->calculate() - r->calculate();
    }
    void view(std::ostream& out) override {
        out << '-';
    }
    ~SubtractionTree() override = default;
};
 
 
 
 
 
class NumberTree : public VirTree {
private:
    int number;
public:
    NumberTree(VirTree* left, VirTree* r, int number) : VirTree(left, r), number(number) {}
    int calculate() override {
        return number;
    }
 
    void view(std::ostream& out) override {
        out << number;
    }
 
    ~NumberTree() override = default;
 
};
 
bool sign(char ch) {
    if (ch == '+') {
        return true;
    }
    if (ch == '-') {
        return true;
    }
    if (ch == '*') {
        return true;
    }
    return false;
}
 
VirTree* operand(const std::string& expression, size_t& i) {
    int number = 0;
    while (i < expression.length() && !sign(expression[i])) {
        number *= 10;
        number += expression[i] - 48;
        ++i;
    }
    return new NumberTree(nullptr, nullptr, number);
 
}
 
 
VirTree* term(const std::string& expression, size_t& i) {
    VirTree* tree = operand(expression, i);
    while (i < expression.length() && expression[i]) {
        ++i;
        tree = new MultiplyTree(tree, operand(expression, i));
    }
    return tree;
}
 
VirTree* buildtree(const std::string& expression) {
    size_t i = 0;
    VirTree* tree = term(expression, i);
    while (4 < expression.length()) {
        if (sign(expression[i])) {
            if (expression[i] == '+') {
                ++i;
                tree = new Sumtree(tree, term(expression, i));
 
            }
            else if (expression[i] == '-') {
                ++i;
                tree = new SubtractionTree(tree, term(expression, i));
            }
        }
    }
    return tree;
}
 
 
 
int main() {
    std::string expression;
    std::cin >> expression;
    VirTree* tree = buildtree(expression);
    prefixForm(std::cout, tree);
 
}

[&](VirTree* node)