std::move_only_function ​

什么是 std::move_only_function ​

std::move_only_function 是 C++23 引入的多态函数包装器,定义在 <functional> 头文件中。它和 std::function 类似,可以包装任意可调用对象(函数、lambda、函数对象等),但有一个关键区别:它不要求被包装的可调用对象是可拷贝的。

std::function 要求存储的目标必须是可拷贝的,这意味着它不能包装持有 std::unique_ptr、std::packaged_task 等仅可移动类型的 lambda 或函数对象。std::move_only_function 解决了这个问题。

cpp
#include <functional>
#include <memory>

auto ptr = std::make_unique<int>(42);

// std::function 不行——lambda 捕获了 unique_ptr,不可拷贝
// std::function<int()> f = [p = std::move(ptr)] { return *p; };  // 编译错误

// std::move_only_function 可以
std::move_only_function<int()> f = [p = std::move(ptr)] { return *p; };

move_only_function vs function ​

特性std::move_only_functionstd::function
要求可拷贝不要求要求
自身可拷贝不可以(仅可移动)可以
调用空对象未定义行为抛出 bad_function_call
cv/ref 限定支持不支持
noexcept 限定支持不支持
target/target_type不提供提供
标准版本C++23C++11

基本示例 ​

cpp
#include <iostream>
#include <functional>
#include <memory>
#include <string>
#include <vector>
#include <future>
#include <thread>
#include <queue>
#include <mutex>

// ============================
// 示例1:包装仅可移动的 lambda
// ============================

void basic_demo() {
    auto ptr = std::make_unique<int>(42);

    // 捕获 unique_ptr 的 lambda 不可拷贝
    std::move_only_function<int()> func = [p = std::move(ptr)] {
        return *p;
    };

    std::cout << "结果: " << func() << std::endl;  // 42
}

// ============================
// 示例2:包装 packaged_task
// ============================

void packaged_task_demo() {
    std::packaged_task<double()> task([] { return 3.14159; });
    std::future<double> future = task.get_future();

    // packaged_task 不可拷贝,function 无法包装
    // std::function<void()> f = std::move(task);  // 编译错误

    // move_only_function 可以
    std::move_only_function<void()> func = std::move(task);
    func();

    std::cout << "pi = " << future.get() << std::endl;
}

// ============================
// 示例3:const 限定
// ============================

void const_qualified_demo() {
    int counter = 0;

    // 签名中带 const:operator() 是 const 的
    std::move_only_function<int() const> func = [counter]() mutable {
        // 注意:这里会编译错误,因为签名要求 const
        // counter++;  // 错误:const 限定不允许修改
        return counter;
    };

    // 非 const 签名
    std::move_only_function<int()> mutable_func = [counter]() mutable {
        return ++counter;
    };

    std::cout << "const: " << func() << std::endl;
    std::cout << "mutable: " << mutable_func() << std::endl;
    std::cout << "mutable: " << mutable_func() << std::endl;
}

// ============================
// 示例4:noexcept 限定
// ============================

void noexcept_demo() {
    // 签名中指定 noexcept
    std::move_only_function<int() noexcept> safe_func = []() noexcept {
        return 42;
    };

    // 非 noexcept 的 lambda 不能赋值给 noexcept 签名
    // std::move_only_function<int() noexcept> bad = [] { throw 1; return 0; };
    // 编译错误

    std::cout << "noexcept 函数: " << safe_func() << std::endl;
}

// ============================
// 示例5:任务队列
// ============================

class TaskQueue {
    std::queue<std::move_only_function<void()>> tasks_;
    std::mutex mutex_;

public:
    // 添加任务——可以接受仅可移动的可调用对象
    template<typename F>
    void push(F&& func) {
        std::lock_guard lock(mutex_);
        tasks_.push(std::move(func));
    }

    // 执行下一个任务
    bool execute_one() {
        std::lock_guard lock(mutex_);
        if (tasks_.empty()) return false;

        auto task = std::move(tasks_.front());
        tasks_.pop();

        // 在锁外执行
        mutex_.unlock();
        task();
        mutex_.lock();
        return true;
    }

    size_t size() const {
        std::lock_guard lock(mutex_);
        return tasks_.size();
    }
};

