Thread: stl container as template argument

Make it

Code:

template<typename ContainerT>
void foo(const ContainerT& c)

Now, typical containers expose public typedefs within that you can grab for the value type, etc.
I believe typename ContainerT::value_type should do the trick for replacing ValueT.

If you want that, then you will have to make an extra layer of redirection. There is a way to detect if there is a typedef of a specific type or not and depending on that fact, take an action.
You should make sure that your containers contain a value_type typedef to make it work with this function, too.

Unfortunately, standard containers take an undefined amount of template parameters, making this approach tricky. You might be able to pull it off using varadic templates, though.

Fundamentally the trouble stems from putting the ContainerT type into the equation in the first place. Move the iterators OUTSIDE this function, forcing the caller to pass the beginning and ending iterators explicitly instead of obtaining them within your template. Not only do you gain freedom from needing to know the container type, you gain the ability to support things that don't have begin() and end() functions, and things which aren't even classes at all (like bare pointers).

In fact I'd just chuck the whole thing and use std::for_each.

It's possible that you want a templated template type:

Code:

template<template <class> class ContainerT, class ValueT>

Yes that's valid syntax, I use essentially that in my policy based renderer.

As expected, this does not compile properly:

Code:

#include <vector>

template<template<typename> class ContainerT, typename ValueT>
void foo(const ContainerT<ValueT>& c)
{
  typedef ContainerT<ValueT> type;
  for (typename type::iterator it = c.begin(); it != c.end(); ++it)
  {
    // do some stuff
  }
}

int main() { std::vector<int> v; foo(v); }

(Btw, you forgot the red part.)

I was able to get it to compile with the following:

Code:

#include <vector>

template<template<typename, typename> class ContainerT, typename ValueT>
void foo(const ContainerT<ValueT, std::allocator<ValueT>>& c)
{
  typedef ContainerT<ValueT, std::allocator<ValueT>> type;
  for (auto it = c.begin(); it != c.end(); ++it)
  {
    // do some stuff
  }
}


int main() { std::vector<int> v; foo(v); }

But this just shows how unreliable this method is, and how it should not be used.