Re: why dynamic_cast fail here?

From:

Rolf Magnus <ramagnus@t-online.de>

Newsgroups:

comp.lang.c++

Date:

Thu, 15 Mar 2007 13:39:15 +0100

Message-ID:

<etbepi$kps$01$2@news.t-online.com>

pietromas@gmail.com wrote:

On Mar 15, 12:12 pm, Rolf Magnus <ramag...@t-online.de> wrote:

pietro...@gmail.com wrote:

In the example below, why does the dynamic_cast fail (return NULL)?

Because a B is not a C.

It should be able to cast between sibling classes ...

No, it shouldn't. An instance of class B only provides the A interface
and the B interface. So why would you want to access it through the C
interface? What would you expect to happen if C had another member
function and you'd try to call that on your B?

#include <iostream>

class A
{
    public:
        virtual const int get() const = 0;
};

class B : public A
{
    public:
        virtual const int get() const { return 0; }
};

class C : public A
{
    public:
        virtual const int get() const { return 1; }
};

int main()
{
    A *a;

    a = new B();
    std::cout << a->get() << std::endl;

    a = dynamic_cast<C*>(a);
    if(a)
        std::cout << a->get() << std::endl;

    return 0;
}

Yes, I see how that could case problems. So does that mean that the
following is not true (http://www.acm.org/crossroads/xrds3-1/
ovp3-1.html):

"The dynamic_cast Operator

The dynamic_cast operator takes the form

dynamic_cast<T> (expr)

and can be used only for pointer or reference types to navigate a
class hierarchy. The dynamic_cast operator can be used to cast from a
derived class pointer to a base class pointer, cast a derived class
pointer to another derived (sibling) class pointer, or cast a base
class pointer to a derived class pointer. Each of these conversions
may also be applied to references. In addition, any pointer may also
be cast to a void*."

Or else, what are the conditions for casting between sibling classes?

I think it means just that those are the cases where you may use a
dynamic_cast. It might fail (returning a null pointer or throwing an
exception), but you're allowed to use it.
And there is also multiple inheritance:

class Base
{
public:
    virtual ~Base() {}
};

class A : public Base
{
};

class B : public Base
{
};

class C: public A, public B
{
};

int main()
{
    A* a = new C;
    B* b = dynamic_cast<B*>(a); // shoulnd't fail
    delete b;
}