C++标准库是否有不可拷贝构造的函数类型？移动捕获Lambda传递方案咨询

你的核心问题是：捕获了仅可移动对象（通过std::move捕获）的Lambda不具备拷贝构造能力，而std::function要求存储的可调用对象必须可拷贝，因此无法直接适配。以下是几种更优的替代方案：

1. 用模板参数直接接受可调用对象（最简洁高效） #

如果不需要类型擦除（比如不需要将不同类型的Lambda存入同一容器，或者不需要统一的函数参数类型），直接把接收Lambda的函数改成模板函数，让编译器推导Lambda的具体类型。这种方式不需要任何额外包装，零开销，且天然支持仅移动的Lambda：

// 定义模板函数，直接接受右值引用的可调用对象
template<typename Callable>
void execute_task(Callable&& task) {
    task(); // 执行Lambda逻辑
}

// 调用时直接传递仅移动Lambda
execute_task([
    promise = std::move(promise),
    namedSeries = std::move(namedSeries)
] mutable {
    // 你的业务逻辑
});

这种方案完全避免了类型擦除的开销，也不需要额外样板代码，是优先选择。

2. 使用C++23的std::move_only_function（标准库原生支持类型擦除） #

如果需要类型擦除（比如要存储多个不同类型的仅移动Lambda，或者需要给函数传递统一类型的可调用对象），C++23引入了std::move_only_function，它专门用于包装仅可移动的可调用对象，和std::function用法类似，但不要求可拷贝：

#include <functional> // 包含std::move_only_function

// 函数参数使用std::move_only_function
void execute_task(std::move_only_function<void()> task) {
    task();
}

// 调用方式和普通Lambda一致
execute_task([
    promise = std::move(promise),
    namedSeries = std::move(namedSeries)
] mutable {
    // 业务逻辑
});

这是标准库的原生解决方案，不需要自己实现包装器，代码简洁且符合标准。

3. 自行实现移动-only函数包装器（C++23之前的版本） #

如果项目还在使用C++20及更早的标准，可以自己实现一个轻量的移动-only函数包装器，核心思路是用虚函数实现类型擦除，且只支持移动操作：

class MoveOnlyFunc {
public:
    // 构造函数：接受任意可调用对象，转发为右值
    template<typename Func>
    MoveOnlyFunc(Func&& func) : impl_(new Impl<Func>(std::move(func))) {}

    // 仅支持移动构造和赋值
    MoveOnlyFunc(MoveOnlyFunc&& other) noexcept : impl_(std::exchange(other.impl_, nullptr)) {}
    MoveOnlyFunc& operator=(MoveOnlyFunc&& other) noexcept {
        if (this != &other) {
            delete impl_;
            impl_ = std::exchange(other.impl_, nullptr);
        }
        return *this;
    }

    // 禁止拷贝
    MoveOnlyFunc(const MoveOnlyFunc&) = delete;
    MoveOnlyFunc& operator=(const MoveOnlyFunc&) = delete;

    ~MoveOnlyFunc() { delete impl_; }

    // 重载()运算符执行任务
    void operator()() const {
        impl_->invoke();
    }

private:
    // 基类定义统一调用接口
    struct BaseImpl {
        virtual ~BaseImpl() = default;
        virtual void invoke() const = 0;
    };

    // 派生类持有具体的可调用对象
    template<typename Func>
    struct Impl : BaseImpl {
        Func func_;
        Impl(Func&& f) : func_(std::move(f)) {}
        void invoke() const override { func_(); }
    };

    BaseImpl* impl_;
};

// 使用示例
void execute_task(MoveOnlyFunc task) {
    task();
}

这个包装器只支持移动操作，完美适配你的仅移动Lambda，且代码量不大，不需要依赖第三方库。

内容的提问来源于stack exchange，提问作者John Glen