Re: help with virtual function callback
* andrew_nuss@yahoo.com:
struct Heap {
bool released;
void Release ()
{
if (released) {
released = false;
DoRelease(); //??? not really a virtual call to subclass
}
}
virtual void DoRelease ()
{
... release blocks
}
virtual ~Heap ()
{
Release();
}
};
struct MyHeap : public Heap {
//??? do I really need this
virtual ~MyHeap () {}
virtual void DoRelease ()
{
... do stuff
Heap::DoRelease();
}
};
My problem is that the DoRelease method of MyHeap is never getting
called!
For some reason, the Release method of base class Heap only sees the
DoRelease of Heap and not the DoRelease of MyHeap. Do I have some
other bug or is it a misunderstanding of virtual methods in C++?
It's a misunderstanding. When ~Heap executes, the dynamic type of the
object is Heap, and the definition of DoRelease used is that used for a
Heap object. For a bit about the rationale (it avoids a lot of bugs
that aren't unusual in e.g. Java), see FAQ item 23.5 and following.
Although the design above is a bit suspect, so that's it's probably
/much/ better to change the design (so that an object at hand is always
guaranteed to be usable) rather than apply a technical fix, there are
simple technical fixes.
Since DoRelease includes "... do stuff" and forwards the actual release
work to the base class, presumably DoRelease needs access to
MyHeap-specific state. That state is not present in the Heap object
when ~Heap executes. Thus, for your particular case the most
appropriate fix is probably to store a pointer to a state object.
class Heap
{
private:
Heap( Heap const& );
Heap& operator=( Heap const& );
protected:
struct State
{
virtual ~IState() {}
virtual int data() const { return 42; } // Just an example.
};
typedef std::auto_ptr<State> StatePtr;
StatePtr myState;
Heap( StatePtr aState = StatePtr(0) ): myState( aState ) {}
virtual ~Heap () {}
public:
void Release ()
{
myState = StatePtr(0);
}
};
class MyHeap : public Heap
{
private:
MyHeap( MyHeap const& );
MyHeap& operator=( MyHeap const& );
protected:
struct RealState: State
{
virtual ~RealState()
{
//... do stuff
}
};
public:
MyHeap(): Heap( StatePtr( new RealState ) ) {}
};
[snip]
My second question is whether I need to redeclare the destructor
(empty) of
MyHeap as virtual or whether if undeclared, the compiler figures things
out
based on the virtualness of the destructor of Heap.
You can just leave it out if it does nothing, and then you get an
automatically generated one.
--
A: Because it messes up the order in which people normally read text.
Q: Why is it such a bad thing?
A: Top-posting.
Q: What is the most annoying thing on usenet and in e-mail?
[ See http://www.gotw.ca/resources/clcm.htm for info about ]
[ comp.lang.c++.moderated. First time posters: Do this! ]