模板类与模板成员之间的类

Question

A class template like this

template <typename... T>
class Action {
private:        
    std::tuple<T...> m_args;
public:
    Action(T... args) : m_args(args...) {}
}

to a class with template member. The reason why doing this is want to make only one type of class, so that object with different args still belong to the same class for easy manipulation.

class Action {
private:       
    // this does not work, how to declare the tuple type so that It can hold any arguments list.
    template <typename... T>
    std::tuple<T...> m_args;
public:   
    template <typename... T>
    Action(T... args) : m_args(args...) {}
}

Answer 1

Put your mind in the perspective of the compiler. How would our trusty friend know how much storage is required for Action , if that size would be dependent upon what constructor was resolved? This is not possible.

template<typename... T>
Action(T... args) : m_args(args...) {}

// wait what???
Action(int someArg) : m_args(someArg) {}

Let's say the second constructor was valid, or we had two Action objects with different arguments passed into the constructor -- what should be sizeof(Action) ?

If you get stuck on an issue like this, think as the compiler: there was probably some person who had to give a good enough reason why it shouldn't be supported, simply because it only complicates the implementation and also has performance implications.

---

Since you mentioned using a pointer instead of an aggregated object, I figured I'd show you how to do this for completeness. Do note that this has performance implications, because you are now allocating the memory for m_args on the heap, rather than the stack.

class Action
{
public:
    template<typename... T>
    using TArgs = std::tuple<T...>;

    std::shared_ptr<void> m_args;

    template<typename... T>
    Action(T... args) 
        : m_args(std::make_shared<TArgs<T...>>(args...)) {}
};

Action myAction(1, 2.0, 3.5f);

auto *myActionArgs = 
    static_cast<Action::TArgs<int, double, float>*>(myAction.m_args.get());

// 2.0
double secondArg = std::get<1>(*myActionArgs);

This does not look like fun to maintain.