模仿QConcurrent::run写一个类，传入类指针和类成员函数，达到异步的效果

在C++中，我们可以创建一个简单的线程池类，类似于`std::async`的功能，用于异步执行传递进来的类成员函数。下面是一个基础的实现，假设我们有一个名为`Worker`的类，它有一个可以异步执行的公共成员函数`doWork`：

#include <iostream>
#include <future>
#include <thread>

// 假设有一个Worker类
class Worker {
public:
    // 类成员函数，需要异步执行
    void doWork(int id) {
        std::cout << "Worker " << id << " started." << std::endl;
        // 这里模拟耗时操作
        std::this_thread::sleep_for(std::chrono::seconds(2));
        std::cout << "Worker " << id << " finished." << std::endl;
    }
};

// 线程池类
template <typename Func, typename... Args>
class ThreadPool {
private:
    std::vector<std::future<void>> futures;

public:
    void enqueue(Func func, Args... args) {
        auto task = std::bind(func, this, args...);
        futures.push_back(std::async(std::launch::async, task));
    }

    // 异步执行完毕后会调用join方法
    ~ThreadPool() {
        for (auto& future : futures) {
            future.get(); // 等待所有任务完成
        }
    }
};

int main() {
    // 创建线程池并异步执行Worker的doWork方法
    ThreadPool<Worker, int> pool;
    pool.enqueue(&Worker::doWork, 1);

    // 可能还有其他任务...
    // pool.enqueue(&Worker::doWork, 2); // 如果需要，可以添加更多任务

    return 0;
}

在这个例子中，当我们调用`enqueue`方法并将`doWork`方法及其参数作为参数传递给它时，`ThreadPool`内部会创建一个新的线程来执行这个任务，并返回一个`std::future`对象。当主线程结束时，`ThreadPool`的析构函数会自动等待所有线程完成。