我希望创建一个回调函数，以递归方式将自身作为回调返回。
建议的递归方法是让函数具有对自身的引用：
std::function<void (int)> recursive_function = [&] (int recurse) {
std::cout << recurse << std::endl;
if (recurse > 0) {
recursive_function(recurse - 1);
}
};
一旦从函数返回它就会失败：
#include <functional>
#include <iostream>
volatile bool no_optimize = true;
std::function<void (int)> get_recursive_function() {
std::function<void (int)> recursive_function = [&] (int recurse) {
std::cout << recurse << std::endl;
if (recurse > 0) {
recursive_function(recurse - 1);
}
};
if (no_optimize) {
return recursive_function;
}
return [] (int) {};
}
int main(int, char **) {
get_recursive_function()(10);
}
在输出10后产生分段错误，因为引用变为无效。
我该怎么做？我已成功使用了我认为的 Y Combinator （我将其作为答案发布），但这非常令人困惑。还有更好的方法吗？
我尝试过将其包装在另一层回调中的无聊方法：
#include <functional>
#include <iostream>
#include <memory>
volatile bool no_optimize = true;
std::function<void (int)> get_recursive_function() {
// Closure to allow self-reference
auto recursive_function = [] (int recurse) {
// Actual function that does the work.
std::function<void (int)> function = [&] (int recurse) {
std::cout << recurse << std::endl;
if (recurse > 0) {
function(recurse - 1);
}
};
function(recurse);
};
if (no_optimize) {
return recursive_function;
}
return [] (int) {};
}
int main(int, char **) {
get_recursive_function()(10);
}
但是在实际场景中失败了，其中函数被延迟并被外循环调用：
#include <functional>
#include <iostream>
#include <memory>
#include <queue>
volatile bool no_optimize = true;
std::queue<std::function<void (void)>> callbacks;
std::function<void (int)> get_recursive_function() {
// Closure to allow self-reference
auto recursive_function = [] (int recurse) {
// Actual function that does the work.
std::function<void (int)> function = [&] (int recurse) {
std::cout << recurse << std::endl;
if (recurse > 0) {
callbacks.push(std::bind(function, recurse - 1));
}
};
function(recurse);
};
if (no_optimize) {
return recursive_function;
}
return [] (int) {};
}
int main(int, char **) {
callbacks.push(std::bind(get_recursive_function(), 10));
while (!callbacks.empty()) {
callbacks.front()();
callbacks.pop();
}
}
提供10，然后是9，然后是细分错误。
答案 0 :(得分：4)
正如你正确指出的那样，lambda capture [&]中有一个无效的引用。
你的回报是各种各样的仿函数，所以我假设回报的确切类型并不重要，只是它表现为一个函数，即可以调用。
如果recursive_function包含在struct或class中，您可以将呼叫运营商映射到recursive_function成员。捕获this变量时会出现问题。它将在创建this时被捕获，因此如果对象被复制一点，原始this可能不再有效。因此，在执行时可以将相应的this传递给函数（此this问题可能不是问题，但它在很大程度上取决于您何时以及如何调用该函数。）
#include <functional>
#include <iostream>
volatile bool no_optimize = true;
struct recursive {
std::function<void (recursive*, int)> recursive_function = [] (recursive* me, int recurse) {
std::cout << recurse << std::endl;
if (recurse > 0) {
me->recursive_function(me, recurse - 1);
}
};
void operator()(int n)
{
if (no_optimize) {
recursive_function(this, n);
}
}
};
recursive get_recursive_function() {
return recursive();
}
int main(int, char **) {
get_recursive_function()(10);
}
或者，如果recursive_function可以是static，那么在原始代码示例中将其声明为这样也可以为您解决问题。
我想在上面的答案中添加一些通用性，即将其作为模板;
#include <functional>
#include <iostream>
volatile bool no_optimize = true;
template <typename Signature>
struct recursive;
template <typename R, typename... Args>
struct recursive<R (Args...)> {
std::function<R (recursive const&, Args... args)> recursive_function;
recursive() = default;
recursive(decltype(recursive_function) const& func) : recursive_function(func)
{
}
template <typename... T>
R operator()(T&&... args) const
{
return recursive_function(*this, std::forward<Args>(args)...);
}
};
recursive<void (int)> get_recursive_function()
{
using result_type = recursive<void (int)>;
if (!no_optimize) {
return result_type();
}
result_type result ([](result_type const& me, int a) {
std::cout << a << std::endl;
if (a > 0) {
me(a - 1);
}
});
return result;
}
int main(int, char **) {
get_recursive_function()(10);
}
这是如何工作的？基本上它将递归从函数内部（即调用自身）移动到对象（即对象本身上的函数操作符）以实现递归。在get_recursive_function中，结果类型recursive<void (int)>用作递归函数的第一个参数。它是const&因为我已将operator()实现为const符合大多数标准算法和lambda函数的默认值。它需要一些＆＃34;合作＆＃34;从函数的实现者（即使用me参数;本身是*this）来获得递归工作，但对于这个价格，你得到一个不依赖于堆栈引用的递归lambda
答案 1 :(得分：3)
编程中的所有问题都可以通过另一层间接解决，除了太多的间接层。
我的目标是创建一个recursive<void(int)>类型，让您轻松创建递归lambda。为此，您传入一个带有签名void(recursive<void(int)>, int)的lambda - 第一个参数是您为了进行递归调用而调用的。
然后我将其打结并使其成为带有签名void(int)的完全递归函数。
以下是我recursive<Signature>的实现：
template<class Sig>
struct recursive;
template<class R, class... As>
struct recursive< R(As...) > {
using base_type = std::function<R(recursive, As...)>;
private:
std::shared_ptr< base_type > base;
public:
template<typename...Ts>
auto operator()(Ts&&... ts) const
-> typename std::result_of< base_type( recursive, Ts... ) >::type
{
return (*base)(*this, std::forward<Ts>(ts)...);
}
recursive(recursive const&)=default;
recursive(recursive&&)=default;
recursive& operator=(recursive const&)=default;
recursive& operator=(recursive &&)=default;
recursive() = default;
template<typename L, typename=typename std::result_of< L(recursive, As...) >::type>
explicit recursive( L&& f ):
base( std::make_shared<base_type>(std::forward<L>(f)))
{}
explicit operator bool() const { return base && *base; }
};
诚然，这很复杂。我做了很多事情来提高效率，这是一个完美的转发。与std::function不同，它还会检查传递给它的lambda的类型是否与它想要的签名匹配。
我相信，但尚未证实，我使lambdas签名void(auto&&,int)变得友好。有人知道完全兼容的C ++ 1y在线编译器吗？
以上只是样板文件。重要的是它如何看待使用点：
std::function<void (int)> get_recursive_function() {
auto f =
[] (recursive<void(int)> self, int recurse) {
std::cout << recurse << std::endl;
if (recurse > 0) {
self(recurse - 1);
}
};
return recursive< void(int) >( f );
};
这里我们使用流行的auto f = lambda语法。无需直接将其存储在std::function。
然后，我们明确地将它转换为recursive<void(int)>，将其绑定并从前面删除recursive<void(int)>参数到f，并公开签名{{1} }。
这确实要求你的lambda将void(int)作为它的第一个参数，并通过它进行递归，但这似乎并不严厉。如果我写了恰到好处，它可能会以recursive<void(int)> self作为第一个参数，但我不确定。
auto&& self自然适用于任何签名。
并且，with delayed calls in outer loop它仍然有效。请注意，我摆脱了那个全局变量（它可以作为一个全局变量使用它，它只是让它变得肮脏）。
在C ++ 1y中，我们可以eliminate the type erasure & shared_ptr overhead在上面看到（recursive<?>对象持有recursive）。你必须提供返回值，因为我无法让shared_ptr<function<?>>解开我的混乱：
result_of然后struct wrap {};
template<class R, class F>
struct recursive {
using base_type = F;
private:
F base;
public:
template<class... Ts>
R operator()(Ts&&... ts) const
{
return (*base)(*this, std::forward<Ts>(ts)...);
}
recursive(recursive const&)=default;
recursive(recursive&&)=default;
recursive& operator=(recursive const&)=default;
recursive& operator=(recursive &&)=default;
recursive() = delete;
template<typename L>
recursive( wrap, L&& f ):
base( std::forward<L>(f) )
{}
};
template<class T>using decay_t = typename std::decay<T>::type;
template<class R, class F>
recursive<R, decay_t<F>> recurse( F&& f ) { return recursive<R, decay_t<F>>(wrap{}, std::forward<F>(f)); }
的实现略有不同（我添加了一些状态以获得乐趣）：
get_recursive_function在std::function<void (int)> get_recursive_function(int amt) {
auto f =
[amt] (auto&& self, int count) {
std::cout << count << std::endl;
if (count > 0) {
self(count - amt);
}
};
return recurse<void>( std::move(f) );
};
int main() {
auto f = get_recursive_function(2);
f(10);
}
的返回值中使用std::function是可选的 - 您可以在C ++ 1y中使用get_recursive_function。与完美版本（lambda可以访问自己的auto）相比，还有一些开销，因为operator()可能不知道它在调用时在同一个对象上被递归调用operator()。
允许lambda正文中的self允许递归调用lambda是很诱人的。它可能会打破很少的代码。
答案 2 :(得分：1)
我目前的解决方法，不幸的是很复杂，是：
#include <functional>
#include <iostream>
#include <queue>
volatile bool no_optimize = true;
std::queue<std::function<void (void)>> callbacks;
（我认为这是一个Y Combinator，但我不确定。）
std::function<void (int)> y_combinator(
std::function<void (std::function<void (int)>, int)> almost_recursive_function
) {
auto bound_almost_recursive_function = [almost_recursive_function] (int input) {
y_combinator(almost_recursive_function)(input);
};
return [almost_recursive_function, bound_almost_recursive_function] (int input) {
almost_recursive_function(bound_almost_recursive_function, input);
};
}
这是基本功能;它不会自称，而是传递它的论据。这个参数应该是递归函数本身。
std::function<void (std::function<void (int)>, int)> get_almost_recursive_function() {
auto almost_recursive_function = (
[] (std::function<void (int)> bound_self, int recurse) {
std::cout << recurse << std::endl;
if (recurse > 0) {
callbacks.push(std::bind(bound_self, recurse - 1));
}
}
);
if (no_optimize) {
return almost_recursive_function;
}
return [] (std::function<void (int)>, int) {};
}
因此，可以通过将组合子应用于几乎递归函数来实现所需函数。
std::function<void (int)> get_recursive_function() {
return y_combinator(get_almost_recursive_function());
}
运行main时，会根据需要输出10，9，...，0。
int main(int, char **) {
callbacks.push(std::bind(get_recursive_function(), 10));
while (!callbacks.empty()) {
callbacks.front()();
callbacks.pop();
}
}
答案 3 :(得分：1)
由于您已经处理了std::function，在整个地方添加了一些开销，您可以添加内存持久性，只会在调用站点添加unique_ptr的间接：
std::unique_ptr<std::function<void (int)>> CreateRecursiveFunction() {
auto result = std::make_unique<std::function<void (int)>>();
auto ptr = result.get();
*result = [ptr] (int recurse) { // c++1y can also capture a reference to the std::function directly [&func = *result]
std::cout << recurse << std::endl;
if (recurse > 0) {
(*ptr)(recurse - 1); // with c++1y func( recurse - 1 )
}
};
return result;
}