Re: Code getting Crashed( C++)
On Aug 8, 3:33 pm, "Stuart Golodetz"
<sgolod...@dNiOaSl.PpAiMpPeLxE.AcSoEm> wrote:
"James Kanze" <james.ka...@gmail.com> wrote in
messagenews:66251dc4-da69-401e-8601-ed735986a6f1@m73g2000hsh.googlegroups=
..com...
[...]
This is even useful, in some admittedly rare cases, e.g.:
SomeType
Derived::f()
{
// The base class imposes pre-conditions which can
// never be met in this derived class, so...
assert( 0, "pre-conditions not met" ) ;
abort() ;
}
From a purist perspective, should Derived really inherit from
the base class in question in this case?
It depends. It depends on the contract of the base class, and
on the implementation of the derived class. It's not
unreasonable to imagine functions in the base class that can
only be called in a specific sequence, or a function f() that
can only be called if g() has successfully been called first.
If the implementation of the derived class is such that such
conditions can never occur, then yes, it's reasonable. I don't
think that the case occurs very often, but it can occur.
Most of the time such cases occur, of course; they are the
result of a compromise: the base class declares all possibly
supported functionality in a single interfaces, rather than have a
hierarchy of interfaces: say SeekableInputSource which derives
from InputSource. But I don't think that this is always the
case (although I can't think of any really good examples off
hand).
(I realise that there can sometimes be occasions when
pragmatism is necessary - just wondering whether this is in
principle best avoided?) I remember reading somewhere (and it
makes sense to me) that an overridden function should have
preconditions which are no stronger than than those of the
base function it overrides (i.e. it accepts anything the base
function would), and postconditions which are no weaker than
those of the base function (i.e. it makes at least the same
guarantees that the base function does). If the overridden
function can't be made to accept something the base function
would, then should the inheritance relationship between the
containing classes really exist?
The overriding class can strengthen post-conditions and
invariants. What if the pre-condition involves a post-condition
or invariant which the overriding class has excluded? E.g. a
very artificial example:
class Base
{
public:
virtual int f() ; // post: return value >= 0 and < 100
virtual void g() ; // pre: f() has been called, and
// returned a value > 10
} ;
class Derived : public Base
{
public:
virtual int f() ; // post: return value >= 0 and < 10
virtual void g() ; // ???
} ;
I'm pretty sure I've encountered such cases once or twice (in
close to 20 years C++, so they aren't that common), although I
can't remember any details off hand.
--
James Kanze (GABI Software) email:james.kanze@gmail.com
Conseils en informatique orient=E9e objet/
Beratung in objektorientierter Datenverarbeitung
9 place S=E9mard, 78210 St.-Cyr-l'=C9cole, France, +33 (0)1 30 23 00 34