请教 请问可以不可以实现一个变参成员(类似变参模版)的类。

首页 论坛 社区服务 请教 请问可以不可以实现一个变参成员(类似变参模版)的类。

该话题包含 2 个回复,有 3 个参与人,并且由  patton882 周 前 最后一次更新。

正在查看 3 个帖子 - 1 至 3 (共计 3 条)
  • 作者
    帖子
  • #1394

    3ndwind
    参与者

    请教 请问可以不可以实现一个变参成员(类似变参模版)的类。
    优化下面代码?我只是问可行性?不需要提供具体的代码, 非常感谢!
    template<typename TRet, typename TP1>
    class Task1: public TaskBase
    {
    public:
    using TaskType = std::function<TRet(TP1)>;
    Task1(TaskType pFunction,TP1 p1)
    : mFunction(pFunction), mP1(p1)
    {

    }
    bool execute()
    {
    lRet = mFunction(mP1);
    return lRet;
    }
    private:
    TRet lRet;
    TaskType mFunction;
    TP1 mP1;
    };

    template<typename TRet, typename TP1,typename TP2>
    class Task2: public TaskBase
    {
    public:
    using TaskType = std::function<TRet(TP1,TP2)>;
    Task2(TaskType pFunction, TP1 p1, TP2 p2)
    : mFunction(pFunction), mP1(p1), mP2(p2)
    {

    }
    bool execute()
    {
    lRet = mFunction(mP1,mP2);
    return lRet;
    }
    private:
    TRet lRet;
    TaskType mFunction;
    TP1 mP1;
    TP2 mP2;
    };

    • 该话题由  3ndwind 于 1 月 前 修正。
    #1402

    yanwei1983
    参与者

    参数std::thread的实现

    #1435

    patton88
    参与者

    //实现一个变参成员(类似变参模版)的类。VS2017编译运行通过
    //Win32Con17_VS2017_01.cpp

    #include <tuple>
    #include <functional>
    #include <iostream>
    using namespace std;

    int fun1(int a) { return a; }
    int fun2(int a, int b) { return a + b; }
    int fun3(int a, int b, int c) { return a + b + c; }

    class TaskBase
    {
    public:
    TaskBase() {}
    virtual ~TaskBase() {}
    };

    //请教 请问可以不可以实现一个变参成员(类似变参模版)的类。
    //优化下面代码?我只是问可行性?不需要提供具体的代码, 非常感谢!
    template<typename TRet, typename TP1>
    class Task1 : public TaskBase
    {
    public:
    using TaskType = std::function<TRet(TP1)>;
    Task1(TaskType pFunction, TP1 p1) : mFunction(pFunction), mP1(p1) {}

    TRet execute()
    {
    lRet = mFunction(mP1);
    return lRet;
    }

    private:
    TRet lRet;
    TaskType mFunction;
    TP1 mP1;
    };

    template<typename TRet, typename TP1, typename TP2>
    class Task2 : public TaskBase
    {
    public:
    using TaskType = std::function<TRet(TP1, TP2)>;
    Task2(TaskType pFunction, TP1 p1, TP2 p2) : mFunction(pFunction), mP1(p1), mP2(p2) {}

    TRet execute()
    {
    lRet = mFunction(mP1, mP2);
    return lRet;
    }

    private:
    TRet lRet;
    TaskType mFunction;
    TP1 mP1;
    TP2 mP2;
    };

    template<typename TRet, typename… TP>
    class TaskX : public TaskBase
    {
    public:
    using TaskType = std::function<TRet(TP…)>;
    TaskX(TaskType pFunction, TP… tp) : mFunction(pFunction)
    {
    mTup = make_tuple(tp…);
    }

    TRet execute()
    {
    lRet = apply(mFunction, mTup);
    return lRet;
    }

    private:
    TRet lRet;
    TaskType mFunction;
    tuple<TP…> mTup;

    template<typename Fun, typename Tup>
    auto apply(Fun fun, const Tup& tup)
    {
    return apply_impl(fun, tup, make_index_sequence<tuple_size<Tup>::value>());
    }

    template<typename Fun, typename Tup, size_t… Index>
    auto apply_impl(Fun fun, const Tup& tup, index_sequence<Index…>)
    {
    return fun(get<Index>(tup)…);
    }
    };

    int main()
    {
    Task1<int, int> task1(fun1, 3); cout << task1.execute() << endl; //3
    Task2<int, int, int> task2(fun2, 3, 5); cout << task2.execute() << endl; //8

    TaskX<int, int> taskx1(fun1, 3); cout << taskx1.execute() << endl; //3
    TaskX<int, int, int> taskx2(fun2, 3, 5); cout << taskx2.execute() << endl; //8

    system(“pause”);
    return 0;
    }

正在查看 3 个帖子 - 1 至 3 (共计 3 条)

抱歉,回复话题必需登录。

Copy Protected by Chetan's WP-Copyprotect.