Mir ist bekannt, dass die Syntax zum Deklarieren einer Template-Klassenmethode in einem Header und zum Definieren in einer Quelldatei wie folgt lautet:

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

Aber was ist, wenn die Methode auch eine Vorlage ist? Ich habe Methoden zum Hinzufügenbasic_string Klasse, und ich möchte wissen, wie man die Implementierung für die Funktionen schreibt.

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

    // ...
};

Wie könnte ich umsetzentemplate <class _ValTy> static String ConvertFrom(_ValTy val);? Denn jetzt muss nicht nur die Klassenvorlage, sondern auch die Funktionsvorlage angegeben werden. Ich wette, dass der Code, den ich schreiben möchte, nicht gültig ist, aber er sollte zeigen, was ich erreichen möchte:

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

Ich bin überhaupt nicht mit Vorlagen fortgeschritten. Ich bezweifle nicht nur, dass das oben Gesagte zutrifft, es scheint auch umständlich zu sein, zu schreiben und nicht sehr lesbar. Wie würde ich vorgehen, um die Template-Methoden und die statischen Template-Methoden zu implementieren, die einen eigenen Klassentyp zurückgeben? Weil ich sie nicht in der Kopfzeile definieren möchte.