用于类模板专业化的运算符重载

Question

I got stuck with a confusing problem here and i couldnt find any solution so far: The linker complains about a multiple definition of an overloaded non-member operator==. Imagine the following situation:

template <class T>
struct MyPtr
{
  T* val;
  ...
}

template <class T> bool operator==(MyPtr<T> const & lhs, MyPtr<T> const & rhs)
{ return *lhs.val == *rhs.val; }
template <class T> bool operator==(MyPtr<T> const & lhs, T* const & rhs)
{ return *lhs.val == *rhs;}

So far so good, everything works like a charme, but as i tried to specialize my class to react to a char* in specific way things get weird:

template <>
struct MyPtr<char>
{
  char* val;
  ...
}

//Now each of these functions result in a multiple definition error of the Linker, 
//and i dont get why:
//bool operator== (MyPtr<char> const& lhs, MyPtr<char> const& rhs)
//{ return strcmp(lhs.val,rhs.val) == 0;}

//template <> bool operator==<char> (MyPtr<char> const& lhs, MyPtr<char> const& rhs)
//{ return strcmp(lhs.val,rhs.val) == 0;}

So what am i doing wrong here? The ordering in my code is as it is written here. Moving these function definitions above the Class specialization result in the error:

Error : specialization of 'MyPtr<char>' after instantiation
Error : redefinition of 'class MyPtr<char>'

Please notice i have to use GCC 4.1.2 . I hope its not a compiler problem here... again...

Answer 1

A function definition should only appear in a header file if:

• It has been declared with the inline keyword, OR
• It is defined within a class definition, OR
• It involves at least one template parameter

(Those are among the cases where the multiple-identical-definitions version of ODR applies.)

So inline is not usually required with template functions. But an explicit specialization doesn't actually have any template parameters, so you should mark it inline if you want it in the header file.

Answer 2

Shouldn't this

template <> bool operator==<char> (MyPtr<char> const& lhs, MyPtr<char> const& rhs)
{ return strcmp(lhs.val,rhs.val) == 0;}

be

template <> bool operator==<char> (MyPtr<char> const& lhs, char* const& rhs)
{ return strcmp(lhs.val,rhs) == 0;}

?

Thanks to jogojapan for the corrections