Specializing a template method of a non-template class - works in MSVC, compilation error in GCC

Question

I have some code that boils down to this:

#include <type_traits>

struct CByteArray {};

struct CIODevice {
    template <typename T>
    CIODevice& operator<< (T value)
    {
        static_assert(std::is_pod<T>::value, "This method is only intended for POD types");
        return *this;
    }

    template <>
    CIODevice& operator<< (CByteArray data)
    {
        return *this;
    }

    template <typename T>
    CIODevice& operator>> (T& value)
    {
        static_assert(std::is_pod<T>::value, "This method is only intended for POD types");
        return *this;
    }
};

int main()
{
    CIODevice device;
    int i = 0;
    device << i;
    device >> i;
    return 0;
}

It compiles in MSVC, but in GCC I get this:

prog.cpp:13:12: error: explicit specialization in non-namespace scope ‘struct CIODevice’
  template <>
            ^
prog.cpp:20:11: error: too many template-parameter-lists
  CIODevice& operator>> (T& value)
           ^
prog.cpp: In function ‘int main()’:
prog.cpp:32:9: error: no match for ‘operator>>’ (operand types are ‘CIODevice’ and ‘int’)
  device >> i;
     ^

Live sample.

I don't get it, what's the mistake here?

Answer 1

C++ specification § 14.7.3 (excerpt);

1. An explicit specialization of any of the following: ...
   
   • member function template of a class or class template ...
2. An explicit specialization shall be declared in a namespace enclosing the specialized template.

Basically, it must be declared in the namespace scope (as GCC and Clang require).

struct CIODevice {
    template <typename T>
    CIODevice& operator<< (T value)
    {
        static_assert(std::is_pod<T>::value, "This method is only intended for POD types");
        return *this;
    }

    template <typename T>
    CIODevice& operator>> (T& value)
    {
        static_assert(std::is_pod<T>::value, "This method is only intended for POD types");
        return *this;
    }
};

template <>
CIODevice& CIODevice::operator<< (CByteArray data)
{
    return *this;
}

Sample code.

Answer 2

See also this.

Basically, MSVC is wrong and GCC is right, you can not do that.

Why don't you use overloading instead of specialization? Try:

template <typename T>
CIODevice& operator<< (T value)
{
    static_assert(std::is_pod<T>::value, "This method is only intended for POD types");
    return *this;
}

// template <> // <--- Remove this
CIODevice& operator<< (CByteArray data)
{
    return *this;
}