folgendes Problem. Ich habe ein Klassentemplate welches widerum funktionstemplates besitzt.

Nun habe ich eine Spezialisierung dieses KTs. Jetzt schreit jedoch der Compiler C2244 bei den Funktionstemplateimplementierungen.

Klassentemplate:

template < typename FILE >
	class FileDataHandler
	{
	private:
		FILE*	m_file;
	public:
		FileDataHandler(FILE* file) : m_file(file){}		
		template <typename T> bool write_value	(const T* source_value);
	};

	template <typename FILE> template < typename T >
	bool FileDataHandler<FILE>::write_value( const T* source_value )
	{
		return true;
	}

Spezialisiert:

template <>
	class FileDataHandler<MyFileType>
	{
	private:
		MyFileType*	m_file;	
	public:
		FileDataHandler(MyFileType* file) : m_file(file) {}
		template <typename T> bool write_value	(const T* source_value);
	};

	template <> template < typename T >
	bool FileDataHandler<MyFileType>::write_value( const T* source_value )//C2244??
	{
		return true;
	}

Der Compilerfehler ist folgender:

error C2244: 'FileDataHandler<MyFileType>::write_value': Keine Übereinstimmung für Funktionsdefinition mit vorhandener Deklaration gefunden
          Definition
          'bool FileDataHandler<MyFileType>::write_value(const T *)'
          Vorhandene Deklarationen
          'bool FileDataHandler<MyFileType>::write_value(const T *)'

Die definition ist gleich der vorhandenen und dann eben doch nicht (ist das vllt schon die Lösung?).

Ich vermute natürlich dass es an der Spezialisierung liegt, aber warum verstehe ich noch nicht ganz.
Was ist das genaue Problem und wie kann ich es lösen?

Vielen Dank für Hilfe
Gruß

template <> template < typename T >
    bool FileDataHandler<MyFileType>::write_value( const T* source_value )//C2244??
    {
        return true;
    }

->

template < typename T >
    bool FileDataHandler<MyFileType>::write_value( const T* source_value )//C2244??
    {
        return true;
    }

Ansonsten würde ich solche Methoden gleich inline schreiben, gibt keinen grossen Mehrwert, die Definition separat zur Deklaration zu halten. Bei so kleinen Methoden wird es sogar unübersichtlicher.

14.7.3/5 schrieb:

Members of an explicitly specialized class template are defined in the same manner as members of normal classes, and not using the template<> syntax.
The same is true when defining a member of an explicitly specialized member class. However, template<> is used in defining a member of an explicitly specialized member class template that is specialized as a class template.