c++ - 在 C++ 中模拟堆上的方法调用？

Question

虽然堆内存的分配速度比线程调用堆栈慢，但它要大得多，从而为执行更多的操作(例如大规模递归方法调用)留出了空间。尽管可以调整堆栈的大小，但相对于堆(超过 1 GB 的可用空间)，允许的值仍然相对较小(可用的几 MB)。

出于好奇，在 C++ 中(作为示例)是否可以通过使用堆而不是线程调用堆栈来模拟调用方法？

Answer 1

这是仅使用堆的阶乘的(人为的且可能过于复杂的)实现:

#include <iostream>
#include <vector>
#include <memory>
#include <numeric>
#include <typeinfo>

struct factorial
{
    struct call_concept
    {
        virtual int operator()() const = 0;
        virtual std::unique_ptr<call_concept> generate_next() const = 0;
        virtual ~call_concept() = default;
    };

    static std::unique_ptr<call_concept> generate_term(int i);

    struct terminator : call_concept
    {
        int operator()() const override { return 1; }
        std::unique_ptr<call_concept> generate_next() const override { return nullptr; }
    };

    struct fact_term : call_concept
    {
        fact_term(int i) : _i(i) {};
        int operator()() const override { return _i; }
        std::unique_ptr<call_concept> generate_next() const override {
            return generate_term(_i - 1);
        }
        int _i;
    };


    struct call
    {
        call(std::unique_ptr<call_concept> pc) : _impl(std::move(pc)) {}

        int operator()() const {
            return _impl->operator()();
        }

        int operator*(const call& r) const {
            return (*this)() * r();
        }

        std::unique_ptr<call_concept> _impl;
    };

    friend int operator*(int i, const call& r) {
        return i * r();
    }



    int operator()(int i) {

        auto pt = generate_term(i);
        std::vector<call> stack;

        while (pt) {
            auto next_term = pt->generate_next();
            stack.emplace_back(std::move(pt));
            pt = std::move(next_term);
        }

        return std::accumulate(std::begin(stack), end(stack), 1, std::multiplies<>());
    }
};

auto factorial::generate_term(int i) -> std::unique_ptr<call_concept>
{
    if (i > 1) {
        return std::make_unique<fact_term>(i);
    }
    else {
        return std::make_unique<terminator>();
    }
}

int main()
{
    auto i = factorial()(10);
    std::cout << i << std::endl;

    return 0;
}

预期结果:

3628800