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<int> > 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<int> > 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;
}

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).

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).

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...

à 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<int> >
puisque en interne, l'implémentation manipule un
std::vector<ISequence<int> >

qui est manipulé...
Et l'objet "interdit" que je manipule n'est utilisé qu'au travers d'une

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

à t'on le droit d'utiliser un object du type std::vector<IObject> où
IObject est une classe abstraite...

Non.

à 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> ?