Re: CArray
"Giovanni Dicanio" <giovanni.dicanio@invalid.it> wrote in message
news:%23dyzsS5HIHA.4808@TK2MSFTNGP05.phx.gbl...
"David Webber" <dave@musical-dot-demon-dot-co.uk> ha scritto nel messaggio
news:OGl8SfwHIHA.4684@TK2MSFTNGP06.phx.gbl...
But I'd prefer
class CMyArray1 :: std::vector< CString >
{
}
Dave: when inheriting from a class, for proper cleanup, should the base
class have a *virtual* destructor?
I believe it is only necessary if you're using polymorphism:
class D : public class B
{
}
B *pB = new D;
//////////////////
delete pB;
When you delete the bass class pointer, the virtual destructor of B is
needed to ensure proper destruction of the derived class D.
In the case of:
class CMyArray1 :: std::vector< CString >
there is nothing to encourage one to do this. I just regard it as
convenient to be able to use
CMyArray1 a;
a.push_back( .... );
and so on, without a chain of contained objects. In this case it even fits
the purist's criterion CMyArray1 *is* the array.
I am *not* tempted to do anything like
std::vector< CString > *pArray = new CMyArray1;
as there would be no point. [A large part of the point is to avoid clumsy
phrases like "std::vector< CString >" in the source code!]
I'm not a C++ guru language-lawyer, but, as a rule to avoid uncorrect
cleanups and uncorrect destructor calls through an inheritance chain, I
define the base class destructor as virtual (and there is also the "rule
of 3", i.e.: if one defines a virtual destructor, he needs also copy ctor
and operator=).
As I say, I write copy constructors and = operators for just about every
class I produce. It's statements like
B *pB = new D;
which set off alarms to check for a virtual destuctor (though often I use
one anyway, in case I'm tempted to do that later). In any event, I tend to
use polymorphism a lot less than general derivation and encapsulation. [I
do use multiple inheritance quite a lot, though less than I used to, and I
avoid doing it on MFC classes these days.]
So, I read the source of std::vector implementation in VC7.1, and it seems
to me (I may be wrong...) that the destructor is not virtual.
In this case, would inheriting from std::vector be unsafe?
I do it all over the place and it has never caused me problems.
I also export the derived classes from DLLs which tends to generate one or
two warnings unless one suppresses them. But the general wisdom is that
you *can* export these from DLLs (though vector may be unique among STL
containers in this respect).
Dave
--
David Webber
Author of 'Mozart the Music Processor'
http://www.mozart.co.uk
For discussion/support see
http://www.mozart.co.uk/mozartists/mailinglist.htm