C++ 尾部递归优化

当函数

more

和

vals

相互调用时，如何启用尾部递归优化

现在，当我设置

n=5

时，但是当我设置

n=50000000

时，会出现错误

using Cb = std::function<void(bool, int)>;
using Read = std::function<void(bool, Cb)>;
using Sink = std::function<void(Read&)>;
using Through = std::function<Read(Read&)>;

int main() {
    int n = 5;

    Read vals = [&](bool abort, Cb cb) {
        if (n-- <= 0) {
            return;
        }
        cb(false, n); // call `more` function
    };

    Sink logInt = [&](Read &read) {
        Cb more;
        more = [&](bool abort, int val) {
            cout << val << endl;
            read(false, more); // call `vals` function
        };

        read(false, more);
    };

    logInt(vals);


    return 0;
}

使用Cb=std:：函数；
使用Read=std:：函数；
使用Sink=std:：函数；
使用Through=std:：function；
int main（）{
int n=5；
读取VAL=[&]（布尔中止，Cb）{
如果（n——你不能强迫它以任何一种可移植的方式。有些编译器可以这样做，但它不是必需的。你必须切换到非递归解决方案。我怀疑你是否能够使用
std:：function
s。
std:：function
使用类型擦除来存储它的可调用性，这基本上删除了编译器需要的所有信息eds能够尝试和优化。gcc通过
-fooptimize sibling calls
来实现，这是在
-O2
、
-O3
和
-Os
上启用的，通常
std:：function
用于存储所有类型的可调用项。当您只需要存储某种类型的单个对象时，您不需要
std:：function
 。将lambda转换为
std:：function
s有缺点，也没有明显的优点。您可以随时更改编码样式，使其不会导致堆栈溢出，并在val's向您提供数据时循环登录。您不能以任何可移植的方式强制它。某些编译器可以这样做，但这不是必需的。您必须切换到n关于递归解决方案。我怀疑您是否能够使用
std:：function
s。
std:：function
使用类型擦除来存储它的可调用性，这基本上删除了编译器尝试和优化所需的所有信息。gcc通过
-fooptimize sibling calls
实现，该功能在
-O2
上启用
-O3
和
-Os
通常
std:：function
用于存储所有类型的可调用对象。当您只需要存储某种类型的单个对象时，您不需要
std:：function
的功能。将lambda转换为
std:：function
有缺点，也没有明显的优点您可以随时更改cod在val向您提供数据的同时，使用ing样式不会导致堆栈溢出，只需循环登录即可