Specialising a template to include template templates

Question

I am teaching myself template programming in C++, so some of my assumptions may be wrong - please correct me if you see any errors.

I am trying to use an STL list as a template parameter to a function. The function is supposed to be used with all sorts of data types, so I have defined the function as template<class T> rather than template<template<> class T> in its original declaration. I now want to specialise it to support a template class.

template<class T> 
void function(T param)
{
  // do something with T
}

template<template <class T, class Allocator> class listPlaceholder> 
void function(std::list<T, Allocator> param)
{
  // do something with every element in param (I actually need to know it's a list)
  std::list<T, Allocator>::iterator current = param.begin();
  std::list<T, Allocator>::iterator end = param.end();

  do {
    function<T>(*current);
  } while (++current != end);
}

The problem is that when I try to compile this code (under GCC) it says that T and Allocator are not defined in the scope. My primary question is "how do I specialise for template classes?" and secondly, if it is possible, "how do I extract the template template parameters?".

As mentioned previously, I am learning template programming, so obvious solutions are welcome.

score 3 · Accepted Answer · edited May 23 '17 at 12:04

You want to declare those parameters

template<template <class T, class Allocator> class listPlaceholder, 
         class T, class Allocator> 
void function(listPlaceholder<T, Allocator> param)
{
  // do something with every element in param (I actually need to know it's a list)
  typename listPlaceholder<T, Allocator>::iterator current = param.begin();
  typename listPlaceholder<T, Allocator>::iterator end = param.end();

  do {
    function<T>(*current);
  } while (++current != end);
}

The names you used in the formal parameter list have no meaning. You also forgot to use listPlaceholder actually. But I'm assuming that was accidental.

As another poster said, you also need the typename keyword because the names are dependent names.

For why the names in the formal list are meaningless, compare it to function pointers:

void f(void (*p)(int t, int allocator), int t, int allocator) {
  p(t, allocator);
}

void g(int a, int b) { 
}

int main() {
  f(&g, 0, 1);
}

What is important is only the type of the parameters, and I could have written void(*p)(int, int) too. In your case, what is important is only that both parameters are type parameters. So you could have written the template template parameter also as template<class, class> class listPlaceholder too, completely equivalent.

Last but not least, I would like to emphasize that you have not specialized function, but you have overloaded it with another template. So, both functions are two completely different function templates.

I used `listPlaceholder` and `std::list` in order to specialise for `std::list`s while keeping any specialisations for other two parameter template classes open (for example I am also using `std::pair`). As I mentioned to the other commenter, would the additional template parameters mean that you could not use this modified function with the original function. — fuseinabowl, Jul 24 '11 at 19:18
@fuseinabowl, ah I see. Well, as you are not specializing, you don't need to "keep it open" for any more specializations. You couldn't specialize a function template for a parameterized `std::list` anyway, because that requires partial specializations, which can't be done for function templates. You can just stick `std::list` in there, and later add more overloads for other types. The compiler will in a call pick the most specialized template (i.e that closest matches the argument). — Johannes Schaub - litb, Jul 24 '11 at 19:20
I tried that first - I couldn't work out exactly how to code that in. Can you give me a code sample of a template function declaration please? — fuseinabowl, Jul 24 '11 at 19:22
I managed to get it working, thanks to both you and @templatetypedef. Thanks a lot, very well explained. — fuseinabowl, Jul 25 '11 at 08:03

score 2 · Answer 2 · answered Jul 24 '11 at 18:48

g++ is actually correct here; you haven't declared T or Allocator in this scope. The template declaration you have

template<template <class T, class Allocator> class listPlaceholder> 
    void function(std::list<T, Allocator> param)

Says "I am parameterized over a class template that takes in two classes as arguments." However, the names of those arguments can't be accessed anywhere in the body of the template. They're mostly there as placeholders, and the above template declaration is equivalent to

template<template <class, class> class listPlaceholder> 
    void function(std::list<T, Allocator> param)

This is similar to how if you were to declare a regular C++ function that took another function as an argument, you can't access the names of the parameters. For example, this is illegal:

void DoSomething(void function(int x, int y)) {
    x = 5; // Error!
}

Since it's equivalent to

void DoSomething(void function(int, int)) {
    x = 5; // Error!
}

I believe what you want to do is change your template function signature to look like this:

template<class T, class Allocator> 
    void function(std::list<T, Allocator> param)

This says "This function is parameterized over two types. When provided as an argument a std::list parameterized over a type and an allocator, the body of this function can refer to those types as T and Allocator."

Thanks, this explains the problem well. Does this mean that I will have to re-declare the original function with no specialisation but with these extra template parameters, then specialise the 2 template function into the list? How would you go about achieving the same result with a 1 template class, without it being confused with the original function? — fuseinabowl, Jul 24 '11 at 19:03
If you wanted to have a generic "something other than list" function and a more specialized "only for lists" function, then you would write the first version as a template function that takes in some type `T` and the second function as above. C++ will always pick the more specialized function during overload resolution. — templatetypedef, Jul 24 '11 at 19:04

score 0 · Answer 3 · edited May 23 '17 at 11:47

0

Use typename as:

typename std::list<T, Allocator>::iterator current = param.begin();
typename std::list<T, Allocator>::iterator end = param.end();

Its because iterator is dependent name, so typename is required by the compiler, so that it can know that iterator is actually a type, not a static value.

To know this in detail, read this FAQ:

Where and why do I have to put the "template" and "typename" keywords?

Beside, you should be writing your function template as:

template <class T, class Allocator>
void function(std::list<T, Allocator> param)
{
   //code..
}

edited May 23 '17 at 11:47

Community

1
1

answered Jul 24 '11 at 18:45

Nawaz

327,095
105
629
812

This is true, but that's not what's causing the error that's reported in the OP's question. – templatetypedef Jul 24 '11 at 18:48

Specialising a template to include template templates

3 Answers3