By using this site, you agree to our updated Privacy Policy and our Terms of Use. Manage your Cookies Settings.
458,166 Members | 1,533 Online
Bytes IT Community
+ Ask a Question
Need help? Post your question and get tips & solutions from a community of 458,166 IT Pros & Developers. It's quick & easy.

Does destructor of base template class need to be virtual?

P: n/a
Hello,

template<class Base>
class Derived : public Base
{
};

By using template, i understand the actual base type will be deduced
at compile time. Moreover, class Derived will consist only of
functions which inturn call functions of the base type. Also, i would
like to hear comments about this kind of design.

Thanks,
Balaji.
Jul 9 '08 #1
Share this Question
Share on Google+
2 Replies


P: n/a
Hi,

ka*******************@gmail.com schrieb:
template<class Base>
class Derived : public Base
{
};

By using template, i understand the actual base type will be deduced
at compile time.
true.

However, the question from your subject is not related to that at all.
The destructor of Base has to be virtual if and only if you delete
objects of some derived type through ponters of type Base*. This is the
same as for any other base class.
Moreover, class Derived will consist only of
functions which inturn call functions of the base type. Also, i would
like to hear comments about this kind of design.
It is difficult to deduce what you are going to do.

Patterns like this are somewhat uncommon, but they can be a good advise
in some cases. Mostly, you could also use a interface of Base, a pointer
or a reference to Base or even a member of type Base instead of this
inheritance. In some cases where performance counts, the above solution
is faster because it moves some logic from runtime to the compile time.
Also it might be a lot of work to expose the whole interface of Base
through Derived otherwise. In case it consists of public or protected
member variables this is impossible.
Marcel
Jul 9 '08 #2

P: n/a
On Jul 9, 2:44 am, Marcel Müller <news.5.ma...@spamgourmet.comwrote:
Hi,

kasthurirangan.bal...@gmail.com schrieb:
template<class Base>
class Derived : public Base
{
};
By using template, i understand the actual base type will be deduced
at compile time.

true.

However, the question from your subject is not related to that at all.
The destructor of Base has to be virtual if and only if you delete
objects of some derived type through ponters of type Base*. This is the
same as for any other base class.
Moreover, class Derived will consist only of
functions which inturn call functions of the base type. Also, i would
like to hear comments about this kind of design.

It is difficult to deduce what you are going to do.

Patterns like this are somewhat uncommon, but they can be a good advise
in some cases. Mostly, you could also use a interface of Base, a pointer
or a reference to Base or even a member of type Base instead of this
inheritance. In some cases where performance counts, the above solution
is faster because it moves some logic from runtime to the compile time.
Also it might be a lot of work to expose the whole interface of Base
through Derived otherwise. In case it consists of public or protected
member variables this is impossible.

Marcel
Thanks Alf & Marcel. I shall weigh all options(inheritance,
containment, non-template as well access thru public/protected/
private) and also refer c++ templates.
For further queries i shall open a new thread.

Thanks,
Balaji.
Jul 11 '08 #3

This discussion thread is closed

Replies have been disabled for this discussion.