STL container as a template parameter [closed]

Answer 1

Another possibility is to make TContainer a variadic template:

#include <vector>

struct TObject {};
struct IUnknown {};

template<template<class...> class TContainer, class TObject>
class Foobar
{
public:
    explicit Foobar( TContainer<TObject*> & container ) : container_( container ){}
private:
    TContainer<TObject*> & container_;
};

int main() {
    std::vector<IUnknown*> v;
    Foobar<std::vector, IUnknown> bla( v );
    return 0;
}

Answer 2

There are three different kinds of template arguments: values, types, and templates:

template <int value_argument> class C { };
template <class type_argument> class D { };
template <template<classT> class template_argument> class E { };

When you use these templates you have to provide an argument of the correct kind:

C<3> c;
D<int> d;
E<C> e;

When you use the third form, a template template argument, the template passed as the argument must match the declaration of the template template argument. In my simple examples, the template E expects a template template argument that takes one type argument.

In the code in the question, the first argument in the declaration of Foobar is template <class> class TContainer. At the point where it's used, the template that's passed is std::vector:

Foobar<std::vector, IUnknown*> bla(v);

The problem is that the template template argument says that it should have one argument, but the template that's passed as the actual argument has two or more. Formally, std::vector is

template <class T, class Allocator = std::allocator<T>> class vector { ... };

In order to use std::vector> as the first argument toFoobar, the definition ofFoobar` needs to be changed so that the first argument takes two type arguments:

template <template<class, class> TContainer, class TObject> class Foobar { ... };

Answer 3

You may create a synonym of your vector type with typedef to simplify coding.

typedef vector<MyClass> List;

Then use List as a template parameter as an "ordinary" type.

template<class T, class K>
class Foobar {...}

Foobar<List> variable;

Answer 4

There are several things wrong with your code, here is a working example:

template<template<class, class> class TContainer, class TObject>
class Foobar
{
public:
    explicit Foobar( TContainer<TObject*, std::allocator<TObject*>> & container )
    :
    container_( container ){}

private:
    TContainer<TObject*, std::allocator<TObject*>> & container_;
};

int main()
{
    std::vector<IUnknown*> v;
    Foobar<std::vector, IUnknown> bla( v );
}

The main fault of your codes it that std::vector takes two template arguments. It looks like this template<class T, class Allocator = std::allocator<T>> class vector;. Also, Joachim Pileborg is right about the double pointer issue, IUnknown**. However, you could simplify your code with the following:

template<class TContainer>
class Foobar
{
public:
    explicit Foobar( TContainer & container )
    :
    container_( container ){}

private:
    TContainer & container_; // Be careful with reference members
};

int main()
{
    std::vector<IUnknown*> v;
    Foobar<std::vector<IUnknown*>> bla( v ); // C++11 decltype(v) could be used
}

Answer 5

To start with, you probably get some compiler errors, if so you should have added them to the question as right now we can only guess.

Secondly, I'm guessing that it's because of your template parameter:

Foobar<std::vector, IUnknown*> bla( v );
//                  ^^^^^^^^^

Here you tell the compiler that the template parameter is a pointer, but then you have the constructor:

Foobar( TContainer<TObject*> & container )
//                 ^^^^^^^^

In the constructor you declare container to be a TContainer with TObject* members, but since TObject already is a pointer you now have a pointer-to-pointer. If TObject equals IUnknown* then TObject* equals IUnknown**. You have the same problem when declaring the container_ member variable.

I recommend you drop the pointer-type when declaring bla:

Foobar<std::vector, IUnknown> bla( v );
//                  ^^^^^^^^