多线程bind二次封装

#include <iostream>
#include <functional>
#include <tuple>
#include <utility>

template <typename Callable, typename... Args>
auto deduce_return_type(Callable&& c, Args&&... args)
-> typename std::result_of<Callable(Args...)>::type {
    return std::forward<Callable>(c)(std::forward<Args>(args)...);
}

template<typename F, typename... Args>
auto binddd(F&& f, Args&&... args) -> std::function<decltype(deduce_return_type(f, args...))()> {
    using ReturnType = decltype(deduce_return_type(f, args...));

    std::function<ReturnType()> func = std::bind(std::forward<F>(f), std::forward<Args>(args)...);

    return func;
}


template<typename F, typename... Args>
auto binddd2(F&& f, Args&&... args) -> std::function<decltype(f( args...))()> {

    std::function<decltype(f(args...))()> func = std::bind(std::forward<F>(f), std::forward<Args>(args)...);

    return func;
}

template<typename F, typename... Args>
auto binddd3(F&& f, Args&&... args){

    auto func = std::bind(std::forward<F>(f), std::forward<Args>(args)...);

    return func;
}

void Function2(int* value) {
    *value = *value + 1;
    std::cout << "value" << *value << "\n";
}
class MyClass {
public:
    void myMemberFunction(int* value) {
        *value = *value + 1;
        std::cout << "Value from thread: " << *value << std::endl;
    }
};
int main() {
    int* v = new int(1);
    MyClass  myclass;
    {
        auto callable = std::bind(Function2, v);
        callable();

        auto callable2 = std::bind(&MyClass::myMemberFunction, &myclass,v);
        callable2();
    }

    {
        auto callable = binddd(Function2, v);
        callable();

        auto callable2 = binddd(&MyClass::myMemberFunction, &myclass, v);
        callable2();
    }


    {
        auto callable = binddd2(Function2, v);
        callable();

        //报错，不能支持成员函数，关键在于decltype(f( args...))推导类型失败，因为多了对象指针与函数参数类型不匹配
        auto callable2 = binddd2(&MyClass::myMemberFunction, &myclass, v);
        callable2();
    }

    {
        auto callable = binddd3(Function2, v);
        callable();

        //虽然支持成员函数，但是在编写是不能检查参数类型是否正确，只能在编译是报错。假如v的类型是string，编写之后是不报错的。
        auto callable2 = binddd3(&MyClass::myMemberFunction, &myclass, v);
        callable2();
    }


    delete v; 

    return 0;
}