Template functions partial specialization

[Andrei Tarassov]

Hi!

I would like to know if it is possible to implement something like
this:

template <class X, class Y>
X void func(X, Y) { ... }

template <class X, class Y>
Y void func(X, Y) { ... }

The idea is that the compiler would choose the appropriate function
depending on the types of X and Y provided there exists some
compile-time criterium.

For example, given the concrete classes A and B (whereas B is derived
from A) I want to make sure that no matter in what order you provide
arguments to func(), the return value would be always A.

One of the solutions would be to put func() inside a template class and
use partial specialization, but that would not work if you deal with
overloading operators.

Are there any other options?

Thanks,
Andrei

[Jonathan Mcdougall]

Andrei Tarassov wrote:

Hi!

I would like to know if it is possible to implement something like
this:

template <class X, class Y>
X void func(X, Y) { ... }

template <class X, class Y>
Y void func(X, Y) { ... }
I don`t quite understand what this syntax could do.
The idea is that the compiler would choose the appropriate function
depending on the types of X and Y provided there exists some
compile-time criterium.

For example, given the concrete classes A and B (whereas B is derived
from A) I want to make sure that no matter in what order you provide
arguments to func(), the return value would be always A.

For this example in particular, you can have a look at Boost.TypeTrait s
to detect the relation between two classes.
Jonathan

[Andrei Tarassov]

The idea is to choose the return type of a template function depending
on the parameters to that function.

I am using boost.type_trai ts already, but what I need is something like
partial specialization for template functions, which is not allowed in
C++. But maybe there are some work-arounds?

[Jonathan Mcdougall]

Andrei Tarassov wrote:

The idea is to choose the return type of a template function depending
on the parameters to that function.

I am using boost.type_trai ts already, but what I need is something like
partial specialization for template functions, which is not allowed in
C++. But maybe there are some work-arounds?

Classes, of course. This should get you started:

# include <boost/type_traits.hpp >

class Base {};
class Derived : public Base {};
template <bool b, class A, class B>
struct get_base_second ;

template <class A, class B>
struct get_base_second <true, A, B>
{
typedef A type;
};

template <bool b, class A, class B>
struct get_base_first;

template <class A, class B>
struct get_base_first< true, A, B>
{
typedef A type;
};

template <class A, class B>
struct get_base_first< false, A, B>
{
typedef typename get_base_second <boost::is_base _of<B, A>::value, B,
A>::type type;
};

template <class A, class B>
struct get_base
{
typedef typename get_base_first< boost::is_base_ of<A, B>::value, A,
B>::type type;
};

template <class A, class B>
typename get_base<A, B>::type foo(A& a, B& b)
{
return b; // whatever
}

int main()
{
Base a;
Derived b;

const Base& aa = foo(a, b); // ok
const Derived& bb = foo(a, b); // error
}
Jonathan

[Andrei Tarassov]

That worked! Thanks!

[Jonathan Mcdougall]

Andrei Tarassov wrote:

That worked! Thanks!

It's a pleasure, but again, please quote the message you are answering
to (http://en.wikipedia.org/wiki/Top-posting#Inline_replies)
Jonathan