模拟C++堆上的方法调用

Emulate method call on heap in C++?

本文关键字：方法 调用 C++ 模拟      更新时间：2023-10-16

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

出于好奇，在C++（例如）中，是否可以通过使用堆而不是线程调用堆栈来模拟调用方法？

这是一个（人为的，可能过于复杂）阶乘的实现，它只使用堆：

#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
相关文章：