Callable

class CallableBase
{
public:
    virtual bool call(int x) = 0;
};

template<class T>
class Callable : public CallableBase
{
    T t_;
public:
    explicit Callable(T t)
        : t_(t)
    {
    }

    Callable& operator=(T t)
    {
        t_ = t;
        return *this;
    }

    bool call(int x) override
    {
        return t_(x);
    }
};

bool func(int x)
{
    return x == 2;
}

int main()
{
    std::function<bool(int)> f;
    constexpr int ss = sizeof(f);

    auto la = [](int x) { return x > 5; };
    constexpr int sla = sizeof(la);

    CallableBase* cb = new Callable<decltype(la)>(la);

    std::cout << cb->call(2) << std::endl;
    std::cout << cb->call(10) << std::endl;

    delete cb;

    using pf_t = bool(*)(int);

    pf_t pf = &func;

    CallableBase* cb2 = new Callable<bool(*)(int)>(&func);

    std::cout << cb2->call(2) << std::endl;
    std::cout << cb2->call(10) << std::endl;

    delete cb2;
}