Estou ciente de que a sintaxe para declarar um método de classe de modelo em um cabeçalho e defini-lo em um arquivo de origem é a seguinte:

myclass.h

template <typename T>
class MyClass {
  public:
    void method(T input);
  private:
    T privVar;
};

myclass.cpp

template <typename T>
void MyClass<T>::method(T input) {
    privVar = input;
}

Mas, e se o método também for um modelo? Eu estou adicionando métodos para obasic_string classe, e eu quero saber como escrever a implementação para as funções.

MyString.h

template <class _Elem   = TCHAR,
          class _Traits = std::char_traits<_Elem>,
          class _Ax     = std::allocator<_Elem>>
class String
    : public std::basic_string<_Elem, _Traits, _Ax> {
  private:
    // Types for the conversion operators.
    typedef       _Elem* _StrTy;
    typedef const _Elem* _ConstStrTy;

    //...

  public:
        // Conversion operators so 'String' can easily be
        // assigned to a C-String without calling 'c_str()'.
    operator _StrTy() const {
        return const_cast<_StrTy>(this->c_str());
    }

    operator _ConstStrTy() const {
        return this->c_str();
    }

    // ... Constructors ...

    /*------------ Additional Methods ------------*/

    //! Converts a value of the given type to a string.
    template <class _ValTy> static String ConvertFrom(_ValTy val);

    //! Converts a string to the given type.
    template <class _ValTy> static _ValTy ConvertTo(const String& str);
    template <class _ValTy> _ValTy ConvertTo(void) const;

    //! Checks if a string is empty or is whitespace.
    static bool IsNullOrSpace(const String& str);
    bool IsNullOrSpace(void) const;

    //! Converts a string to all upper-case.
    static String ToUpper(String str);
    void ToUpper(void);

    // ...
};

Como eu poderia implementartemplate <class _ValTy> static String ConvertFrom(_ValTy val);? Porque agora não só preciso especificar o modelo de classe, mas também o modelo de função. Estou apostando que o código que estou prestes a escrever não é válido, mas deve mostrar o que estou tentando realizar:

MyString.cpp

template <class _Elem, class _Traits, class _Ax>
template <class _ValTy>
String<_Elem, _Traits, _Ax> String<_Elem, _Traits, _Ax>::ConvertFrom(_ValTy val) {
    // Convert value to String and return it...
}

Eu não sou avançado em todos os modelos. Não só tenho muita dúvida de que o acima é válido, parece complicado escrever e não ser muito legível. Como eu iria sobre a implementação dos métodos de modelo e os métodos de modelo estático que retorna seu próprio tipo de classe? Porque eu não quero defini-los no cabeçalho.