templates & polymorphic classes

[verec]

One problem I've come accross in designing a specific version of auto_ptr
is that I have to disntiguish between "polymorphi c" arguments and "plain" ones,
because the template has to, internally, cast to void *.

Specifically,
template <typename T> void f(T * t) {
void * p = dynamic_cast<vo id *>(t) ;
}

will not compile if T isn't of a class that has somewhere at least
a virtual function. In particular, none of the STL containers do qualify
for T.

Yet, because of multiple inheritance, if I want to get down to the base
"most" class, the dynamic_cast<vo id*> is the way to go.

I could use reinterpret_cas t instead, and this would work for all T,
except that I'd lose the "cast to base" feature mentionned above.

I could also use a pair of templates, one for polymorphic types,
and one of "POD". But I'd rather not do that.

I'd be happy with a runtime query ... if I could devise one, that is.

typeid() seems to not be applicable in this context.

Ideally, if I could come up with

template <typename T>
bool is_polymorphic( T t) {
...
}

I would be filled with joy :-)

Any taker?
--
JFB

[Swampmonster]

And the size of T1 could be bigger then the size of T, even it T
is a polymorphic type, since the compiler might want to give T1 a
different address then the copy of T that T1 contains. The compiler
isn't required to do so, but I don't think that there is any rule
that forbids it either.

I don't understand the issue. The only vague hint that I can see
is if T is some MI composite, in which case an intermediate and
empty T0 deriving from T, and from which both T1 and T2 would
derive, could solve the issue?

--
JFB

Hm. Ok, I think I messed up my neural pathways there. Normally the
compiler should append T1's data to T. But isn't it possible that
the compiler is so very much stupid, that it wants to give T1 some
additional data? Just because he feels like doing so?
Anyway, the T1 and T2 (without T0) method should be fine, and it's
the very thing boost does. Only they append 256 bytes IIRC.