void task_queue_demo() {
    TaskQueue queue;

    // 普通 lambda
    queue.push([] {
        std::cout << "  任务1: 普通 lambda" << std::endl;
    });

    // 带 unique_ptr 的 lambda
    auto data = std::make_unique<std::string>("重要数据");
    queue.push([d = std::move(data)] {
        std::cout << "  任务2: " << *d << std::endl;
    });

    // packaged_task
    std::packaged_task<int()> task([] { return 100; });
    auto future = task.get_future();
    queue.push(std::move(task));

    // 执行所有任务
    while (queue.execute_one()) {}

    std::cout << "  任务3 结果: " << future.get() << std::endl;
}

// ============================
// 示例6:回调注册
// ============================

class EventEmitter {
    std::vector<std::move_only_function<void(int)>> listeners_;

public:
    template<typename F>
    void on(F&& listener) {
        listeners_.push_back(std::move(listener));
    }

    void emit(int value) {
        for (auto& listener : listeners_) {
            listener(value);
        }
    }
};

void callback_demo() {
    EventEmitter emitter;

    // 注册普通回调
    emitter.on([](int v) {
        std::cout << "  监听器A: " << v << std::endl;
    });

    // 注册带资源的回调
    auto resource = std::make_unique<std::string>("资源");
    emitter.on([r = std::move(resource)](int v) {
        std::cout << "  监听器B (" << *r << "): " << v << std::endl;
    });

    emitter.emit(42);
}

// ============================
// 示例7:operator bool 检查
// ============================

void null_check_demo() {
    std::move_only_function<void()> func;  // 空

    if (!func) {
        std::cout << "func 为空" << std::endl;
    }

    func = [] { std::cout << "已赋值" << std::endl; };

    if (func) {
        func();
    }

    // 赋值为 nullptr
    func = nullptr;
    std::cout << "清空后为空: " << std::boolalpha << !func << std::endl;
}

int main() {
    std::cout << "=== 仅可移动 lambda ===" << std::endl;
    basic_demo();

    std::cout << "\n=== packaged_task ===" << std::endl;
    packaged_task_demo();

    std::cout << "\n=== const 限定 ===" << std::endl;
    const_qualified_demo();

    std::cout << "\n=== noexcept 限定 ===" << std::endl;
    noexcept_demo();

    std::cout << "\n=== 任务队列 ===" << std::endl;
    task_queue_demo();

    std::cout << "\n=== 回调注册 ===" << std::endl;
    callback_demo();

    std::cout << "\n=== 空检查 ===" << std::endl;
    null_check_demo();

    return 0;
}

支持的签名限定 ​

std::move_only_function 支持在签名中添加 cv 限定、引用限定和 noexcept:

签名形式operator() 的限定
R(Args...)无限定
R(Args...) constconst
R(Args...) &左值引用
R(Args...) const &const 左值引用
R(Args...) &&右值引用
R(Args...) const &&const 右值引用
R(Args...) noexceptnoexcept
R(Args...) const noexceptconst noexcept

适用场景 ​

  • 包装持有仅可移动资源的 lambda(unique_ptr 等)
  • 任务队列和线程池中存储任务
  • 回调系统中存储一次性回调
  • 包装 std::packaged_task
  • 需要 cv/ref/noexcept 限定的函数包装

常见问题 ​

调用空的 move_only_function 会怎样?

未定义行为。与 std::function 不同(抛出 bad_function_call),move_only_function 调用空对象是 UB。使用前应该检查 operator bool()。

move_only_function 可以拷贝吗?

不可以。它只能移动。如果需要可拷贝的函数包装器,用 std::function 或 C++26 的 std::copyable_function。

move_only_function 比 function 更高效吗?

通常是的。因为不需要支持拷贝,move_only_function 的实现可以更简单,不需要虚拷贝函数,内存布局更紧凑。

注意事项 ​

  • 仅可移动,不可拷贝
  • 调用空对象是未定义行为,不是异常
  • 不提供 target() 和 target_type() 成员函数
  • 签名中的 cv/ref/noexcept 限定影响 operator() 的调用方式
  • 需要 <functional> 头文件

总结 ​

std::move_only_function 是 C++23 引入的仅可移动函数包装器,解决了 std::function 要求目标可拷贝的限制。它可以包装持有 unique_ptr、packaged_task 等仅可移动资源的可调用对象。与 function 相比,它还支持在签名中添加 const、引用限定和 noexcept。典型应用场景包括任务队列、一次性回调、线程池任务存储等。注意调用空对象是未定义行为,使用前应检查是否为空。