 |
C++Talk.NET
C++ language newsgroups
|
| View previous topic :: View next topic |
| Author |
Message |
Mathieu Peyréga
Guest
|
 Posted: Thu Apr 22, 2004 5:29 pm Post subject: STL et classe abstraites |
 |
|
Bonjour,
le code suivant qui permet de manipuler des classes template avec pour
paramètre une classe abstraite (via une référence bien sur) est-il à
votre avis conforme au standard C++
Cordialement,
Mathieu
#include <iostream>
#include <vector>
template <class T>
class ISequence
{
public:
typedef typename std::vector<T>::size_type size_type;
typedef typename std::vector<T>::reference reference;
typedef typename std::vector<T>::const_reference const_reference;
inline virtual ~ISequence(void) {}
virtual size_type Size(void) const = 0;
virtual void Clear(void) = 0;
virtual void Push_Back(const_reference value) = 0;
virtual const_reference operator[](size_type i) const = 0;
virtual reference operator[](size_type i) = 0;
}; // class ISequence<T>
template <class T>
class Sequence : public ISequence<T>
{
public:
typedef typename ISequence<T>::size_type size_type;
typedef typename ISequence<T>::reference reference;
typedef typename ISequence<T>::const_reference const_reference;
inline Sequence(void) {}
inline ~Sequence(void) {}
inline virtual size_type Size(void) const { return m_data.size(); }
inline virtual void Clear(void) { m_data.clear(); }
inline virtual void Push_Back(const_reference value)
{ m_data.push_back(value); }
inline virtual const_reference operator[](size_type i) const
{ return m_data[i]; }
inline virtual reference operator[](size_type i)
{ return m_data[i]; }
protected:
std::vector<T> m_data;
}; // class Sequence<T>
typedef ISequence< ISequence IPathSequence;
class PathSequence : public IPathSequence
{
public:
inline PathSequence(void) {}
inline ~PathSequence(void) {}
inline size_type Size(void) const { return m_data.Size(); }
inline void Clear(void) { m_data.Clear(); }
inline void Push_Back(const_reference value)
{
size_type i = m_data.Size(),
jmax = value.Size(),
j;
m_data.Push_Back(Sequence<int>());
for(j=0;j<jmax;++j)
{
m_data.Push_Back(value[j]);
}
}
inline virtual const_reference operator[](size_type i) const
{ return m_data[i]; }
inline virtual reference operator[](size_type i)
{ return m_data[i]; }
protected:
Sequence< Sequence m_data;
}; // class PathSequence
int main(int argc, char* argv)
{
ISequence<int> *ps1 = new Sequence<int>;
ISequence<int> *ps2 = new Sequence<int>;
ISequence<int> *ps3 = new Sequence<int>;
ISequence<int> & is1 = *ps1;
ISequence<int> & is2 = *ps2;
ISequence<int> & is3 = *ps3;
is1.Push_Back(1);
is2.Push_Back(2); is2.Push_Back(3);
is3.Push_Back(4); is3.Push_Back(5); is3.Push_Back(6);
IPathSequence *pIPathSeq = new PathSequence;
IPathSequence &IPathSeq = *pIPathSeq;
IPathSeq.Push_Back(is1);
IPathSeq.Push_Back(is2);
IPathSeq.Push_Back(is3);
std::cout << "IPathSeq contains " << IPathSeq.Size() << " elements" <<
std::endl;
return 0;
}
|
|
| Back to top |
|
 |
