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 解决了这个问题。
#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_function | std::function |
|---|---|---|
| 要求可拷贝 | 不要求 | 要求 |
| 自身可拷贝 | 不可以(仅可移动) | 可以 |
| 调用空对象 | 未定义行为 | 抛出 bad_function_call |
| cv/ref 限定 | 支持 | 不支持 |
| noexcept 限定 | 支持 | 不支持 |
| target/target_type | 不提供 | 提供 |
| 标准版本 | C++23 | C++11 |
基本示例
#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...) const | const |
R(Args...) & | 左值引用 |
R(Args...) const & | const 左值引用 |
R(Args...) && | 右值引用 |
R(Args...) const && | const 右值引用 |
R(Args...) noexcept | noexcept |
R(Args...) const noexcept | const 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。典型应用场景包括任务队列、一次性回调、线程池任务存储等。注意调用空对象是未定义行为,使用前应检查是否为空。