Is this valid ISO C++?

[Ioannis Vranos]

This compiles with MINGW GCC 3.4.2 but not with my other compilers. Is it valid ISO C++?
#include <vector>
template< template<class> class ContainerTemplate, class ValueType>
inline void test(const ValueType &val)
{
ContainerTemplate<ValueType> container(val);
}

int main()
{
using namespace std;

test<vector>(10);
}

--
Ioannis Vranos

http://www23.brinkster.com/noicys

[Victor Bazarov]

"Ioannis Vranos" <iv*@remove.this.grad.com> wrote...

This compiles with MINGW GCC 3.4.2 but not with my other compilers. Is it
valid ISO C++?
#include <vector>
template< template<class> class ContainerTemplate, class ValueType>
inline void test(const ValueType &val)
{
ContainerTemplate<ValueType> container(val);
}

int main()
{
using namespace std;

test<vector>(10);
}

No, this is not valid for a simple reason that std::vector is a template
that has more than one argument. Your 'ContainerTemplate' template
template argument has only one argument itself.

Until we have template typedefs you're probably out of luck. You could
try declaring your own template deriving form 'vector<T>', but you'd
have to duplicate all functionality.

V

[Ioannis Vranos]

Victor Bazarov wrote:

#include <vector>
template< template<class> class ContainerTemplate, class ValueType>
inline void test(const ValueType &val)
{
ContainerTemplate<ValueType> container(val);
}

int main()
{
using namespace std;

test<vector>(10);
}

No, this is not valid for a simple reason that std::vector is a template
that has more than one argument. Your 'ContainerTemplate' template
template argument has only one argument itself.

Until we have template typedefs you're probably out of luck. You could
try declaring your own template deriving form 'vector<T>', but you'd
have to duplicate all functionality.

What I am trying to do is passing a template class (not an instance) to a template
function, and create instances of it inside the function. Something like this:

template <class T>
class SomeContainer{};

template <template<class> class ContainerType>
inline void somefunc()
{
ContainerType<int> obj;
}
int main()
{
somefunc<SomeContainer>();
}

This compiles in all my compilers. What has it do with how many arguments vector takes?

--
Ioannis Vranos

http://www23.brinkster.com/noicys

[Pete Becker]

Ioannis Vranos wrote:

template <template<class> class ContainerType>
inline void somefunc()
{
ContainerType<int> obj;
}
[...]
This compiles in all my compilers. What has it do with how many
arguments vector takes?

The declaration of somefunc says that you'll pass it a template that
takes one argument. vector takes two. To use vector you'd have to
declare somefunc as template<template<class,class> class ContainerType> ...

Except that that doesn't necessarily work, either, because vector can,
hypothetically, take additional implementation-specific arguments.

--

Pete Becker
Dinkumware, Ltd. (http://www.dinkumware.com)

[Peter MacMillan]

Ioannis Vranos wrote:

This compiles in all my compilers. What has it do with how many
arguments vector takes?

I looked at the OP and I was wondering the same thing.

vector is defined as: template <class T, class Allocator = allocator>

So, in your function template (to accept vector) you'd have to have
something like:
//---
#include <memory> // for allocator
#include <vector>

template< template<class, class> class CT, class VT, class AT>
inline void test(const VT &val)
{
CT<VT, AT> container(val);
}

int main()
{
using namespace std;

typedef allocator<int> intalloc;
test<vector, int, intalloc>(10);

}
//---

weird stuff (that you can't ignore auto-template parameters)...
--
Peter MacMillan
e-mail/msn: pe***@writeopen.com
icq: 1-874-927

GCS/IT/L d-(-)>-pu s():(-) a- C+++(++++)>$ UL>$ P++ L+ E-(-) W++(+++)>$
N o w++>$ O !M- V PS PE Y+ t++ 5 X R* tv- b++(+) DI D+(++)>$ G e++ h r--
y(--)

[Peter MacMillan]

//---
#include <memory>
#include <vector>

template< template<class, class> class CT, class VT>
inline void test(const VT &val)
{
CT<VT, std::allocator<VT> > container(val);
}

int main()
{
using namespace std;
test<vector, int>(10);
}
//---

Sorry for the extra post. Was just bugged that I didn't need that extra
template parameter. ;0

--
Peter MacMillan
e-mail/msn: pe***@writeopen.com
icq: 1-874-927

GCS/IT/L d-(-)>-pu s():(-) a- C+++(++++)>$ UL>$ P++ L+ E-(-) W++(+++)>$
N o w++>$ O !M- V PS PE Y+ t++ 5 X R* tv- b++(+) DI D+(++)>$ G e++ h r--
y(--)

[Stefan Strasser]

Ioannis Vranos schrieb:

This compiles with MINGW GCC 3.4.2 but not with my other compilers. Is
it valid ISO C++?
#include <vector>
template< template<class> class ContainerTemplate, class ValueType>
inline void test(const ValueType &val)
{
ContainerTemplate<ValueType> container(val);
}

int main()
{
using namespace std;

test<vector>(10);
}

it has been reported earlier as bug to gcc,
see http://gcc.gnu.org/bugzilla/show_bug.cgi?id=9737

but it seems they don't want to fix it because it is likely to be valid
in std c++ in the future, DR 150 is mentioned in that context.