giova
Guest
|
| Posted: Mon Apr 26, 2004 2:54 pm Post subject: Re: STL et classe abstraites |
|
|
Vu d'avion ca me semble parfaitement conforme et meme tres propre, mais
j'avoue que tout ca est un peu nouveau pour moi, dpnc mon avis est a
prendre au conditionnel, au pire si tu utilise visual qui d'apres mon
formateur est le compilateur le plus a la norme, tu peux mettre le
niveau d'avertissement au max, ca pourrait te donner des indications.
En tout cas ton code colle parfaitement avec tout ce que j'ai pu voir
lors de ma formation, (exepté que tu utilise vector qui fait parti de la
STL et non du C++ traditionnel).
Mathieu Peyréga wrote:
| Quote: | Bonjour,
le code suivant qui permet de manipuler des classes template avec pour
paramètre une classe abstraite (via une référence bien sur) est-il à
votre avis conforme au standard C++
Cordialement,
Mathieu
#include <iostream
#include
template
class ISequence
{
public:
typedef typename std::vector
typedef typename std::vector<T>::reference reference;
typedef typename std::vector<T>::const_reference const_reference;
inline virtual ~ISequence(void) {}
virtual size_type Size(void) const = 0;
virtual void Clear(void) = 0;
virtual void Push_Back(const_reference value) = 0;
virtual const_reference operator[](size_type i) const = 0;
virtual reference operator[](size_type i) = 0;
}; // class ISequence<T
template
class Sequence : public ISequence
{
public:
typedef typename ISequence
typedef typename ISequence<T>::reference reference;
typedef typename ISequence<T>::const_reference const_reference;
inline Sequence(void) {}
inline ~Sequence(void) {}
inline virtual size_type Size(void) const { return m_data.size(); }
inline virtual void Clear(void) { m_data.clear(); }
inline virtual void Push_Back(const_reference value)
{ m_data.push_back(value); }
inline virtual const_reference operator[](size_type i) const
{ return m_data[i]; }
inline virtual reference operator[](size_type i)
{ return m_data[i]; }
protected:
std::vector<T> m_data;
}; // class Sequence<T
typedef ISequence< ISequence IPathSequence;
class PathSequence : public IPathSequence
{
public:
inline PathSequence(void) {}
inline ~PathSequence(void) {}
inline size_type Size(void) const { return m_data.Size(); }
inline void Clear(void) { m_data.Clear(); }
inline void Push_Back(const_reference value)
{
size_type i = m_data.Size(),
jmax = value.Size(),
j;
m_data.Push_Back(Sequence<int>());
for(j=0;j<jmax;++j)
{
m_data.Push_Back(value[j]);
}
}
inline virtual const_reference operator[](size_type i) const
{ return m_data[i]; }
inline virtual reference operator[](size_type i)
{ return m_data[i]; }
protected:
Sequence< Sequence m_data;
}; // class PathSequence
int main(int argc, char* argv)
{
ISequence<int> *ps1 = new Sequence<int>;
ISequence<int> *ps2 = new Sequence<int>;
ISequence<int> *ps3 = new Sequence<int>;
ISequence<int> & is1 = *ps1;
ISequence<int> & is2 = *ps2;
ISequence<int> & is3 = *ps3;
is1.Push_Back(1);
is2.Push_Back(2); is2.Push_Back(3);
is3.Push_Back(4); is3.Push_Back(5); is3.Push_Back(6);
IPathSequence *pIPathSeq = new PathSequence;
IPathSequence &IPathSeq = *pIPathSeq;
IPathSeq.Push_Back(is1);
IPathSeq.Push_Back(is2);
IPathSeq.Push_Back(is3);
std::cout << "IPathSeq contains " << IPathSeq.Size() << " elements"
std::endl;
return 0;
}
|
|
|
| Back to top |
|
|
Christophe de VIENNE
Guest
|
| Posted: Mon Apr 26, 2004 3:27 pm Post subject: Re: STL et classe abstraites |
|
|
giova wrote:
[snip]
| Quote: | au pire si tu utilise visual qui d'apres mon
formateur est le compilateur le plus a la norme, tu peux mettre le
niveau d'avertissement au max, ca pourrait te donner des indications.
|
Heu, de quelle version parlait-il ? Vous a-t-il parlé de Commeau ?
| Quote: |
En tout cas ton code colle parfaitement avec tout ce que j'ai pu voir
lors de ma formation, (exepté que tu utilise vector qui fait parti de la
STL et non du C++ traditionnel).
|
<vector> fait partie de la norme standard.
A+
Christophe
|
|
| Back to top |
|
|
Mathieu Peyréga
Guest
|
| Posted: Mon Apr 26, 2004 5:05 pm Post subject: Re: STL et classe abstraites |
|
|
| Quote: | Vu d'avion ca me semble parfaitement conforme et meme tres propre, mais
j'avoue que tout ca est un peu nouveau pour moi, dpnc mon avis est a
prendre au conditionnel, au pire si tu utilise visual qui d'apres mon
formateur est le compilateur le plus a la norme, tu peux mettre le
niveau d'avertissement au max, ca pourrait te donner des indications.
En tout cas ton code colle parfaitement avec tout ce que j'ai pu voir
lors de ma formation, (exepté que tu utilise vector qui fait parti de la
STL et non du C++ traditionnel).
|
Que visual soit le comilateur le plus à la norme m'étonne un peu...
A mon avis, gcc et en particulier sa toute dernière version 3.4.0 la
respecte beaucoup mieux...
Cela dit, mon propos était plus clairement :
à t'on le droit d'utiliser un object du type std::vector<IObject> où
IObject est une classe abstraite... Si je suis bien, c'est ce qui se
passe dans mon exemple quand je manipule un ISequence< ISequence
puisque en interne, l'implémentation manipule un
std::vector<ISequence
Hors, si j'ai bien compris ce que j'ai lu dans la norme, on ne peut
utiliser dans un conteneur STL que des objects qui respectent un certain
nombre de contrainte dont être "CopyConstructible" ce qui n'est
manifestement pas le cas lorsqu'on a une classe abstraite (à moins que
j'ai mal compris le tableau récapitulant les contraintes)
De plus, dans la norme, la signature de la méthode resize de
std::vector<T> est :
void resize(size_type new_size, value_type x = T());
et non pas ce qui est implémenté dans visual ou g++ :
void resize(size_type new_size, const value_type& x = T());
En passant sur le fait que l'implémentation gcc et visual me parait plus
"intelligente" que la norme dans le sens où elle évite un l'appel du
constructeur de recopie.
En gros, j'ai l'impression que mon code (qui compile et linke) ne
respecte pas la norme à cause de ce point mais j'aurais aimé avoir
d'autres avis.
Cordialement,
Mathieu
|
|
| Back to top |
|
|
Loïc Joly
Guest
|
| Posted: Mon Apr 26, 2004 6:42 pm Post subject: Re: STL et classe abstraites |
|
|
Mathieu Peyréga wrote:
| Quote: | Vu d'avion ca me semble parfaitement conforme et meme tres propre,
mais j'avoue que tout ca est un peu nouveau pour moi, dpnc mon avis
est a prendre au conditionnel, au pire si tu utilise visual qui
d'apres mon formateur est le compilateur le plus a la norme, tu peux
mettre le niveau d'avertissement au max, ca pourrait te donner des
indications.
En tout cas ton code colle parfaitement avec tout ce que j'ai pu voir
lors de ma formation, (exepté que tu utilise vector qui fait parti de
la STL et non du C++ traditionnel).
|
La STL fait partie du C++ à 100%. Maintenant, comme je ne sais pas la
signification du mot traditionnel (j'imagine qu'il doit vouloir dire
quelquechose de différent pour Gaby et pour James...  )
| Quote: |
Que visual soit le comilateur le plus à la norme m'étonne un peu...
A mon avis, gcc et en particulier sa toute dernière version 3.4.0 la
respecte beaucoup mieux...
|
Quelqu'un a vu des benchs récents ? Les derniers que j'ai vu
concernaient VC 6.0 et gcc 2.95.
| Quote: |
Cela dit, mon propos était plus clairement :
à t'on le droit d'utiliser un object du type std::vector<IObject> où
IObject est une classe abstraite...
|
Non.
--
Loïc
|
|
| Back to top |
|
|
Mathieu Peyréga
Guest
|
| Posted: Mon Apr 26, 2004 8:19 pm Post subject: Re: STL et classe abstraites |
|
|
| Quote: | à t'on le droit d'utiliser un object du type std::vector<IObject> où
IObject est une classe abstraite... Si je suis bien, c'est ce qui se
passe dans mon exemple quand je manipule un ISequence< ISequence
puisque en interne, l'implémentation manipule un
std::vector
|
Autant pour moi avec la surcharge, c'est bien le Sequence
| Quote: | qui est manipulé...
Et l'objet "interdit" que je manipule n'est utilisé qu'au travers d'une |
référence et du polymorphisme...
En fait, ce code compile si on utilise les STL livrées avec gcc ou
visual, mais pas avec la STLPort 4.6.2 pour laquel la signature de la
méthode resize est celle de la norme.
En effet, à ce moment là, le compilateur qui instancie le template
IPathSequence génère une erreur à cause de l'appel du constructeur par
défaut qui est bien évidement impossible pourune classe abstraite...
| Quote: | Hors, si j'ai bien compris ce que j'ai lu dans la norme, on ne peut
utiliser dans un conteneur STL que des objects qui respectent un certain
nombre de contrainte dont être "CopyConstructible" ce qui n'est
manifestement pas le cas lorsqu'on a une classe abstraite (à moins que
j'ai mal compris le tableau récapitulant les contraintes)
De plus, dans la norme, la signature de la méthode resize de
std::vector<T> est :
void resize(size_type new_size, value_type x = T());
et non pas ce qui est implémenté dans visual ou g++ :
void resize(size_type new_size, const value_type& x = T());
En passant sur le fait que l'implémentation gcc et visual me parait plus
"intelligente" que la norme dans le sens où elle évite un l'appel du
constructeur de recopie.
En gros, j'ai l'impression que mon code (qui compile et linke) ne
respecte pas la norme à cause de ce point mais j'aurais aimé avoir
d'autres avis.
Cordialement,
Mathieu
|
|
|
| Back to top |
|
|
Mathieu Peyréga
Guest
|
| Posted: Mon Apr 26, 2004 8:21 pm Post subject: Re: STL et classe abstraites |
|
|
| Quote: | à t'on le droit d'utiliser un object du type std::vector<IObject> où
IObject est une classe abstraite...
Non.
|
Au moins c'est clair (et logique vu l'implémentation)... En question
subsidiaire :
est-ce qu'on a le droit de manipuler un pointeur ou une référence sur un
std::vector<IObject> ?
|
|
| Back to top |
|
|
kanze@gabi-soft.fr
Guest
|
| Posted: Tue Apr 27, 2004 8:05 am Post subject: Re: STL et classe abstraites |
|
|
Mathieu Peyréga <peyrega (AT) no (DOT) spam.netcourrier.com> wrote
| Quote: | à t'on le droit d'utiliser un object du type std::vector<IObject> où
IObject est une classe abstraite...
Non.
Au moins c'est clair (et logique vu l'implémentation)...
|
Il ne s'agissent pas d'une histoire d'implémentation. Un
std::vector<IObject> doit contenir des éléments (objets) de type
IObject. Si IObject est abstrait, il ne peut pas y avoir d'objets de ce
type.
| Quote: | En question subsidiaire :
est-ce qu'on a le droit de manipuler un pointeur ou une référence sur
un std::vector<IObject> ?
|
Si IObject est abstrait, il ne peut pas y avoir de type
std::vector<IObject>. Donc, pas de pointeurs et pas de références vers
un type qui ne peut même pas exister.
--
James Kanze GABI Software mailto:kanze (AT) gabi-soft (DOT) fr
Conseils en informatique orientée objet/ http://www.gabi-soft.fr
Beratung in objektorientierter Datenverarbeitung
9 place Sémard, 78210 St.-Cyr-l'École, France, +33 (0)1 30 23 00 34
|
|
| Back to top |
|
|
|
|
You cannot post new topics in this forum
You cannot reply to topics in this forum
You cannot edit your posts in this forum
You cannot delete your posts in this forum
You cannot vote in polls in this forum
|
|
FAQ
Search
Memberlist
Usergroups
Register
Profile
Log in to check your private messages
Log in
