Re: has_foo revisited...
rune.sune@yahoo.com wrote:
Hello,
I'd like to have a foo function that handles primitives and classes in
a seamless way. Primitives are used directly and classes are handled by
theirs special foo member function. So it would look something like
this:
int main()
{
int x = 42;
F f;
G g;
foo(x); // Would print 42 to stdout directly
foo(f); // Would print to stdout using f's foo member
foo(g); // Would print to stdout using g's foo member
}
A function template and some added sugar would probably fix this
somehow...
Now, the first problem is that of deciding wether a class has a member
function foo or not. While googling around for a has_foo function I
found this nice post:
http://groups.google.com/group/comp.lang.c++.moderated/msg/410c7680a9b31411
This is a nice trick which uses SFINAE for its purpose. However, it is
too tricky for me to follow...
C++ Templates: The Complete Guide illustrates something similar but
doesn't help.
Slightly modified it reads:
template <typename T>
struct has_foo
{
typedef char One;
typedef struct { char tmp[2]; } Two;
typedef int (T::*PMF)() const;
template <PMF> struct wrapper;
template <typename U>
static One test(U*, wrapper<&U::foo>* = 0); // why these two params?
static Two test(...);
enum { value = (1 == sizeof(has_foo<T>::test((T*)0)))};
};
I do not understand why the static test member function that returns
One must take the two parameters U* and the wrapper-pointer which is
defaulted to 0!? For example, why is it not sufficient to only take one
parameter?:
template <typename U> static One test(wrapper<&U::foo>*);
Because if you do it this way you will have to cast 0 to
wrapper<&T::foo>* in the sizeof expression which will lead to a compile
error for types not having foo member function. But you don't want an
error, rather the first test function overload should be disabled for
classes not having the member function. Since the first test is a
function template substituting U with a type without foo member
function results in the second argument substitution failure, which is
not a compile time error, as it would be if you were to cast 0 to
wrapper<&T::foo>* directly. This is the purpose of the trick to avoid
the error.
Note that has_foo<> metafunction only works for user defined types
(UDT), you can not pass fundamental types (int's, pointers) to it. So
you need to use additional template machinery to meet your goal.
For your task you could exploit facilities provided by boost to avoid
writing boilerplate code yourself. It would look like this:
#include <iostream>
#include <boost/utility/enable_if.hpp>
#include <boost/type_traits/is_class.hpp>
template <typename T>
struct has_foo_impl
{
template <int(T::*)()const> struct wrapper;
template <typename U>
static char(&test(U*, wrapper<&U::foo>* = 0))[1];
static char(&test(...))[2];
enum { value = 1 == sizeof test((T*)0) };
};
// this makes has_foo_impl a boost style metafunction predicate
template<class T>
struct has_foo : boost::mpl::bool_<has_foo_impl<T>::value>
{};
// this is for classes with foo member functions
template<class T>
typename boost::enable_if<has_foo<T>, void>::type
foo_impl(T const& t)
{
std::cout << t.foo() << char(0xa);
}
// this is for classes without foo member functions
template<class T>
typename boost::disable_if<has_foo<T>, void>::type
foo_impl(T const& t)
{
std::cout << "a class with no foo() member function" << char(0xa);
}
// this is a dispatcher function for classes only
template<class T>
typename boost::enable_if<boost::is_class<T>, void>::type
foo(T const& t)
{
foo_impl(t);
}
// this is for fundamental types only (not classes)
template<class T>
typename boost::disable_if<boost::is_class<T>, void>::type
foo(T const& t)
{
std::cout << t << char(0xa);
}
struct F
{
int foo() const { return 42; }
};
struct G {};
int main(int ac, char** av)
{
foo(F());
foo(G());
foo(1);
}
P.S. sorry for char(0xa), my backslash key does not work to type
backslash-n.
[ See http://www.gotw.ca/resources/clcm.htm for info about ]
[ comp.lang.c++.moderated. First time posters: Do this! ]