C++ Compiler picks wrong overload of output stream operator << - c++

Question

I have a very simple inline helper class called IpAddress, which has 2 overloads of operator << to either serialize an object to a set of custom binary streams (operator as template function) or to output it to a std::ostream (non-template operator function).
#include <cstdint>
#include <string>
#include <array>
#include <iostream>
#include <sstream>
typedef uint8_t byte;
class IpAddress: public std::array<byte,4>
{
// ...
template<class S>
inline friend S& operator<<(S& left, const IpAddress& right) {
left.setBytes(right.data(), 4);
return left;
}
inline friend std::ostream& operator<< (std::ostream& left, const IpAddress& right) {
// do stuff eligible for an ostream
return left;
}
inline operator std::string() {
std::stringstream stream;
stream << *this;
return stream.str();
}
}
As you can see, there is also an operator to convert the address to a string. Unfortunately, the << call inside is selecting the wrong operator<< (the template one), leading to a compiler error:
error: C2039: 'setBytes' : is not a member of 'std::basic_stringstream<char,std::char_traits<char>,std::allocator<char>>'
Why is the compiler (MSVC in this case) selecting the wrong overload with a non-working body? Why not the "more specialized" std::ostream operator? How do I change this behaviour? Thanks!

Answer 1

You don't post a complete, compilable example so I can't see the call site.
However, the problem is most likely because whatever you are streaming out to is not exactly an ostream. It's likely to be derived from an ostream. In which case, template T will be a better match.
EDIT:
Style comments aside (they are right and you would do well to listen), here is a fix:
#include <iostream>
#include <utility>
#include <cstdint>
#include <array>
#include <sstream>
template<class T> static constexpr bool IsAnOstream = std::is_base_of<std::decay_t<T>, std::ostream>::value;
using byte = std::uint8_t;
struct IpAddress: public std::array<byte,4>
{
// ...
template<class S, std::enable_if_t<not IsAnOstream<S>>* = nullptr>
friend S& operator<<(S& left, const IpAddress& right) {
left.setBytes(right.data(), 4);
return left;
}
friend std::ostream& operator<< (std::ostream& left, const IpAddress& right) {
// do stuff eligible for an ostream
return left;
}
/*
* this is a bad idea - it can lead to all kinds of confusion
*
inline operator std::string() {
std::stringstream stream;
stream << *this;
return stream.str();
}
*/
};
// this is better - it's less surprising.
std::string to_string(const IpAddress& r)
{
std::stringstream stream;
stream << *this;
return stream.str();
}
struct MyStream
{
void setBytes(const uint8_t* p, size_t len) {}
};
int main()
{
IpAddress a;
MyStream s;
std::cout << a;
s << a;
return 0;
}