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