Re: If a class has a virtual destructor
On Aug 6, 4:37 am, anubhav.sax...@wipro.com wrote:
Hi,
I want to design a template function/class that can be used to find
out if a given type 'T' has
a) A virtual destructor
b) A virtual function <ret>Name(int param1, int param2) const;
For point b, specifically I am interested in finding out how to detect
the virtuality of the call.
As I understand, we cannot take the address of a destructor and hence
the usual approach of <ret>(T::*p) does not work.
Regards,
Anubhav.
You could do something like this to detect if your class has a vtbl,
which is fairly portable
template <class T>
struct ftester:T{
virtual ~ftester()=0;
};
template<class T>
struct has_vtble{
enum {value=sizeof(ftester<T>)==sizeof(T)};
};
But as other posters have pointed out, to detect that a specific
function was declared virtual is beyond what C++ can do via the type
system. However, by using a mix of compilers one can start coming
close.
For instance, I could compile code using gcc +Wall option, which will
warn me if I make a class that has virtual fucntions but no virtual
destructor. If I compile everything using gcc +Wall +Werror, then I
can be assured that any class that has a virtual function has a
virtual destructor.
MSVC has a unique way of implementing virtual inheritance.It wants to
place on vtble fot the functions, and another for the classes, while
most compilers use a single vtbl for both. For instance, say I had a
class like so:
struct B{};
struct D:virtual B{};
Then on most compilers (gcc for one), has_vtble<D>::value==true, but
on MSVC,the answer is false.
Now, by setting up a build that runs both compilers, I can ensure if I
detect that a class has a virtual function it always has a virtual
destructor.
So at least (1) is covered.
On the Sun compiler, they have these nasty warnings about hiding
names. I have not tried this, but this should generate a warning on
Sun WS6U2 if Ret Name(); is not virtual
struct Base{
int foo(){}
};
struct Base2{
virtual int foo(){}
};
template<class T> struct foochecker:T{
int foo(){}
};
foochecker<Base2> f;
f.foo();
foochecker<Base> f2;
f2.foo();//warning foochecker<Base>::foo hides Base::foo
There are likely more elegant ways to do this.
The moral of the story is that the more compilers you can set up in
your build, at high warning levels, the closer you can come to getting
what you need.
Lance
--
[ See http://www.gotw.ca/resources/clcm.htm for info about ]
[ comp.lang.c++.moderated. First time posters: Do this! ]