Template Conundrum

Question

I have encountered a C++ template conundrum. I've tried to trim it down to the bare minimum, and now I'm not even sure if what I'm trying to do is possible. Take a look at the following code (in some .h file).

template<typename T>
class A
{
public:
    template<typename S>
    void f(S x);
};

class B1 { };

template<typename S>
class B2 { };

//This one works:
template<>
template<typename S>
void A<B1>::f(S x)
{
}    

//This one does not work:
template<>
template<typename S>
void A<B2<S>>::f(S x)
{
}

In my main function I have something like this:

//This one works:
A<B1> first;
first.f<int>(5);

//This one does not work:
A<B2<int>> second;
second.f<int>(5);

The error message I get because of the second part is

error C3860: template argument list following class
             template name must list parameters in the
             order used in template parameter list

error C3855: 'A<T>': template parameter 'T' is
             incompatible with the declaration

Any idea what the problem is?

Edit

To make the problem more concrete, here's my motivation. I want the function f above to have specializations for T=std::tuple<T1, T2>, T=std::tuple<T1, T2, T3>, and T=std::tuple<T1, T2, T3, T4>, where the types in the tuple are still unbound.

What are you trying to do with this? Maybe there is a better way. — Pubby, Mar 08 '13 at 19:47
Is this what you want? http://stacked-crooked.com/view?id=8b9365eab6441615b312ad76b0500bb7-18aa934a8d82d638dde2147aa94cac94 — Pubby, Mar 08 '13 at 19:53
@Pubby I have added a section at the end with the motivation. — Timothy Shields, Mar 08 '13 at 20:05
Re: your edit: That would be partial specialisation of a function template. Not possible. You could maybe emulate it by having the function delegate to a class template. Or how about plain overloads? — Angew is no longer proud of SO, Mar 08 '13 at 20:09
@TimothyShields just overload with `template void f(std::tuple);` then? — Pubby, Mar 08 '13 at 20:10

score 4 · Accepted Answer · answered Mar 08 '13 at 19:50

4

You are trying to partially specialize a member function template. That is not possible, I'm afraid...

answered Mar 08 '13 at 19:50

Paul Michalik

4,331
16
18

Daniel Frey · Answer 2 · 2013-03-09T01:40:28.670

Your code has two problems. First, the second specialization is illegal, because

template<> // parameters useable for the specialization of A you refer to
           // since it is a function, no partial specialization is allowed.
template<typename S> // parameters for the function's parameters
void A<B2<S>>          // S can not be used here!
             ::f(S x)  // only here
{
}

If I change that to

template<>
template<typename S>
void A<B2<int>>::f(S x)
{
}

it works and now the second problem is exposed:

second.f<B2<int>>(5);

This sets S to B2<int> and the function expect a parameter S x - but the integer 5 can not be converted to that type. Change it to:

B2<int> x;
second.f<B2<int>>(x);

and it works as well.

Note that this might not solve the problem you were trying to solve, it just explains what happens.

Thinking about your edit: I think the fact that you try to specialize for T=std::tuple<...> already points the direction: T is the template parameter of A and that is what you should specialize. Maybe something like:

template< typename T >
class F // used to implement f(), so you can specialize
        // just F/f() instead of the whole class A
{
  void f(T x) { /* default impl */ }
};

template< typename T1, typename T2 >
class F< std::tuple< T1, T2 > >
{
  void f(T1 x, T2 y) { /* special impl */ }
};

template< typename T >
class A : public F< T >
{
    // ...other stuff...
};

score 1 · Answer 3 · edited May 23 '17 at 12:21

1

If you want to pass another template to a template, you have to use template template parameters, so your A<> template would look like this:

template<typename T>
class A
{
public:
    template<template <typename> class H, typename S>
    void f(H<S> x);
};

Now you can pass a template to your template.

I don't think you can specialize on template template parameters if your original template didn't take such an parameter type.

edited May 23 '17 at 12:21

Community

1
1

answered Mar 08 '13 at 19:46

Tony The Lion

61,704
67
242
415

I'm looking into this now...will get back to you on whether it works for me. Looks promising. – Timothy Shields Mar 08 '13 at 19:52

Template Conundrum

Edit

3 Answers3