Re: Which casting conversion to use for void*?

From:

Kai-Uwe Bux <jkherciueh@gmx.net>

Newsgroups:

comp.lang.c++

Date:

Mon, 09 May 2011 23:46:04 +0200

Message-ID:

<iq9nat$oqs$1@hoshi.visyn.net>

?? Tiib wrote:

On May 10, 12:04 am, Joshua Maurice <joshuamaur...@gmail.com> wrote:

On May 9, 1:44 pm, ?? Tiib <oot...@hot.ee> wrote:

On May 9, 9:34 pm, Joshua Maurice <joshuamaur...@gmail.com> wrote:

In all cases, the C-style cast is equivalent to either a
static_cast or a reinterpret_cast, and as you have pointed out, it
can be quite "ambiguous", or hard to tell for a human reader, which
it is when working with class types.

Nitpick ... in all cases C-style cast is either a static_cast,
dynamic_cast, const_cast, reinterpret_cast or combination of such.

const_cast yes, but unless I'm losing my mind, C-style casts can never
be dynamic_casts. Can it? Example please? I was pretty sure no, but
now you're making me question that. Whipping through a couple of
examples, I'm pretty sure no still.

Not sure ... isn't it dynamic_cast like that:

struct OneInterface
{
     virtual void one() = 0;
};

struct OtherInterface
{
     virtual void other() = 0;
};

class X
     : public OneInterface
     , public OtherInterface
{
public:
     virtual void one() {}
     virtual void other() {}
};

int main()
{
     OneInterface* p = new X;
     p->one();
     // static_cast and reinterpret_cast both wrong:
     OtherInterface* p2 = (OtherInterface*)p;
     p2->other();
}

Assuming that the code compiles (did not check too hard), I think the line

OtherInterface* p2 = (OtherInterface*)p;

is seen by the compiler as a reinterpret_cast as per [5.9/7] and the line

p2->other();

is undefined behavior. In [5.4/5] and [5.4/7], you find a list of what the
cast notation can mean; and a dynamic_cast is not listed.

Best,

Kai-Uwe Bux