将带有移动捕获的 lambda 传递给函数

Question

我最近遇到了一个对我来说很难找到的错误。我试图将 lambda 传递给采用 std::function 对象的函数。 lambda 正在捕获一个不可复制的对象。

我想通了，显然在所有传球之间一定会发生一些副本。我得出这个结果是因为我总是以 error: use of deleted function 错误结束。

这是产生此错误的代码：

void call_func(std::function<void()> func)
{
    func();
}

int main()
{
    std::fstream fs{"test.txt", std::fstream::out};
    auto lam = [fs = std::move(fs)] { const_cast<std::fstream&>(fs).close(); };
    call_func(lam);
    return 0;
}

我通过将std::fstream 对象封装在std::shared_ptr 对象中解决了这个问题。这工作正常，但我认为可能有更性感的方式来做到这一点。

我现在有两个问题：

1. 为什么会出现此错误？
2. 我的想法：我在for 循环中生成了许多fstream 对象和lambda，并且对于每个fstream，都有一个lambda 写入它。所以对fstream 对象的访问只能由lambdas 完成。我想为一些回调逻辑这样做。有没有像我尝试过的那样使用 lambdas 更漂亮的方法？

Answer 1

发生错误是因为您的 lambda 具有不可复制的捕获，使 lambda 本身不可复制。 std::functionrequires that the wrapped object be copy-constructible.

如果您可以控制call_func，请将其设为模板：

template<typename T>
void call_func(T&& func)
{
    func();
}

int main()
{
    std::fstream fs{"test.txt", std::fstream::out};
    auto lam = [fs = std::move(fs)] { const_cast<std::fstream&>(fs).close(); };
    call_func(lam);
}

---

以下是我对您在 (2) 中的想法的看法。由于std::function 要求被包装的对象是可复制构造的，我们可以制作我们自己的没有这个限制的函数包装器：

#include <algorithm>
#include <fstream>
#include <iterator>
#include <utility>
#include <memory>
#include <sstream>
#include <vector>

template<typename T>
void call_func(T&& func) {
    func();
}

// All functors have a common base, so we will be able to store them in a single container.
struct baseFunctor {
    virtual void operator()()=0;
};

// The actual functor is as simple as it gets.
template<typename T>
class functor : public baseFunctor {
    T f;
public:
    template<typename U>
    functor(U&& f)
        :    f(std::forward<U>(f))
    {}
    void operator()() override {
        f();
    }
};

// In C++17 you don't need this: functor's default constructor can already infer T.
template<typename T>
auto makeNewFunctor(T&& v) {
    return std::unique_ptr<baseFunctor>(new functor<T>{std::forward<T>(v)});
}

int main() {
    // We need to store pointers instead of values, for the virtual function mechanism to behave correctly.
    std::vector<std::unique_ptr<baseFunctor>> functors;

    // Generate 10 functors writing to 10 different file streams
    std::generate_n(std::back_inserter(functors), 10, [](){
        static int i=0;
        std::ostringstream oss{"test"};
        oss << ++i << ".txt";
        std::fstream fs{oss.str(), std::fstream::out};
        return makeNewFunctor([fs = std::move(fs)] () mutable { fs.close(); });
    });

    // Execute the functors
    for (auto& functor : functors) {
        call_func(*functor);
    }
}

请注意，虚拟调用的开销是不可避免的：由于您需要将具有不同行为的函子存储在同一个容器中，因此您基本上需要一种或另一种方式的多态行为。所以你要么手动实现这个多态，要么使用virtual。我更喜欢后者。