template <typename T,
template <typename ELEM, typename ALLOC =
std::allocator<ELEM> > class CONT = std::deque>
class Stack : public CONT<T>
{
};
mais je n'y arrive pas. Il me dit que le nombre d'arguments est insuffisant
dans public CONT<T>. Je comprends parfaitement pourquoi il me dit ca mais je
n'arrive pas a le resoudre.
Cette action est irreversible, confirmez la suppression du commentaire ?
Signaler le commentaire
Veuillez sélectionner un problème
Nudité
Violence
Harcèlement
Fraude
Vente illégale
Discours haineux
Terrorisme
Autre
Michaël Monerau
Plotark wrote:
Bonjour,
J'essaye de faire marcher le code suivant:
template <typename T, template <typename ELEM, typename ALLOC > std::allocator<ELEM> > class CONT = std::deque> class Stack : public CONT<T> { }; mais je n'y arrive pas. Il me dit que le nombre d'arguments est insuffisant dans public CONT<T>. Je comprends parfaitement pourquoi il me dit ca mais je n'arrive pas a le resoudre.
Quelqu'un a t il une idee?
A première vue, j'écrirais plutôt :
template <typename ELEM, typename ALLOC = std::allocator<ELEM>, class CONT = std::deque<ELEM> > class Stack : public CONT<ELEM> { // ... };
Voilà :) Je ne sais pas si c'est exactement ce à quoi tu veux arriver (j'ai pensé que le T et ELEM étaient les mêmes, peut-être à tort... Sinon, modifie). -- <=- Michaël "Cortex" Monerau -=> "OK, We'll call it a draw" - Monthy Python
Plotark wrote:
Bonjour,
J'essaye de faire marcher le code suivant:
template <typename T,
template <typename ELEM, typename ALLOC > std::allocator<ELEM> > class CONT = std::deque>
class Stack : public CONT<T>
{
};
mais je n'y arrive pas. Il me dit que le nombre d'arguments est
insuffisant dans public CONT<T>. Je comprends parfaitement pourquoi
il me dit ca mais je n'arrive pas a le resoudre.
Quelqu'un a t il une idee?
A première vue, j'écrirais plutôt :
template <typename ELEM,
typename ALLOC = std::allocator<ELEM>,
class CONT = std::deque<ELEM> >
class Stack : public CONT<ELEM>
{
// ...
};
Voilà :) Je ne sais pas si c'est exactement ce à quoi tu veux arriver (j'ai
pensé que le T et ELEM étaient les mêmes, peut-être à tort... Sinon,
modifie).
--
<=- Michaël "Cortex" Monerau -=>
"OK, We'll call it a draw" - Monthy Python
template <typename T, template <typename ELEM, typename ALLOC > std::allocator<ELEM> > class CONT = std::deque> class Stack : public CONT<T> { }; mais je n'y arrive pas. Il me dit que le nombre d'arguments est insuffisant dans public CONT<T>. Je comprends parfaitement pourquoi il me dit ca mais je n'arrive pas a le resoudre.
Quelqu'un a t il une idee?
A première vue, j'écrirais plutôt :
template <typename ELEM, typename ALLOC = std::allocator<ELEM>, class CONT = std::deque<ELEM> > class Stack : public CONT<ELEM> { // ... };
Voilà :) Je ne sais pas si c'est exactement ce à quoi tu veux arriver (j'ai pensé que le T et ELEM étaient les mêmes, peut-être à tort... Sinon, modifie). -- <=- Michaël "Cortex" Monerau -=> "OK, We'll call it a draw" - Monthy Python
Vincent Lascaux
template <typename T, template <typename ELEM, typename ALLOC > std::allocator<ELEM> > class CONT = std::deque> class Stack : public CONT<T> { };
Quelle difference fais-tu avec le code suivant :
template <typename T, template <typename ELEM, typename ALLOC > class CONT std::deque> class Stack : public CONT< T, std::allocator<ELEM> > { };
Dans les deux cas, il me semble que l'utilisateur ne peut pas specifier l'allocateur qu'il veut utiliser pour le container. Personnellement j'ecrirais plutot ca :
template <typename T, template <typename ELEM, typename ALLOC > class CONT std::deque, template class ALLOC = std::allocator< T > > class Stack : public CONT< T, ALLOC > { };
-- Vincent
template <typename T,
template <typename ELEM, typename ALLOC > std::allocator<ELEM> > class CONT = std::deque>
class Stack : public CONT<T>
{
};
Quelle difference fais-tu avec le code suivant :
template <typename T,
template <typename ELEM, typename ALLOC > class CONT std::deque>
class Stack : public CONT< T, std::allocator<ELEM> >
{
};
Dans les deux cas, il me semble que l'utilisateur ne peut pas specifier
l'allocateur qu'il veut utiliser pour le container. Personnellement
j'ecrirais plutot ca :
template <typename T,
template <typename ELEM, typename ALLOC > class CONT std::deque,
template class ALLOC = std::allocator< T > >
class Stack : public CONT< T, ALLOC >
{
};
template <typename T, template <typename ELEM, typename ALLOC > std::allocator<ELEM> > class CONT = std::deque> class Stack : public CONT<T> { };
Quelle difference fais-tu avec le code suivant :
template <typename T, template <typename ELEM, typename ALLOC > class CONT std::deque> class Stack : public CONT< T, std::allocator<ELEM> > { };
Dans les deux cas, il me semble que l'utilisateur ne peut pas specifier l'allocateur qu'il veut utiliser pour le container. Personnellement j'ecrirais plutot ca :
template <typename T, template <typename ELEM, typename ALLOC > class CONT std::deque, template class ALLOC = std::allocator< T > > class Stack : public CONT< T, ALLOC > { };
-- Vincent
Michaël Monerau
Vincent Lascaux wrote:
Personnellement j'ecrirais plutot ca :
template <typename T, template <typename ELEM, typename ALLOC > class CONT = std::deque, template class ALLOC = std::allocator< T > > class Stack : public CONT< T, ALLOC > { };
deux mots-clé template imbriqués ? Je ne sais pas si c'est légal... -- <=- Michaël "Cortex" Monerau -=> "OK, We'll call it a draw" - Monthy Python
Vincent Lascaux wrote:
Personnellement j'ecrirais plutot ca :
template <typename T,
template <typename ELEM, typename ALLOC > class CONT
= std::deque,
template class ALLOC = std::allocator< T > >
class Stack : public CONT< T, ALLOC >
{
};
deux mots-clé template imbriqués ? Je ne sais pas si c'est légal...
--
<=- Michaël "Cortex" Monerau -=>
"OK, We'll call it a draw" - Monthy Python
