template< template<class T> void(*)(int),  class T1 = vector<T> >
class Test2
{
   typename T1::iterator it;
};

> template< template<class T> void(*)(int),  class T1 = vector<T> >
> class Test2
> {
>    typename T1::iterator it;
> };
>

14.3.3 Template template arguments

1 A templateargument

for a template templateparameter

shall be the name of a class template, expressed as

idexpression.

Only primary class templates are considered when matching the template template argument

with the corresponding parameter; partial specializations are not considered even if their parameter lists

match that of the template template parameter.

template< template<class T> struct R,  class T1 = vector<T> >
class Test2
{
   typename T1::iterator it;
};

template< template<class T> class R,  class T1 = vector<T> >
class Test2
{
   typename T1::iterator it;
};

E>template< template<class T> struct R,  class T1 = vector<T> >
E>class Test2
E>{
E>   typename T1::iterator it;
E>};
E>

14.1/1

template-parameter:
type-parameter
parameter-declaration

type-parameter:
class identifieropt
class identifieropt = type-id
typename identifieropt
typename identifieropt = type-id
template < template-parameter-list > class identifieropt
template < template-parameter-list > class identifieropt = id-expression

> E>template< template<class T> class R,  class T1 = vector<[b]T[b]> >
> E>class Test2
> E>{
> E>   typename T1::iterator it;
> E>};
> E>

template< template<class T> struct R,  class T1 = vector<T> >

template< template<typename> class R,  class T1 = vector<[b]???[b]> >
class Test2
{
   typename T1::iterator it;
};

NB>была такая мысль

template <typename T,
            template <typename ELEM,
                typename ALLOC = std::allocator<ELEM> >
                class CONT =std::deque>
class Stack
{
private:
    CONT<T> elems;
};

int main( int argc, char ** argv )
{
  Stack <int, std::vector> vStack;
  Stack <int> intStack;

}

R>template< template<class T> struct R,  class T1 = vector<T> >
R>

R>template< template<typename> class R,  class T1 = vector<[b]???[b]> >
R>class Test2
R>{
R>   typename T1::iterator it;
R>};
R>

template<class T, void(*)(T) >
class Test2
{
};

void ttt(int)
{
}
int main( int argc, char ** argv )
{
  Test2<int , ttt> t;
  /*Test2<double , ttt> t;*/ //ошибка
  return 0;
}

> R>template< template<typename> class R,  class T1 = vector<[b]???[b]> >
> R>class Test2
> R>{
> R>   typename T1::iterator it;
> R>};
> R>

> а если так?

> 
> template<class T, void(*)(T) >
> class Test2
> {
> };
> 
>

template<typename T, template<typename, typename> class BasicContainer = std::vector>
class Container : BasicContainer<T, std::allocator<T> >
{
};
int main()
{
    Container<int>                             int_vector;
    Container<std::string, std::list>      names_list;
    Container<float, std::deque>        float_deque;
}

NB>>>>была такая мысль

E>>>Он то компилится если объект не создавать

NB>>я тебя не понимаю, какой объект

E>>>template< template<class T> class R,  class T1 = vector<T> > 
class Test {
   typedef T1 type;
};

template<class T> Second {};
Test<Second> x; // какой тип имеет Test::type

template< template<class T, class S=T /*можно*/> class R,  class T1 = vector<T /*нельзя*/> >

template< template<class T> class R,  class T1 = R<int> >

>> какой объект