Template function specialization/overloading

[gao_bolin]

I am facing the following scenario: I have a class 'A', that implements
some concept C -- but we know this, not because A inherits from a
virtual class 'C', but only because a trait tell us so:

class A {};

template <typename T>
struct Is_C
{
static const bool value = false;
};

template <>
struct Is_C<A>
{
static const bool value = true;
};
What I would like to do is, given an instance 'a' of A, call a function
'foo(a)' that would have specific code for class A -- and have default
code for other classes.

The following

template < typename T >
void foo(T t)
{
if (Is_C<T>::value )
{
/* ... */
}
else
{
/* ... */
}
}

would work, but then, it is not extensible to another trait 'Is_D'
unless I modify the function foo. Ideally I would have a function foo
for the general case (corresponding to the 'else') and as many
functions foo for all the different tests, but I am not sure how to do
that. I would like to use the boost::enable_i f, but if I use function
overloading, I need to have a disable_if in my 'general case' foo for
each 'specialized' foo:

// General case
template < typename T >
typename disable_if<Is_C <T> >::type // This has to be modified if
another foo is added
foo(T t)
{
/* ... */
}

// Specialization for concept C
template < typename T >
typename enable_if<Is_C< T> >::type
foo(T t)
{
/* ... */
}

I would really appreciate any suggestion for this problem.

Thanks

B.

[gao_bolin]

I am not sure what you mean. For the example I was mentioning, the
enable_if solution would be

// general case
template <typename T1, typename T2, typename T3 >
typename disable_if_c<
numeric_traits< T1>::is_special ized &&
numeric_traits< T2>::is_special ized &&
numeric_traits< T3>::is_special ized

::type foo(const T1 &x1, const T2 &x2, const T3 &x3)
{
/*...*/
}

// case when all types have numeric traits
template <typename T1, typename T2, typename T3 >
typename enable_if_c<
numeric_traits< T1>::is_special ized &&
numeric_traits< T2>::is_special ized &&
numeric_traits< T3>::is_special ized::type

foo(const T1 &x1, const T2 &x2, const T3 &x3)
{
/*...*/
}

What would be the equivalent with your technique? I can see that I
would need only one tag, for the case when all types have numeric
traits, but how would I avoid having a trait with three template
arguments, and having to specialize this trait for all 3-uples of types
with known numeric traits (and there are a lot of them) ? How could I
reuse numeric traits?

Bolin

[Shezan Baig]

ga*******@voila .fr wrote:

I am not sure what you mean. For the example I was mentioning, the
enable_if solution would be

// general case
template <typename T1, typename T2, typename T3 >
typename disable_if_c<
numeric_traits< T1>::is_special ized &&
numeric_traits< T2>::is_special ized &&
numeric_traits< T3>::is_special ized

::type

foo(const T1 &x1, const T2 &x2, const T3 &x3)
{
/*...*/
}

// case when all types have numeric traits
template <typename T1, typename T2, typename T3 >
typename enable_if_c<
numeric_traits< T1>::is_special ized &&
numeric_traits< T2>::is_special ized &&
numeric_traits< T3>::is_special ized

::type

foo(const T1 &x1, const T2 &x2, const T3 &x3)
{
/*...*/
}

What would be the equivalent with your technique? I can see that I
would need only one tag, for the case when all types have numeric
traits, but how would I avoid having a trait with three template
arguments, and having to specialize this trait for all 3-uples of types
with known numeric traits (and there are a lot of them) ? How could I
reuse numeric traits?

Bolin

Create a function like this:
template <typename T1, typename T2, typename T3>
void foo(const T1& x1, IsSpecializedTa g,
const T2& x2, IsSpecializedTa g,
const T3& x3, IsSpecializedTa g)
{
/* ... */
}

template <typename T1, typename T2, typename T3>
void foo(const T1& x1, const T2& x2, const T3& x3)
{
typedef typename Trait<T1>::Tag Tag1;
typedef typename Trait<T2>::Tag Tag2;
typedef typename Trait<T3>::Tag Tag3;

return foo(x1, Tag1(),
x2, Tag2(),
x3, Tag3());
}
Of course, you also have the flexibility to mix and match tags like
this:
template <typename T1, typename T2, typename T3>
void foo(const T1& x1, IsSpecializedTa g,
const T2& x2, IsSomethingElse Tag,
const T3& x3, IsYetSomethingE lseTag)
{
/* ... */
}
and 'foo' will "just work" as long as you have assigned an appropriate
tag for each of the possible types (via specialization) .

Hope this helps,
-shez-