Re: [boost] Re: Re: is_base_and_derived question

From: Terje Slettebø (tslettebo_at_[hidden])
Date: 2003-01-29 00:20:02

>From: "Rani Sharoni" <rani_sharoni_at_[hidden]>

> "David Abrahams" <dave_at_[hidden]> wrote in message
> news:u3cndjmu6.fsf_at_boost-consulting.com...
> > "John Maddock" <jm_at_[hidden]> writes:
> > > Yes, a class is it's own superclass/subclass, but IMO not it's own
> > > base: so it is a bug in the implementation.
> >
> > I'd like to suggest changing the documentation to match the
> > implementation at this point.  I know of a few places where I have
> > relied on the current semantics, and I'm sure that's the case for
> > others as well.  I'm not set on this course, but I think it's worth
> > considering.
>
> Before changing the documentation please consider the following improved
> implemetation that overcomes ambiguity and access control issues of the
> current is_base_and_derived implemetation (I lately posted it to
c.l.c++.m)
> :
>
> template <typename B, typename D>
> struct is_base_and_derived
> {
> private:
>     typedef char (&yes)[1];
>     typedef char (&no) [2];
>
>     template<typename T>
>     static yes check(D const volatile &, T);
>     static no  check(B const volatile &, int);
>
>     struct C
>     {
>         operator B const volatile &() const;
>         operator D const volatile &();
>     };
>
>     static C getC();
> public:
>     static const bool result =
>         sizeof(check(getC(), 0)) == sizeof(yes);
> };
>
> Additional specializations needed (e.g. void and reference types)

Very nice, Rani. Very clever. :)

It's interesting that, according to your clc++m posting, the inspiration of
this came from Andrei Alexandrescu's article on Mojo, who also came up with
Loki's SuperSubclass trait. Dave Abrahams is also credited in the thread,
for contributing to the above technique.

As you show in the other posting with example use, the above version works
as overload resolution is done before access check, so it works also for
private base classes. Besides, in this case, it never gets to do an access
check, as the actual call is never done.

As I understand, the reason it works for multiple occurrences of the same
base class is that it's not asking for D's B subobject, but instead for a
conversion to _a_ B (any B).

Also, "static no check(B const volatile &,int)" works as an ambiguity
buster, in the case where B is not a base class of D.

Regards,

Terje