Re: Returning iterator from template class
Jack Saalweachter wrote:
dan2online wrote:
If you want to extend the vector, inheritance is better than
composition in your case.
Eehhhhh.
It's 'riskily dangerous' to inherit from vector<T> (or any other
standard containers) because they don't have virtual destructors. No
virtual destructors mean that if you ever end up storing your
super_vector<T> as a vector<T>*, and then delete that pointer, /the
universe explodes/. Or near enough.
There are few 'never's in programming, but as a rule of thumb, I have to
stop and think real hard about extending a class with no virtual
destructor.
May I direct your attention to
std::unary_function
or
std::iterator
These classes are explicitly meant to be inherited from, yet they do not
have a virtual destructor.
In general, whether you need polymorphic pointers is very much dependent on
your field of programming -- I have almost no use for runtime polymorphism.
However, I do have a need to, e.g., distinguish ordinary containers from
vectors that support arithmetic operations:
template < typename T >
class math_vector : public std::vector< T > {
public:
math_vector ( void )
: std::vector< T > ()
{}
template < typename A >
math_vector ( A a )
: std::vector< T > ( a )
{}
template < typename A, typename B >
math_vector ( A a, B b )
: std::vector< T > ( a, b )
{}
template < typename A, typename B, typename C >
math_vector ( A a, B b, C c )
: std::vector< T > ( a, b, c )
{}
template < typename A, typename B, typename C, typename D >
math_vector ( A a, B b, C c, D d )
: std::vector< T > ( a, b, c, d )
{}
}; // math_vector<>
Now, you can implement vector arithmetic along the following lines:
template < typename T >
math_vector< T > operator+= ( math_vector< T > & u,
math_vector< T > const & v ) {
typename math_vector< T >::const_iterator v_iter = v.begin();
for ( typename math_vector< T >::iterator u_iter = u.begin();
u_iter != u.end();
++ u_iter, ++ v_iter ) {
*u_iter += *v_iter;
}
return( u );
}
and the overload does not extend to all vectors but only those that are
flagged as math_vectors in the program. Here, std::vector is used like a
policy class and its use is an implementation detail of math_vector.
It is true that you cannot use pointers to std::vector polymorphically.
Well, so just don't do that. However, to infer that inheritance should be
limited to classes with virtual destructors is an over-generalization: in
fact, policy based design uses inheritance quite extensively, yet most
policy classes have no virtual destructors.
Best
Kai-Uwe Bux