C++23 新特性详解：std::move_only_function —— 专为可移动不可复制函数对象而生

在 C++23 标准中，std::move_only_function 的引入填补了标准库函数包装器长期存在的关键空白。此前，std::function 要求其封装的可调用对象必须满足 CopyConstructible（可复制构造）——这一约束在现代 C++ 中日益成为负担：当目标对象持有唯一资源（如 std::unique_ptr、std::thread 或自定义句柄）时，复制语义天然不成立。std::move_only_function 正是为此而生：它仅要求可调用对象支持移动语义，彻底解耦“可调用性”与“可复制性”，使资源独占型回调的封装变得自然、安全且零开销。

为什么需要 move_only_function？

std::function 的设计初衷面向通用场景，但其复制能力带来了三重隐性成本：

1. 语义冲突：强制复制一个本应独占资源的对象（如 std::unique_ptr<int>）会导致编译失败或逻辑错误；
2. 性能损耗：即使可复制，深拷贝大型闭包或状态机也可能带来非预期开销；
3. 接口污染：开发者被迫为不可复制类型编写冗余的包装层（如手动管理 std::shared_ptr），破坏类型安全性与意图表达。

std::move_only_function 直接回应上述问题：它仅提供移动构造、移动赋值和调用操作符，明确宣告“此函数对象不可复制”，从类型系统层面杜绝误用。

基本语法与使用方式

std::move_only_function 定义于 <functional> 头文件中，模板参数形式与 std::function 一致，声明为：

template<class R, class... Args>
class move_only_function<R(Args...)>;

其核心成员函数包括：

• move_only_function() noexcept; —— 默认构造（空状态）
• move_only_function(move_only_function&&) noexcept; —— 移动构造
• move_only_function& operator=(move_only_function&&) noexcept; —— 移动赋值
• explicit operator bool() const noexcept; —— 空状态检查
• R operator()(Args...) const; —— 函数调用（要求内部可调用对象支持 const 调用）

注意：它不提供复制构造、复制赋值，也不提供 .target() 或 .target_type() 成员——这些被刻意省略以强化移动语义契约。

实际代码示例

以下示例展示如何封装一个持有 std::unique_ptr 的 lambda，并通过 move_only_function 传递：

#include <functional>
#include <memory>
#include <iostream>

int main() {
    // 创建一个独占资源的 lambda：捕获 unique_ptr，无法复制
    auto closure = [ptr = std::make_unique<int>(42)]() mutable -> int {
        return *ptr + 1;
    };

    // ✅ 正确：move_only_function 可接收该 lambda
    std::move_only_function<int()> func{std::move(closure)};

    // ✅ 调用正常
    std::cout << "Result: " << func() << "\n"; // 输出 43

    // ❌ 编译错误：尝试复制 move_only_function
    // auto func2 = func; // error: use of deleted function

    // ✅ 可安全移动
    auto func3 = std::move(func);
    std::cout << "After move: " << (static_cast<bool>(func) ? "valid" : "empty") << "\n";
    std::cout << "func3 result: " << func3() << "\n";

    return 0;
}

再看一个更贴近工程实践的异步任务调度场景：

#include <functional>
#include <queue>
#include <memory>
#include <mutex>
#include <thread>

class TaskQueue {
public:
    using task_t = std::move_only_function<void()>;

    void push(task_t task) {
        std::lock_guard<std::mutex> lock(mtx_);
        tasks_.push(std::move(task));
    }

    task_t pop() {
        std::lock_guard<std::mutex> lock(mtx_);
        if (tasks_.empty()) return {};
        auto task = std::move(tasks_.front());
        tasks_.pop();
        return task;
    }

private:
    std::queue<task_t> tasks_;
    mutable std::mutex mtx_;
};

// 使用示例：提交一个带独占资源的异步任务
void example_usage() {
    TaskQueue queue;

    // 捕获 unique_ptr 和 thread_local 状态，天然不可复制
    auto task = [ptr = std::make_unique<double>(3.14159)]() {
        std::cout << "Pi ≈ " << *ptr << "\n";
    };

    queue.push(std::move(task)); // ✅ 无拷贝，高效入队

    // 后续在线程池中执行...
}

与 std::function 的关键差异总结

注意事项与最佳实践

• move_only_function 的调用操作符要求内部可调用对象支持 const 调用。若需修改捕获状态，请确保 lambda 声明为 mutable（如上例所示）。
• 与 std::function 类似，它仍依赖类型擦除，存在间接调用开销；对极致性能敏感路径，应优先考虑模板化策略或直接传参。
• 当函数对象生命周期需跨越多个所有者时，std::shared_ptr<std::function<...>> 仍是合理选择；move_only_function 更适用于“单次移交”或“所有权明确转移”的场景（如事件队列、协程挂起点、RAII 回调等）。
• 所有标准容器（如 std::vector, std::queue）均天然支持 move_only_function，因其满足 MoveInsertable 和 Erasable 要求。

结语

std::move_only_function 并非对 std::function 的替代，而是对其能力边界的优雅拓展。它标志着 C++ 标准库持续向“精准建模语义”演进：不再强加不必要的约束，而是让类型系统成为开发者意图的忠实表达者。在 C++23 逐步落地的今天，理解并善用这一工具，不仅能写出更安全、更高效的回调抽象，更能推动团队形成尊重移动语义、规避隐式复制的现代 C++ 编程习惯。当你的 lambda 拥抱 std::unique_ptr，当你的异步任务拒绝被拷贝——std::move_only_function 就是你最可靠的承载容器。