Does an ABC need an implementation for a pure virtual DTOR?

Hi,

my linker is trying to look that up. So the implementation of a DTOR of an ABC can't be omitted even if the DTOR is pure virtual. Is that correct or do I suffer from some other fault?

Thank you in advance!

Are you talking about Abstract Base Class? Then it should introduce an (empty) virtual destructor.

--
Mats

If you think about sequence of destructing any object of the derived class, you will undestand - why.

matsp:
Yes I mean abstract base class.

Hm strange, here is my code:

Code:

---

// Model.h
struct Model
{
        virtual ~Model() = 0;       
        virtual const std::vector<BlasVector> wireFrame(const BlasVector& heading) const = 0;
};



// ModelFlyer.h
class ModelFlyer : public Model
{
        std::vector<BlasVector> mWireFrame;
       
public:

        ModelFlyer();
        virtual ~ModelFlyer();       
        virtual const std::vector<BlasVector> wireFrame(const BlasVector& heading) const;
};


// ModelFlyer.cpp
#include "ModelFlyer.h"

ModelFlyer::ModelFlyer()
        :mWireFrame()
{...}

ModelFlyer::~ModelFlyer()
{}

const std::vector<BlasVector>
ModelFlyer::wireFrame(const BlasVector& heading) const
{...}

---

And here is my linker error:

Quote:

---

1>ModelFlyer.obj : error LNK2019: unresolved external symbol "public: virtual __thiscall Model::~Model(void)" (??1Model@@UAE@XZ) referenced in function "public: virtual __thiscall ModelFlyer::~ModelFlyer(void)" (??1ModelFlyer@@UAE@XZ)
1>C:\workspace-eclipse\jschlegel-dev\Win32\Debug\bin\entityDebugger.exe : fatal error LNK1120: 1 unresolved externals

---

If I define Model::~Model(){} inside a Model.cpp the linker is pleased.

Do you know what I'm doing wrong?


vart:
What will I understand? Why the definition is needed or why "an (empty) virtual destructor is introduced [automatically]"? The first one is understood, the second doesn't seem to happen.

The destructor must always be implemented, even if it's pure.

Code:

---

class foo
{
public:
  virtual ~foo() = 0;
};
inline foo::~foo() {}

---

Ok, question answered. Thank you all!

Quote:

---

Originally Posted by pheres

Hi,

my linker is trying to look that up. So the implementation of a DTOR of an ABC can't be omitted even if the DTOR is pure virtual. Is that correct or do I suffer from some other fault?

Thank you in advance!

---

The compiler will implement one anyway, even if you specify a pure virtual destructor. There's nothing bad about it.

Quote:

---

Originally Posted by brewbuck

The compiler will implement one anyway, even if you specify a pure virtual destructor. There's nothing bad about it.

---

Huh? No, if you declare a pure virtual destructor, automatic generation is suppressed for this class.

Quote:

---

Originally Posted by CornedBee

The destructor must always be implemented, even if it's pure.

Code:

---

class foo
{
public:
  virtual ~foo() = 0;
};
inline foo::~foo() {}

---

---

Is there a reason why is has to be implemented?

It's called - the base destructor is always implicitly called in the derived destructor. Therefore it has to be implemented. To have it pure, it must be explicitly declared. Therefore the compiler won't provide the implementation.
End result: you have to implement it yourself.

Quote:

---

Originally Posted by CornedBee

Huh? No, if you declare a pure virtual destructor, automatic generation is suppressed for this class.

---

Are you sure? If it is required to exist regardless, why would the compiler not implement one? Allowing you to forget to implement it seems kinda stupid.

Quote:

---

Are you sure? If it is required to exist regardless, why would the compiler not implement one? Allowing you to forget to implement it seems kinda stupid.

---

From the C++ Standard (2003) Section 12:

Quote:

---

The default constructor (12.1), copy constructor and copy assignment operator (12.8), and destructor (12.4) are special member functions. The implementation will implicitly declare these member functions for a class type when the program does not explicitly declare them, except as noted in 12.1.

---

I guess the idea is that if you declare the destructor and forget to implement it, something might be wrong, so instead of giving a default with an empty body, the compiler simply does nothing and lets the linker complain.

EDIT:
I noticed that what I quoted does not talk about definition, so here are some snippets from Section 12.4:

Quote:

---

An implicitly-declared destructor is implicitly defined when it is used to destroy an object of its class type (3.7).
...
At the point of definition of a virtual destructor (including an implicit definition

---

From what I see, the former line talks about when an implicitly-declared destructor is defined, but does not talk about when an explicitly declared destructor is defined... so the implication is that explicitly declared destructors are to be explicitly defined. A virtual destructor can be implicitly defined too, when it belongs to a derived class whose base class' destructor is virtual.