Virtual destructors

[Bv202]

Hi,

I understand that, when you delete a derived object, first the derived destructor, then the base destructor is called. But let's assume we have this:

class Base 
{
public:
Base(int var1, int var2);
virtual ~Base();

void DoSomething() = 0;

private:
std::string string1;
std::string string2;
};

class Derived : public Base
{
public:
Derived(int var1, int var2);
void DoSomething();

private:
float float1;
};

So there is a virtual destructor in the base class, but none in the derived class. Why would you do this and what will happen now?

Thank you!

[wmheric]

This is indeed the way it should be - the destructor declared virtual in the base class.

It is to ensure when a Base is to be destroyed, it is properly done - the destructor of Derived is called first, then the dtor of Base.
Now, since you haven't provided a dtor for Derived, the default dtor is called.

If you mark a method as virtual in the bass class, it's not necessary that you also mark it as virtual in the derived class (but I think it's a good idea to do so, it makes the code easier to understand).

[Bv202]

Hi,

Thank you for the answer. But what happens if I don't declare it virtual in the base class? Will it go wrong when destroying?

[wmheric]

Yes, you can try making your destructors display something. You would see that the dtor of the derived class is not called if you don't say virtual in the base.

I don't have much idea what's happening behind =\ maybe the memory isn't handled properly...

[Bv202]

Hi,

Thank you, I understand it.

But what about the constructors? Why don't you need to make these virtual?

[Bazzy]

Base constructors need to be called explicitly from derived classes constructors

[Bv202]

Hey,

Can you explain that a bit; I don't really understand what you mean with that.

Thanks

[Bazzy]

Here is an example:

class B
{
    protected:
        int i;

    public:
        B ( int i ) : i ( i ) {} // base constructor
};

class D : public B
{
     public:
        D ( int i ) : B ( i ) {} // derived constructor calling the base one

        D ( something ) // other derived constructor not calling the base constructor
        {
             //...
        }
};

[Bv202]

Hi,

Yes, I understand that. But what if we have a situation like in my first example:

class Base 
{
public:
Base(int var1, int var2);
virtual ~Base();

void DoSomething() = 0;

private:
std::string string1;
std::string string2;
};

class Derived : public Base
{
public:
Derived(int var1, int var2);
void DoSomething();

private:
float float1;
};

The constructor of both the base and derived class is the same now - why would you do this and what happens now?

EDIT:
Nevermind, I understand it again. Thank you for the explaination.

[kbw]

If a base class's destructor is virtual, the derived class destructor is made virtual whether the virtual keyword is used or not.