Question

我想实现一个类模板：

表现得像一个功能
它的输入和输出变量都是共享的。
相对容易使用。

结果，我构建了以下内容：

// all input/output variable's base class
class basic_logic_parameter;

// input/output variable, has theire value and iterators to functions that reference to this variable
template <typename FuncIterator, typename ValueType>
class logic_parameter
    :public basic_logic_parameter
{
private:
    std::list<FuncIterator> _refedFuncs;
    ValueType _val;
public:

};

// all `function`'s base class
class basic_logic_function
{
public:
    virtual ~basic_logic_function() = 0;
};

// the function, has input/output variable
template <typename FuncIterator, typename R, typename... Args>
class logic_function_base
    :public basic_logic_function
{
private:
    std::shared_ptr<logic_parameter<FuncIterator, R>> _ret;
    std::tuple<std::shared_ptr<logic_parameter<FuncIterator, Args>>...> _args;
public:
    template <std::size_t N>
    decltype(auto) arg()
    {
        return std::get<N>(_args);
    }

    template <std::size_t N>
    struct arg_type
    {
        typedef std::tuple_element_t<N> type;
    };

    template <std::size_t N>
    using arg_type_t = arg_type<N>::type;

    decltype(auto) ret()
    {
        return _ret;
    }
};

我希望像这样使用：

// drawing need  color and a pen
    struct Color
    {
    };

    struct Pen
    {
    };

    struct Iter
    {
    };

    class Drawer
        :public logic_function_base<Iter, void(Color, Pen)>
    {
    public:
        void draw()
        {
            arg_type_t<0> pColor; // wrong
        }
    }

我的编译器无法通过此代码，为什么？我只想将模板参数包转换为std::tuple of std::shared_ptr of them. 例如：

鉴于struct A, int, struct C，我希望：

std::tuple<
  std::shared_ptr<logic_parameter<A>>,
  std::shared_ptr<logic_parameter<int>>,
  std::shared_ptr<logic_parameter<C>>,
>

Answer 1

问题（一旦小错误被修复¹）就是你实例化了：

logic_function_base<Iter, void(Color, Pen)>

...意味着FuncIterator为Iter且R为void(Color, Pen)，因此Args为emtpy <>，因此{{1是一个空的decltype(_args)，你的代码无法获得空元组的第0个元素的类型，这是合法的。

你想要的是std::tuple<>：

的部分特化

logic_function_base

¹当前代码中的小错误：

template <typename F, typename T>
class logic_function_base;


template <typename FuncIterator, typename R, typename... Args>
class logic_function_base<FuncIterator, R(Args...)>: public basic_logic_function {

};

Answer 2

这可能无法解答您的整个问题，但您可以使用以下特征来包装元组元素类型。

template <typename T> struct wrap;
template <typename... T>
struct wrap<std::tuple<T...>> {
  using type = std::tuple<std::shared_ptr<logic_parameter<T>>...>;
}
template <typename T>
using wrap_t = typename wrap<T>::type;

然后您可以像这样使用它：

std::tuple<int,double,char> t1;
wrap_t<decltype(t)> t2;

t2的类型为std::tuple<std::shared_ptr<logic_parameter<int>>,std::shared_ptr<logic_parameter<double>>,std::shared_ptr<logic_parameter<char>>>。

std :: tuple of std :: shared_ptr of template parameter pack

2 个答案: