Soy consciente de que la sintaxis para declarar un método de clase de plantilla en un encabezado y definirlo en un archivo de origen es la siguiente:

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;
}

Pero, ¿y si el método es también una plantilla? Estoy agregando métodos a labasic_string clase, y quiero saber cómo escribir la implementación para las funciones.

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);

    // ...
};

¿Cómo podría implementar?template <class _ValTy> static String ConvertFrom(_ValTy val);? Porque ahora no solo necesito especificar la plantilla de clase, sino también la plantilla de función. Estoy apostando a que el código que estoy a punto de escribir no es válido, pero debería mostrar lo que estoy tratando de lograr:

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...
}

No soy avanzado en absoluto con las plantillas. No solo tengo muchas dudas de que lo anterior sea válido, parece engorroso escribir y no es muy legible. ¿Cómo haría para implementar los métodos de plantilla y los métodos de plantilla estática que devuelven su propio tipo de clase? Porque no quiero definirlos en el encabezado.