Using SFINAE to check for global operator<<?
I want to have several overloaded, global to_string()
functions that take some type T
and convert it to its string representation. For the general case, I want to be able to write:
template<typename T,class OutputStringType> inline
typename enable_if<!std::is_pointer<T>::value
&& has_insertion_operator<T>::value,
void>::type
to_string( T const &t, OutputStringType *out ) {
std::ostringstream o;
o << t;
*out = o.str();
}
My implementation of has_insertion_operator
so far is:
struct sfinae_base {
typedef char yes[1];
typedef char no[2];
};
template<typename T>
struct has_insertion_operator : sfinae_base {
template<typename U> static yes& test( U& );
template<typename U> static no& test(...);
static std::ostream &s;
static T const &t;
static bool const value = sizeof( test( s << t ) ) == sizeof( yes ); // line 48
};
(It borrows from this
and this.)
That seems to work.
But now I want to have an overloaded version of to_string
for types that do not have operator<<
but do have their own to_string()
member function, i.e.:
template<class T,class OutputStringType> inline
typename enable_if<!has_insertion_operator<T>::value
&& has_to_string<T,std::string (T::*)() const>::value,
void>::type
to_string( T const &t, OutputStringType *out ) {
*out = t.to_string();
}
The implementation of has_to_string
is:
#define DECL_HAS_MEM_FN(FN_NAME) \
template<typename T,typename S> \
struct has_##FN_NAME : sfinae_base { \
template<typename SignatureType,SignatureType> struct type_check; \
template<class U> static yes& test(type_check<S,&U::FN_NAME>*); \
template<class U> static no& test(...); \
static bool const value = sizeof( test<T>(0) ) == sizeof( yes ); \
}
DECL_HAS_MEM_FN( to_string );
(This part seems to work fine. It's adapted from this.) However, when I have:
struct S {
string to_string() const {
return "42";
}
};
int main() {
string buf;
S s;
to_string( s, &buf ); // line 104
}
I get:
foo.cpp: In instantiation of ‘const bool has_insertion_operator<S>::value’:
foo.cpp:104: instantiated from here
foo.cpp:48: error: no match for ‘operator<<’ in ‘has_insertion_operator<S>::s << has_insertion_operator<S>::t’
It seems like SFINAE is not happening. How do I write has_insertion_operator
correctly such that it determines whether a global operator<<
is available?
FYI: I'm using g++ 4.2.1 (that which ships as part of Xcode on Mac OS X). Also, I'd like the code to be only standard C++03 without 3rd-party libraries, e.g., Boost.
Thanks!
Solution 1:
I should have simply been more faithful to this answer. A working implementation is:
namespace has_insertion_operator_impl {
typedef char no;
typedef char yes[2];
struct any_t {
template<typename T> any_t( T const& );
};
no operator<<( std::ostream const&, any_t const& );
yes& test( std::ostream& );
no test( no );
template<typename T>
struct has_insertion_operator {
static std::ostream &s;
static T const &t;
static bool const value = sizeof( test(s << t) ) == sizeof( yes );
};
}
template<typename T>
struct has_insertion_operator :
has_insertion_operator_impl::has_insertion_operator<T> {
};
I believe that it does not actually rely on SFINAE.
Solution 2:
The initializer of value
on line 48 is not in a context where SFINAE works. Try moving the expression to the function declaration.
#include <iostream>
struct sfinae_base {
typedef char yes[1];
typedef char no[2];
};
template<typename T>
struct has_insertion_operator : sfinae_base {
// this may quietly fail:
template<typename U> static yes& test(
size_t (*n)[ sizeof( std::cout << * static_cast<U*>(0) ) ] );
// "..." provides fallback in case above fails
template<typename U> static no& test(...);
static bool const value = sizeof( test<T>( NULL ) ) == sizeof( yes );
};
However, I have to question the amount of sophistication that is going into this. I see non-orthogonal mechanisms that will grind against each other (to_string
vs. operator<<
) and I hear poor assumptions getting tossed around (for example that operator<<
is global vs a member, although the code as implemented looks OK in that regard).