目的：

学习C++模板的编写，使用模板类包装一个可调用对象
可调用对象包括：普通函数， lambda表达式， 类成员函数

可以参考到QtConcurrent::run的实现，可以看到这个函数有非常多重载，其中可以接受类成员函数的重载如下(截图仅能展示部分)：

个人认为，这里的实现不是很好；这里是针对不同参数个数的函数，每一个都做一个重载，如果能实现一种方式，可以适配任意类型和数量的参数就好了

class AsyncTask
{
public:
    AsyncTask();

    // 支持可调用对象
    template <typename Functor, typename ...Args>
    static QFuture<std::result_of_t<Functor(Args...)>> postTask(Functor&& func, Args&& ...args)
    {
        return QtConcurrent::run(std::forward<Functor>(func), std::forward<Args>(args)...);
    }


    // 支持类成员函数
    template <typename Class, typename ReturnType, typename... Args>
    static QFuture<ReturnType> postTask(Class* instance, ReturnType(Class::*memFunc)(Args...), Args&&... args)
    {
        return QtConcurrent::run(instance, memFunc, std::forward<Args>(args)...);
    }
};

使用：

class A
{
public:
    int memFunc(double y, int x)
    {
        qDebug() << "class member func:" << y << x << QThread::currentThreadId();
        return x;
    }
};


int normalFunc(int x)
{
    qDebug() << "normal function:" << x << QThread::currentThreadId();
    return x;
}

int main(int argc, char *argv[])
{
    QFuture<bool> future = AsyncTask::postTask([](int x, int y)
    {
        qDebug() << "lambda:" << x << y << QThread::currentThreadId();
        return  x < y;
    }, 3, 2);       //绑定lambda表达式

    QFuture<int> future2 = AsyncTask::postTask(normalFunc, 5);      //绑定普通函数

    A x;
    QFuture<int> future3 = AsyncTask::postTask(&x, &A::memFunc, 2.5, 3);        //绑定类成员函数
 }

使用模板类包装类成员函数

// 模板类，用于包装类成员函数指针
template <typename Class, typename RetType, typename ...Args>
class MemberFunctionPointer
{
public:
    using MemFuncPtr = RetType(Class::*)(Args...);		//类成员函数指针
    MemberFunctionPointer(MemFuncPtr ptr, Class* obj): m_ptr(ptr), object(obj)
    {

    }

    RetType invoke(Args&&... args)
    {
        return (object->*m_ptr)(std:: forward<Args>(args)...);
    }
private:
    MemFuncPtr m_ptr;
    Class* object;
};

// 辅助函数，用于模板参数推导
// C++17之前, 模板类的模板参数不能自动推导,必须显示指出, 例如std::vector<int>; std::list<int>; 而模板函数的模板参数可以自动推导, 所以标准库才提供 std::make_pair的函数,减轻模板类的编码负担
template <typename Class, typename RetType, typename... Args>
MemberFunctionPointer<Class, RetType, Args...> make_wrapper(RetType (Class::*fn)(Args...), Class* object)
{
    return MemberFunctionPointer<Class, RetType, Args...>(fn, object);
}

使用：

    auto wrapper = make_wrapper(&A::memFunc, &x);
    wrapper.invoke(3.2, 8);

参考