為什么我不能std::apply申請成員函式

我正在嘗試開發一個包裝器來幫助人們pthread在呼叫任何成員函式時使用。

template <typename>
struct signature;

template <typename C, typename R, typename... Args>
struct signature<R (C::*)(Args...)> {
    using return_type        = R;
    using pure_argument_type = std::tuple<C*, std::tuple<Args...>>; // obj, {args...}
    using argument_type =
        std::tuple<R (C::*)(Args...), pure_argument_type>; // obj.mem_fn, {obj, args...}
};
    
struct Job {
public:
    Job()  = default;
    ~Job() = default;

    void join() { pthread_join(btd, nullptr); }

    template <typename C, typename F, typename... Args>
    int run(F C::*f, C* c, Args&&... args) {
        typename signature<decltype(f)>::pure_argument_type pureParams =
            std::make_tuple(c, std::forward_as_tuple(args...));
        typename signature<decltype(f)>::argument_type params = std::make_tuple(f, pureParams);

        return pthread_create(
            &btd, nullptr,
            [](void* p) {
                auto param = static_cast<typename signature<decltype(f)>::argument_type*>(p);
                std::apply(std::get<0>(*param), std::get<1>(*param)); ////// ERROR!
                return (void*)nullptr;
            },
            &params);
    }

private:
    pthread_t btd;
};

但是，當我嘗試執行以下操作時，

class Test {
public:
    void func(int& a, double& d) { a = 2; d = 2.0; }

    void dojob() {
        int a = 0;
        double d = 0.0;
        Job job;
        job.run(&Test::func, this, std::ref(a), std::ref(d));
        job.join();
        std::cout << "a:" << a << " d:" << d << std::endl;
    }
};

Test t;
t.dojob();

我得到錯誤：

In file included from /opt/compiler-explorer/gcc-11.2.0/include/c  /11.2.0/bits/stl_map.h:63,
                 from /opt/compiler-explorer/gcc-11.2.0/include/c  /11.2.0/map:61,
                 from <source>:2:
/opt/compiler-explorer/gcc-11.2.0/include/c  /11.2.0/tuple: In instantiation of 'constexpr decltype(auto) std::__apply_impl(_Fn&&, _Tuple&&, std::index_sequence<_Idx ...>) [with _Fn = void (Test::*&)(int&, double&); _Tuple = std::tuple<Test*, std::tuple<int&, double&> >&; long unsigned int ..._Idx = {0, 1}; std::index_sequence<_Idx ...> = std::integer_sequence<long unsigned int, 0, 1>]':
/opt/compiler-explorer/gcc-11.2.0/include/c  /11.2.0/tuple:1854:31:   required from 'constexpr decltype(auto) std::apply(_Fn&&, _Tuple&&) [with _Fn = void (Test::*&)(int&, double&); _Tuple = std::tuple<Test*, std::tuple<int&, double&> >&]'
<source>:98:27:   required from 'int Job::run(F C::*, C*, Args&& ...) [with C = Test; F = void(int&, double&); Args = {std::reference_wrapper<int>, std::reference_wrapper<double>}]'
<source>:118:16:   required from here
/opt/compiler-explorer/gcc-11.2.0/include/c  /11.2.0/tuple:1843:27: error: no matching function for call to '__invoke(void (Test::*&)(int&, double&), Test*&, std::__tuple_element_t<1, std::tuple<Test*, std::tuple<int&, double&> > >&)'
 1843 |       return std::__invoke(std::forward<_Fn>(__f),
      |              ~~~~~~~~~~~~~^~~~~~~~~~~~~~~~~~~~~~~~
 1844 |                            std::get<_Idx>(std::forward<_Tuple>(__t))...);
      |

你可以在這里得到我的代碼：https : //godbolt.org/z/sMjcxvP33

uj5u.com熱心網友回復：

的回傳型別std::get<1>(*param)是std::tuple<C*, std::tuple<Args...>>。

由于 this 的第二個元素的型別tuple也是 a tuple，所以需要使用std::apply再次展開，類似這樣

std::apply(
  [f = std::get<0>(*param)](auto* obj, auto&& args) {
    std::apply([&](auto&&... args) { 
      (obj->*f)(std::forward<decltype(args)>(args)...); 
    }, std::forward<decltype(args)>(args));
  },
  std::get<1>(*param));

演示

另一種選擇是嵌套弄平tuple到std::tuple<C*, Args...>，然后將其傳遞到std::apply沿f。

std::apply(
  std::get<0>(*param),
  std::tuple_cat(
    std::make_tuple(std::get<0>(std::get<1>(*param))),
                    std::get<1>(std::get<1>(*param))));

演示

uj5u.com熱心網友回復：

std::apply需要一個單一的包含所有引數元組，而不是嵌套結構彼此之內。

你有一個競爭條件，如果你的 lambda 沒有std::apply在run回傳時將引數復制到引數中，你將取消參考一個懸空指標。

template <typename C, typename R, typename... Args>
struct signature<R (C::*)(Args...)> {
    using return_type        = R;
    using pure_argument_type = std::tuple<C*, Args...>; // obj, args...
    struct argument_type {
        R (C::*fun)(Args...);
        pure_argument_type args;
    };
};
    
struct Job {
public:
    Job()  = default;
    ~Job() = default;

    void join() { pthread_join(btd, nullptr); }

    template <typename C, typename R, typename... Args>
    int run(R (C::*f)(Args...), C* c, Args&&... args) {
        using params_t = typename signature<R (C::*)(Args...)>::argument_type;

        auto * params = new params_t{f, std::tuple_cat(std::make_tuple(c), std::forward_as_tuple(args...))};

        return pthread_create(
            &btd, nullptr,
            [](void* p) {
                auto param = static_cast<params_t*>(p);
                std::apply(param->fun, param->args);
                delete param;
                return (void*)nullptr;
            },
            params);
    }

private:
    pthread_t btd;
};

標籤：

上一篇：如何在MATLAB中使用FIR濾波器過濾音頻檔案中的噪聲？

下一篇：全域變數的“未決議的外部符號”