1 
#include<iostream>

struct I1
{ 
    virtual void nb1()=0;
    virtual ~I1(){}
};

struct I2
{ 
    virtual void nb2()=0;
    virtual void nb22()=0;
    virtual ~I2(){}
};

struct C12 : I1, I2
{
    virtual void nb1(){std::cout << "nb\n";}    
    virtual void nb2(){std::cout << "nb2\n";}    
    virtual void nb22(){std::cout << "nb22\n";}
};

int main()
{
    I2 * p2 = new C12; 
    I1 * p1 = reinterpret_cast<I1*>(p2);
    return 1;
}

Is there any contraindications to use a reinterpret_cast here ? Should I mandatory use dynamic_cast?

Is it ok ONLY if I1 and I2 are pure virtual ?

Improve this question
3
  • whats the point of reinterpret_cast here since both I1 and I2 are unrelated?even though reinterpret_cast is specifically for these conversions Commented Apr 16, 2013 at 12:12
  • @Koushik: Because that's the cast you need to convert pointers to unrelated types. Of course, it can go horribly wrong if you end up using a pointer to the wrong type, as you would here. Commented Apr 16, 2013 at 12:15
  • @MikeSeymour yes thats what i meant to ask. its of no use in this situation? i could convert a char to a function pointer with this cast rite?(obviously moronic:-)) Commented Apr 16, 2013 at 12:18

5 Answers 5

Reset to default
3

The reinterpret_cast is unsafe; you should always use dynamic_cast. It is irrelevant that I1 and I2 are pure virtual classes; as subobjects of C12 they have nonzero storage requirements. Indeed, in the following program:

int main() {
    I2 * p2 = new C12; 
    I1 * p1 = reinterpret_cast<I1*>(p2);
    std::cout << p2 << '\n';
    std::cout << p1 << '\n';
    std::cout << dynamic_cast<I1*>(p2) << '\n';
    p1->nb1();
}

the output is:

0x14de0c8
0x14de0c8
0x14de0c0   // !!!
nb2         // !!!

You may be thinking of the empty base optimization (1.8p5); but this does not apply to classes with virtual methods, which require a vptr.

Improve this answer
Sign up to request clarification or add additional context in comments.

2 Comments

Is it due to the vtable if p1 could access to nb1() even if its adress is wrong (0x14de0c8 instead of 0x14de0c0 )?
@Guillaume07 p1->nb1() is accessing an I2 vtable as if it was an I1 vtable; clearly, the vtable layouts are such that nb2 is the same location in the I2 vtable as nb1 is in the I1 vtable.
3

Is there any contraindications to use a reinterpret_cast here ?

Don't do that; it will give undefined behaviour.

Typically, the base sub-objects are stored at different locations within the complete object, so that cast will end up pointing to the wrong location. You might find that it "works" by accident with these empty base classes, since they might (or might not) end up at the same location; but you certainly can't rely on that behaviour.

Should I mandatory use dynamic_cast?

If you don't know the common derived type (C12) at compile time, then that's the only sensible option. Note that it requires polymorphic classes (which is the case here).

If you do know the common derived type, then you can convert via that using static_cast:

I1 * p1 = static_cast<C12*>(p2);

Note that the "upcast" from the derived class can be done implicitly; only the "downcast" from the base class needs an explicit cast.

Improve this answer

Comments

1

Since the compiler might reserve some bytes for each of the two subobjects of C12 even if they have no members or base classes, and since then the addresses of those two subobjects are distinct, this can lead to problems. The standard just says that the result of that cast is unspecified (§5.2.10,7).

Improve this answer

Comments

0

It's almost always bad idea to use reinterpret_cast.

Here you may do either dynamic_cast or double static_cast (via base class).

From ABI point of view your C12 is:

struct C12 {
    I1 parent1;
    I2 parent2;
};

C12 obj;

Now you've get pointer to inner obj.parent2, which is not obj.

Improve this answer

Comments

0

If you have an object x of type C12 and have three pointers pointing to it like in:

C12 x;
C12 *pA = &x;
I1  *pB = &x;
I2  *pC = &x;

then the pointers pA, pB and pC are not necessarily equal. So you can't just reinterpret_cast back and forth between pA, pB and pC. You can safely static_cast or dynamic_cast between pA and pB and between pA and pC. So to get an I1* from an I2* you need to cast your p2 first to C12*, then to I1*. Pick the line you like most:

I1 * p1 = static_cast<C12*>(p2);
I1 * p1 = dynamic_cast<C12*>(p2);
Improve this answer

5 Comments

I don't know what compiler you are using, but you don't need the intermediate step in VS2010.
@metalhead: You need to go via C12* if you are using a static_cast.
@CharlesBailey: The OP said nothing about static_cast and it is not needed for dynamic_cast or reinterpret_cast
@metalhead: But the reinterpret_cast is wrong and won't work (unless you get very lucky with your undefined behavior), so that only leaves the two possibilities in this answer.
@CharlesBailey: Fair enough, but for once VS's undefined behavior is as desired and it does work. I just tried it out, but you are right that it can't be counted upon.

Start asking to get answers

Find the answer to your question by asking.

Ask question

Explore related questions

See similar questions with these tags.