Template specialization + linking error

I keep getting a linking error for certain functions. Here's one:

Code:

Error	8	:StrTraits<char>::GetLength(char const *)" (?GetLength@?$StrTraits@D@Strings@@SAIPBD@Z) already defined in Help.obj	Help2.obj

It's a template specialization, so it should reside in two headers.
But as I include the header in two or more .cpp files, I get a linking error. Maybe someone can shed some light?
Definition is as follows:

Code:

	
Code:
	
 template<typename T> class StrTraits
	{
	public:
		typedef int (fnc_tprintf_s)(T* buffer, size_t sizeOfBuffer, const T* format, ...);
		typedef int (fnc_tvprintf_s)(T* buffer, size_t sizeOfBuffer, const T* format, va_list argptr);
		typedef int (fnc_tvcprintf)(const T* format, va_list argptr);
		typedef int (fnc_tcscmp)(const T* string1, const T* string2);
	
		static const T* UINT64_T_IDENTIFIER;
		static const T* INT64_T_IDENTIFIER;
		static const T* LONG_IDENTIFIER;
	
		static uint32_t GetLength(const T* strData);
		static fnc_tprintf_s* GetFormatFunction(const T*);
		static fnc_tvprintf_s* GetVFormatFunction(const T*);
		static fnc_tvcprintf* GetVFormatCountFunction(const T*);
		static fnc_tcscmp* GetCompareFunction(const T*);
	
		static T* Allocate(uint32_t nSize);
		static void Delete(T* pToDelete);
	};

	template<> uint32_t StrTraits<char>::GetLength(const char* strData) { return strlen(strData); }
	template<> uint32_t StrTraits<wchar_t>::GetLength(const wchar_t* strData) { return wcslen(strData); }
 

(Yes, I know it's the wrong way to do traits, but I'm going to change it later.)

Make GetLength() impl. inline - since it's in a header.
Or move it to a CPP.

gg

Even though it's a template? Or perhaps it simply doesn't apply to specializations?

It's the same as if you had put this in a header:

Code:

uint32_t GetLength(const wchar_t* strData) 
{ 
   return wcslen(strData);
}

Then 2 CPP's include it. Now you have 2 implementations.

I don't think there's an exception for static members of a template or a specialization.

gg

I know that it would generate an error if it was a non-template function, but apparently specializations are considered to be real functions if instantiated, thus subject to the same rules as all normal functions.
Because it doesn't apply to template functions (non-specialized, of course).
Anyway, inlining them compiles it fine.
So... you can actually put specializations in a source file. I guess it makes sense...

Full specializations indeed aren't templates. Why would they be? There's no uncertainty about them left.