Thank you, all - the reason is now pretty clear to me. In the end, I
You may call a pure virtual function if it has a body, i.e. it should be
defined. For examplr
class Base
{
protected:
virtual ~Base() = 0;
private:
virtual void f() const = 0;
};
inline Base::~Base()
{
std::cout << "Inside Base::~Base()\n";
f();
}
inline void Base::f() const
{
std::cout << "Inside Base::f()\n";
}
class Derived: public Base
{
public:
virtual ~Derived()
{
std::cout << "Inside Derived::~Derived()\n";
f();
}
private:
virtual void f() const
{
std::cout << "Inside Derived::f()\n";
}
};
int _tmain(int argc, _TCHAR* argv[])
{
{
Derived d;
}
return 0;
}
In your case the linker does not have the definition of the function.
Vladimir Grigoriev
"Dan Mattsson" <danm-ng@stallstugan.se> wrote in message
news:ACF2D3CA-8F99-47A8-985F-3530ADE2FB8E@microsoft.com...
I've been searching for a solution (or, rather, the reason) for an issue
I've been having. Our software makes ample use of inheritance in all
kinds of manners but one thing struck me as odd.
There's an abstract base class (let's call it CEdsDocument, since it is
its name) that defines a few common functions and some abstract ones:
class CEdsDocument abstract : public CDocument
{
public:
CEdsDocument();
virtual ~CEdsDocument();
[cut for brevity et al.]
virtual afx_msg void OnStopExec() abstract;
}
CEdsDocument::~CEdsDocument()
{
OnStopExec();
[Bunch of other stuff]
}
The compiler (VC++ 9) accepts it but the linker won't since there is no
CEdsDocument::OnStopExec(). But, whenever the destructor is called, the
function will exist since it's pure virtual.
Then I saw Herb Sutters article at http://www.gotw.ca/gotw/031.htm and it
got me thinking. Providing a body for OnStopExec() doesn't help since
the abstract base class' version of the function gets called.
Is there a way to call a pure virtual function from the destructor of the
abstract class that declared it? Or is it Just Plain WrongT?