c++ - Adding additional template arguments to a method of a class which is already templated when defining out-of-line

Question

template <typename T>
struct S {
    T myValue;

    S(T&);

    template <typename... Ts>
    S(Ts&&...);
};

Suppose I wanted to define methods out-of-line to be called like S(some, arguments, of, various, types), how would I define the methods? For S(T&), I just do

template <typename T>
S<T>::S(T&){ /* code */ }

, but If I try and do

template<typename T, typename... Ts>
S<T>::S(Ts&&...){ /* code */ }

then it gives me an error: 'too many template parameters in template redeclaration'. Removing , typename... Ts results in an error about Ts not being defined.

What is the correct syntax to write the body of a method outside of the class/struct when there are additional template arguments for the method?

question from:https://stackoverflow.com/questions/65935185/adding-additional-template-arguments-to-a-method-of-a-class-which-is-already-tem

Answer 1

Per cppreference,

If the enclosing class declaration is, in turn, a class template, when a member template is defined outside of the class body, it takes two sets of template parameters: one for the enclosing class, and another one for itself:

template<typename T1>
struct string {
    // member template function
    template<typename T2>
    int compare(const T2&);
    // constructors can be templates too
    template<typename T2>
    string(const std::basic_string<T2>& s) { /*...*/ }
};
// out of class definition of string<T1>::compare<T2> 
template<typename T1> // for the enclosing class template
template<typename T2> // for the member template
int string<T1>::compare(const T2& s) { /* ... */ }

So you would need to do

template<typename T>
template<typename... Ts>
S<T>::S(Ts&&...){ /* code */ }