C++23标准新增的std::move_only_function是一个仅可移动的可调用对象包装器，它弥补了std::function无法存储不可拷贝可调用对象的缺陷，非常适合用来处理持有独占资源、不可拷贝的异步任务类型。
std::move_only_function基本特性
std::move_only_function位于<functional>头文件中，它的模板参数和std::function类似，用来指定可调用对象的签名，核心特点是它不支持拷贝操作，只支持移动操作，因此可以存储持有std::unique_ptr等仅可移动资源的可调用对象。
它和std::function的核心差异如下：
| 特性 | std::function | std::move_only_function |
|---|---|---|
| 拷贝支持 | 支持 | 不支持 |
| 移动支持 | 支持 | 支持 |
| 可存储仅可移动可调用对象 | 不支持 | 支持 |
| 空状态检查 | 支持 | 支持 |
非拷贝型异步任务的定义
非拷贝型异步任务通常指任务对象持有不可拷贝的资源，比如独占的智能指针、文件描述符、互斥锁等，这类任务无法通过拷贝的方式传递或存储。下面是一个典型的非拷贝型异步任务示例，任务持有std::unique_ptr资源：
#include <iostream>
#include <memory>
#include <functional>
// 非拷贝型异步任务，持有unique_ptr资源
struct NonCopyableTask {
std::unique_ptr<int> data;
NonCopyableTask(std::unique_ptr<int> d) : data(std::move(d)) {}
// 禁止拷贝构造和拷贝赋值
NonCopyableTask(const NonCopyableTask&) = delete;
NonCopyableTask& operator=(const NonCopyableTask&) = delete;
// 支持移动构造和移动赋值
NonCopyableTask(NonCopyableTask&&) = default;
NonCopyableTask& operator=(NonCopyableTask&&) = default;
// 可调用对象，返回任务处理结果
int operator()() const {
return *data + 10;
}
};
这个任务类型因为持有std::unique_ptr成员，无法被拷贝，如果用std::function存储会直接编译报错。
使用std::move_only_function处理非拷贝型异步任务
下面演示如何用std::move_only_function存储和传递上述非拷贝型异步任务，模拟异步任务的提交和执行流程：
#include <iostream>
#include <memory>
#include <functional>
#include <vector>
#include <thread>
#include <chrono>
// 定义异步任务类型，返回int，无参数
using AsyncTask = std::move_only_function<int()>;
// 模拟任务队列，存储异步任务
std::vector<AsyncTask> task_queue;
// 提交异步任务到队列
void submit_task(AsyncTask task) {
task_queue.push_back(std::move(task));
}
// 执行队列中的所有任务
void execute_tasks() {
for (auto& task : task_queue) {
if (task) { // 检查任务是否为空
int result = task();
std::cout << "任务执行结果: " << result << std::endl;
}
}
task_queue.clear();
}
int main() {
// 创建非拷贝型任务，持有unique_ptr资源
auto data = std::make_unique<int>(5);
NonCopyableTask task(std::move(data));
// 将任务提交到队列，只能用移动语义传递
submit_task(std::move(task));
// 模拟异步执行，等待一段时间后执行任务
std::this_thread::sleep_for(std::chrono::milliseconds(100));
execute_tasks();
return 0;
}
上述代码中，AsyncTask被定义为std::move_only_function<int()>，可以接收NonCopyableTask类型的可调用对象，提交任务时只能通过std::move传递，符合非拷贝型任务的特性。
实际异步场景中的应用
在实际的异步编程中，比如线程池的任务提交，经常需要传递带有独占资源的任务，使用std::move_only_function可以避免额外的资源拷贝开销，也能保证资源的所有权清晰。下面是一个简化版线程池的任务提交示例：
#include <iostream>
#include <memory>
#include <functional>
#include <thread>
#include <queue>
#include <mutex>
#include <condition_variable>
// 线程池任务类型
using ThreadPoolTask = std::move_only_function<void()>;
class SimpleThreadPool {
public:
SimpleThreadPool(size_t thread_num) : stop(false) {
for (size_t i = 0; i < thread_num; ++i) {
workers.emplace_back([this] {
while (true) {
ThreadPoolTask task;
{
std::unique_lock<std::mutex> lock(queue_mutex);
condition.wait(lock, [this] { return stop || !tasks.empty(); });
if (stop && tasks.empty()) return;
task = std::move(tasks.front());
tasks.pop();
}
if (task) task();
}
});
}
}
// 提交任务到线程池
void enqueue(ThreadPoolTask task) {
{
std::unique_lock<std::mutex> lock(queue_mutex);
tasks.push(std::move(task));
}
condition.notify_one();
}
~SimpleThreadPool() {
{
std::unique_lock<std::mutex> lock(queue_mutex);
stop = true;
}
condition.notify_all();
for (std::thread &t : workers) {
if (t.joinable()) t.join();
}
}
private:
std::vector<std::thread> workers;
std::queue<ThreadPoolTask> tasks;
std::mutex queue_mutex;
std::condition_variable condition;
bool stop;
};
int main() {
SimpleThreadPool pool(2);
// 提交带独有资源的任务
auto res = std::make_unique<std::string>("异步任务结果");
pool.enqueue([ptr = std::move(res)] {
std::cout << "执行任务，资源内容: " << *ptr << std::endl;
});
// 等待任务执行完成
std::this_thread::sleep_for(std::chrono::milliseconds(200));
return 0;
}
这个线程池的实现中，任务类型使用std::move_only_function，支持提交捕获了std::unique_ptr的lambda表达式，这类lambda本身是不可拷贝的，用std::function无法存储，而std::move_only_function可以完美支持。
使用注意事项
- std::move_only_function不支持拷贝，传递时只能使用移动语义，避免尝试拷贝操作导致编译错误。
- 可以通过operator bool()检查std::move_only_function是否为空，避免调用空对象导致未定义行为。
- 模板参数指定的可调用对象签名需要和实际存储的可调用对象匹配，否则无法存储。
- 如果需要支持拷贝可调用对象，还是应该使用std::function，两者适用场景不同，不要混用。
总结
std::move_only_function是C++23中非常实用的新特性，它解决了std::function无法存储仅可移动可调用对象的问题，特别适合处理非拷贝型的异步任务。在异步编程、线程池、任务队列等场景中，使用它可以更安全地管理带有独占资源的任务，避免不必要的资源拷贝，让代码的逻辑更清晰，资源所有权更明确。
std::move_only_functionC++23非拷贝型异步任务异步任务处理修改时间：2026-06-15 20:21:22