J'ai une classe Element :
template<class T>
class Element
{
...
}
Comment créer un std::vector d'Element ?
J'ai une classe Element :
template<class T>
class Element
{
...
}
Comment créer un std::vector d'Element ?
J'ai une classe Element :
template<class T>
class Element
{
...
}
Comment créer un std::vector d'Element ?
Hello,
J'ai une classe Element :
template<class T>
class Element
{
}
Comment créer un std::vector d'Element ?
J'ai essayé pas mal de variations autour de
std::vector< Element <class T> > tableau;
ou
std::vector< Element > tableau;
sans succès. [...]
Hello,
J'ai une classe Element :
template<class T>
class Element
{
}
Comment créer un std::vector d'Element ?
J'ai essayé pas mal de variations autour de
std::vector< Element <class T> > tableau;
ou
std::vector< Element > tableau;
sans succès. [...]
Hello,
J'ai une classe Element :
template<class T>
class Element
{
}
Comment créer un std::vector d'Element ?
J'ai essayé pas mal de variations autour de
std::vector< Element <class T> > tableau;
ou
std::vector< Element > tableau;
sans succès. [...]
btzaf wrote on 17/10/2007 17:17:Hello,
J'ai une classe Element :
template<class T>
class Element
{
}
Comment créer un std::vector d'Element ?
instancier, comme vous le faites, un variable donnée ("tableau") comme
vecteur d'élément paramétré est bien sur possible pour peu que vous
désignez la classe paramètre:
[...]
et je pense que votre intention est surement cette finalité (création
d'un vecteur d'instances paramétrés par une classe concrête) plutôt que
de créer une variable "vecteur d'instances paramétrables".
cette seconde intention serait inattendue pour une variable donnée et ne
se concevrait que pour créer un type paramétré (une classe template)
dérivé de vector gérant des Elements eux même paramétrés - ceci est hors
de mes très faible connaissance en template, peut être est-ce non
réalisable, peut-être est-ce seulement couteux en <>
btzaf wrote on 17/10/2007 17:17:
Hello,
J'ai une classe Element :
template<class T>
class Element
{
}
Comment créer un std::vector d'Element ?
instancier, comme vous le faites, un variable donnée ("tableau") comme
vecteur d'élément paramétré est bien sur possible pour peu que vous
désignez la classe paramètre:
[...]
et je pense que votre intention est surement cette finalité (création
d'un vecteur d'instances paramétrés par une classe concrête) plutôt que
de créer une variable "vecteur d'instances paramétrables".
cette seconde intention serait inattendue pour une variable donnée et ne
se concevrait que pour créer un type paramétré (une classe template)
dérivé de vector gérant des Elements eux même paramétrés - ceci est hors
de mes très faible connaissance en template, peut être est-ce non
réalisable, peut-être est-ce seulement couteux en <>
btzaf wrote on 17/10/2007 17:17:Hello,
J'ai une classe Element :
template<class T>
class Element
{
}
Comment créer un std::vector d'Element ?
instancier, comme vous le faites, un variable donnée ("tableau") comme
vecteur d'élément paramétré est bien sur possible pour peu que vous
désignez la classe paramètre:
[...]
et je pense que votre intention est surement cette finalité (création
d'un vecteur d'instances paramétrés par une classe concrête) plutôt que
de créer une variable "vecteur d'instances paramétrables".
cette seconde intention serait inattendue pour une variable donnée et ne
se concevrait que pour créer un type paramétré (une classe template)
dérivé de vector gérant des Elements eux même paramétrés - ceci est hors
de mes très faible connaissance en template, peut être est-ce non
réalisable, peut-être est-ce seulement couteux en <>
De fait, ce que je veux c'est permettre à une méthode d'une autre classe
(appelons-là Foo) de recevoir un vecteur d'Element :
template<class T>
Foo::bar(std::vector< Element <T> >& tableau)
ce qui me permettrait d'avoir des choses comme
Element<int> eint1, eint2;
std::vector<Element <int> > vec;
vec.push_back(eint1);
vec.push_back(eint2);
Foo foo;
foo.bar(vec);
Seulement ce code ne compile pas, le compilo me dit:
De fait, ce que je veux c'est permettre à une méthode d'une autre classe
(appelons-là Foo) de recevoir un vecteur d'Element :
template<class T>
Foo::bar(std::vector< Element <T> >& tableau)
ce qui me permettrait d'avoir des choses comme
Element<int> eint1, eint2;
std::vector<Element <int> > vec;
vec.push_back(eint1);
vec.push_back(eint2);
Foo foo;
foo.bar(vec);
Seulement ce code ne compile pas, le compilo me dit:
De fait, ce que je veux c'est permettre à une méthode d'une autre classe
(appelons-là Foo) de recevoir un vecteur d'Element :
template<class T>
Foo::bar(std::vector< Element <T> >& tableau)
ce qui me permettrait d'avoir des choses comme
Element<int> eint1, eint2;
std::vector<Element <int> > vec;
vec.push_back(eint1);
vec.push_back(eint2);
Foo foo;
foo.bar(vec);
Seulement ce code ne compile pas, le compilo me dit:
De fait, ce que je veux c'est permettre à une méthode d'une autre classe
(appelons-là Foo) de recevoir un vecteur d'Element :
template<class T>
Foo::bar(std::vector< Element <T> >& tableau)
ce qui me permettrait d'avoir des choses comme
Element<int> eint1, eint2;
std::vector<Element <int> > vec;
vec.push_back(eint1);
vec.push_back(eint2);
Foo foo;
foo.bar(vec);
Seulement ce code ne compile pas, le compilo me dit:
Pourtant, ca devrait. Quel compilateur/version ?
De fait, ce que je veux c'est permettre à une méthode d'une autre classe
(appelons-là Foo) de recevoir un vecteur d'Element :
template<class T>
Foo::bar(std::vector< Element <T> >& tableau)
ce qui me permettrait d'avoir des choses comme
Element<int> eint1, eint2;
std::vector<Element <int> > vec;
vec.push_back(eint1);
vec.push_back(eint2);
Foo foo;
foo.bar(vec);
Seulement ce code ne compile pas, le compilo me dit:
Pourtant, ca devrait. Quel compilateur/version ?
De fait, ce que je veux c'est permettre à une méthode d'une autre classe
(appelons-là Foo) de recevoir un vecteur d'Element :
template<class T>
Foo::bar(std::vector< Element <T> >& tableau)
ce qui me permettrait d'avoir des choses comme
Element<int> eint1, eint2;
std::vector<Element <int> > vec;
vec.push_back(eint1);
vec.push_back(eint2);
Foo foo;
foo.bar(vec);
Seulement ce code ne compile pas, le compilo me dit:
Pourtant, ca devrait. Quel compilateur/version ?
De fait, ce que je veux c'est permettre à une méthode d'une
autre classe (appelons-là Foo) de recevoir un vecteur
d'Element :
template<class T>
Foo::bar(std::vector< Element <T> >& tableau)
ce qui me permettrait d'avoir des choses comme
Element<int> eint1, eint2;
std::vector<Element <int> > vec;
vec.push_back(eint1);
vec.push_back(eint2);
Foo foo;
foo.bar(vec);
Seulement ce code ne compile pas,
le compilo me dit:
vec-template.cpp: In function ?int main()?:
vec-template.cpp:50: error: no matching function for call to
?Foo<Element<int> >::bar(std::vector<Element<int>,
std::allocator<Element<int> > >&)?
vec-template.cpp:31: note: candidates are:
Foo<T>::bar(std::vector<Element<T>, std::allocator<Element<T> > >&)
[with T = Element<int>]
vec-template.cpp:28: note: Foo<Element<int> >::bar(const
Foo<Element<int> >&)
De manière générale, ce que je me demande, donc, c'est s'il est pos sible
de pousser le mécanisme des templates de telle sorte que nous ayons des
classes templates dont les méthodes reçoivent elles-mêmes des insta nces
de classes templates et celà sans avoir à surcharger ces méthodes p our
chaque type possible de la classe template paramètre, soit pouvoir
écrire des définitions :
template<class T>
Foo::bar(std::vector< Element <T> >& vec)
plutôt que :
Foo::bar(std::vector< Element <int> >& vec) { ... }
Foo::bar(std::vector< Element <float> >& vec) { ... }
dont je me rends compte en l'écrivant qu'elles ne résoudraient
d'ailleurs pas mon problème car in-fine je voudrais récupérer 'vec'
dans une variable d'instance 'Foo::_vec' dont je ne vois pas de quel
type elle pourrait être sauf à écrire un truc de genre
std::vector< Element<T> > _vec;
:-/
De fait, ce que je veux c'est permettre à une méthode d'une
autre classe (appelons-là Foo) de recevoir un vecteur
d'Element :
template<class T>
Foo::bar(std::vector< Element <T> >& tableau)
ce qui me permettrait d'avoir des choses comme
Element<int> eint1, eint2;
std::vector<Element <int> > vec;
vec.push_back(eint1);
vec.push_back(eint2);
Foo foo;
foo.bar(vec);
Seulement ce code ne compile pas,
le compilo me dit:
vec-template.cpp: In function ?int main()?:
vec-template.cpp:50: error: no matching function for call to
?Foo<Element<int> >::bar(std::vector<Element<int>,
std::allocator<Element<int> > >&)?
vec-template.cpp:31: note: candidates are:
Foo<T>::bar(std::vector<Element<T>, std::allocator<Element<T> > >&)
[with T = Element<int>]
vec-template.cpp:28: note: Foo<Element<int> >::bar(const
Foo<Element<int> >&)
De manière générale, ce que je me demande, donc, c'est s'il est pos sible
de pousser le mécanisme des templates de telle sorte que nous ayons des
classes templates dont les méthodes reçoivent elles-mêmes des insta nces
de classes templates et celà sans avoir à surcharger ces méthodes p our
chaque type possible de la classe template paramètre, soit pouvoir
écrire des définitions :
template<class T>
Foo::bar(std::vector< Element <T> >& vec)
plutôt que :
Foo::bar(std::vector< Element <int> >& vec) { ... }
Foo::bar(std::vector< Element <float> >& vec) { ... }
dont je me rends compte en l'écrivant qu'elles ne résoudraient
d'ailleurs pas mon problème car in-fine je voudrais récupérer 'vec'
dans une variable d'instance 'Foo::_vec' dont je ne vois pas de quel
type elle pourrait être sauf à écrire un truc de genre
std::vector< Element<T> > _vec;
:-/
De fait, ce que je veux c'est permettre à une méthode d'une
autre classe (appelons-là Foo) de recevoir un vecteur
d'Element :
template<class T>
Foo::bar(std::vector< Element <T> >& tableau)
ce qui me permettrait d'avoir des choses comme
Element<int> eint1, eint2;
std::vector<Element <int> > vec;
vec.push_back(eint1);
vec.push_back(eint2);
Foo foo;
foo.bar(vec);
Seulement ce code ne compile pas,
le compilo me dit:
vec-template.cpp: In function ?int main()?:
vec-template.cpp:50: error: no matching function for call to
?Foo<Element<int> >::bar(std::vector<Element<int>,
std::allocator<Element<int> > >&)?
vec-template.cpp:31: note: candidates are:
Foo<T>::bar(std::vector<Element<T>, std::allocator<Element<T> > >&)
[with T = Element<int>]
vec-template.cpp:28: note: Foo<Element<int> >::bar(const
Foo<Element<int> >&)
De manière générale, ce que je me demande, donc, c'est s'il est pos sible
de pousser le mécanisme des templates de telle sorte que nous ayons des
classes templates dont les méthodes reçoivent elles-mêmes des insta nces
de classes templates et celà sans avoir à surcharger ces méthodes p our
chaque type possible de la classe template paramètre, soit pouvoir
écrire des définitions :
template<class T>
Foo::bar(std::vector< Element <T> >& vec)
plutôt que :
Foo::bar(std::vector< Element <int> >& vec) { ... }
Foo::bar(std::vector< Element <float> >& vec) { ... }
dont je me rends compte en l'écrivant qu'elles ne résoudraient
d'ailleurs pas mon problème car in-fine je voudrais récupérer 'vec'
dans une variable d'instance 'Foo::_vec' dont je ne vois pas de quel
type elle pourrait être sauf à écrire un truc de genre
std::vector< Element<T> > _vec;
:-/
template<class T>
class Foo
{
std::vector< Element<T> > _vec;
public:
void bar (std::vector< Element<T> >& vec) { _vec = vec; }
};
Foo<Element<int> > foo;
Foo<int> n'irait il pas mieux?
foo.bar(vec);
}
template<class T>
class Foo
{
std::vector< Element<T> > _vec;
public:
void bar (std::vector< Element<T> >& vec) { _vec = vec; }
};
Foo<Element<int> > foo;
Foo<int> n'irait il pas mieux?
foo.bar(vec);
}
template<class T>
class Foo
{
std::vector< Element<T> > _vec;
public:
void bar (std::vector< Element<T> >& vec) { _vec = vec; }
};
Foo<Element<int> > foo;
Foo<int> n'irait il pas mieux?
foo.bar(vec);
}
Supérficiellement, ces phrases ressemblent à l'anglais, mais
c'est un anglais trop complexe pour que je le comprenne (et mon
anglais, en général, n'est pas si mal que ça). Mais j'ai
La solution la plus simple, peut-être, c'est d'écrire quelque
chose du genre :
template< typename Container >
void
Foo::bar( Container& tableau ) { /* ... */ }
De tête, je ne vois pas de moyen à contraindre que Container
soit une instance de std::vector. Mais est-ce que c'est
important, du moment qu'il supporte toutes les opérations du
vector qui m'interesse ? D'ailleurs, il se peut bien qu'un tel
test n'est pas nécessaire. Si, par exemple, tu utilises
autrement des opérations sur Container::value_type qui ne sont
valides que sur un Element<T>.
Si c'est dans la fonction, c'est bien. Si c'est un membre de la
classe, c'est plus complexe. Tu peux le faire en introduisant
une indirection supplémentaire, mais selon les cas, c'est
peut-être plus intéressant de définir des conversions entre les
différents Element, et utiliser un type canonique (disons
Element< double >).
Supérficiellement, ces phrases ressemblent à l'anglais, mais
c'est un anglais trop complexe pour que je le comprenne (et mon
anglais, en général, n'est pas si mal que ça). Mais j'ai
La solution la plus simple, peut-être, c'est d'écrire quelque
chose du genre :
template< typename Container >
void
Foo::bar( Container& tableau ) { /* ... */ }
De tête, je ne vois pas de moyen à contraindre que Container
soit une instance de std::vector. Mais est-ce que c'est
important, du moment qu'il supporte toutes les opérations du
vector qui m'interesse ? D'ailleurs, il se peut bien qu'un tel
test n'est pas nécessaire. Si, par exemple, tu utilises
autrement des opérations sur Container::value_type qui ne sont
valides que sur un Element<T>.
Si c'est dans la fonction, c'est bien. Si c'est un membre de la
classe, c'est plus complexe. Tu peux le faire en introduisant
une indirection supplémentaire, mais selon les cas, c'est
peut-être plus intéressant de définir des conversions entre les
différents Element, et utiliser un type canonique (disons
Element< double >).
Supérficiellement, ces phrases ressemblent à l'anglais, mais
c'est un anglais trop complexe pour que je le comprenne (et mon
anglais, en général, n'est pas si mal que ça). Mais j'ai
La solution la plus simple, peut-être, c'est d'écrire quelque
chose du genre :
template< typename Container >
void
Foo::bar( Container& tableau ) { /* ... */ }
De tête, je ne vois pas de moyen à contraindre que Container
soit une instance de std::vector. Mais est-ce que c'est
important, du moment qu'il supporte toutes les opérations du
vector qui m'interesse ? D'ailleurs, il se peut bien qu'un tel
test n'est pas nécessaire. Si, par exemple, tu utilises
autrement des opérations sur Container::value_type qui ne sont
valides que sur un Element<T>.
Si c'est dans la fonction, c'est bien. Si c'est un membre de la
classe, c'est plus complexe. Tu peux le faire en introduisant
une indirection supplémentaire, mais selon les cas, c'est
peut-être plus intéressant de définir des conversions entre les
différents Element, et utiliser un type canonique (disons
Element< double >).
On Oct 18, 9:31 am, btzaf wrote:De fait, ce que je veux c'est permettre à une méthode d'une
autre classe (appelons-là Foo) de recevoir un vecteur
d'Element :
template<class T>
Foo::bar(std::vector< Element <T> >& tableau)
ce qui me permettrait d'avoir des choses comme
Element<int> eint1, eint2;
std::vector<Element <int> > vec;
vec.push_back(eint1);
vec.push_back(eint2);
Foo foo;
foo.bar(vec);
Seulement ce code ne compile pas,
Je crois que c'est une contexte « non-deduced ». J'ai beaucoup
de mal à comprendre l'anglais de la norme ici -- aussi, la
texte dans la proposition la plus récente diffère assez de celui
de la norme 1998 --, mais la norme dit :
On Oct 18, 9:31 am, btzaf <bt...@free.fr> wrote:
De fait, ce que je veux c'est permettre à une méthode d'une
autre classe (appelons-là Foo) de recevoir un vecteur
d'Element :
template<class T>
Foo::bar(std::vector< Element <T> >& tableau)
ce qui me permettrait d'avoir des choses comme
Element<int> eint1, eint2;
std::vector<Element <int> > vec;
vec.push_back(eint1);
vec.push_back(eint2);
Foo foo;
foo.bar(vec);
Seulement ce code ne compile pas,
Je crois que c'est une contexte « non-deduced ». J'ai beaucoup
de mal à comprendre l'anglais de la norme ici -- aussi, la
texte dans la proposition la plus récente diffère assez de celui
de la norme 1998 --, mais la norme dit :
On Oct 18, 9:31 am, btzaf wrote:De fait, ce que je veux c'est permettre à une méthode d'une
autre classe (appelons-là Foo) de recevoir un vecteur
d'Element :
template<class T>
Foo::bar(std::vector< Element <T> >& tableau)
ce qui me permettrait d'avoir des choses comme
Element<int> eint1, eint2;
std::vector<Element <int> > vec;
vec.push_back(eint1);
vec.push_back(eint2);
Foo foo;
foo.bar(vec);
Seulement ce code ne compile pas,
Je crois que c'est une contexte « non-deduced ». J'ai beaucoup
de mal à comprendre l'anglais de la norme ici -- aussi, la
texte dans la proposition la plus récente diffère assez de celui
de la norme 1998 --, mais la norme dit :
Je ne suis pas sur qu'il est necessaire d'aller si loin. Le code
d'origine compile, si on prend en compte la correction de Jean-Marc.
Je ne suis pas sur qu'il est necessaire d'aller si loin. Le code
d'origine compile, si on prend en compte la correction de Jean-Marc.
Je ne suis pas sur qu'il est necessaire d'aller si loin. Le code
d'origine compile, si on prend en compte la correction de Jean-Marc.