C-Style upcast and downcast involving private inheritance

Question

Consider the following piece of code :-

class A {};

class B : private A {};

B* bPtr1 = new B;
// A* aPtr1 = bPtr1; // error
// A* aPtr2 = static_cast<A*>(bPtr1); // error
A* aPtr3 = (A*)bPtr1;
B* bPtr2 = (B*)aPtr3;

The C-style cast discards the private inheritance while both the implicit and static_cast fail (also dynamic_cast). Why ? If C-style casts are just bit-fiddling, how are C++ casts implemented i.e. how do they know the type of inheritance from memory footprint?

After bPtr1 is casted to aPtr3, i will have to use another C-style cast to downcast to B as again both static_cast and dynamic_cast fail. So, is bPtr2 guaranteed to be good?

Thanks in advance

Answer 1

The C-style cast effectively does a reinterpret_cast. Once you use reinterpret_cast, you're totally on your own; it's basically undefined behaviour, and (to answer your question) there are no guarantees. (But, according to 5.2.10.7, you can always safely reinterpret_cast back to the original type, as long as the type you converted to does not have stricter alignment requirements than the original type.)

In practice, it's especially dangerous to use reinterpret_cast (or anything other than dynamic_cast) when you have multiple inheritance involved.

Answer 2

The C++ casts are enforced by the compiler (not the linker). It's not that private inheritance causes a different class layout; it's that the compiler will forbid you from casting a pointer to a derived class to a pointer to its base class if the inheritance is not public, based on the declaration of the class.

Answer 3

If C-style casts are just bit-fiddling, how are C++ casts implemented i.e. how do they know the type of inheritance from memory footprint?

C-style casts in C++ mean more than meets the eye. They are technically the only way to ask the compiler to choose the right cast operator required for conversion. For the same reason, this is better than using reinterpret_cast. The latter is implementation defined.

It seems there is a lot of confusion around C-style casts. Remember, no tool is safe until you know how to use it. The same applies to the C-style cast. The point of having a C-style cast is to ask the compiler to choose the safest and most portable conversion for a given pair of types. This may trigger a change from static_cast to reinterpret_cast silently and introduce errors. The point is: you need to know what you are doing.

Answer 4

The existing answers are great, but one bit of information you may find helpful relates to this:

C-style casts are just bit-fiddling

If you use an old-style cast between two pointer types, the compiler usually wouldn't need to fiddle with any bits. You're telling the compiler that you want to treat a location of memory as if it contained some type (because you know that it effectively does), so the compiler does nothing at all at runtime to modify the contents of memory. Casting merely disables type safety at compile time.

Answer 5

Its been a few months but lets see if i can remember static_cast tries to do a conversion from right type to left (address of left side may not be the same as right side). Since it doesnt know if A* came from B* it fails.

With dynamic cast what i assume it checks the vtable on the right side (thus only class with virtual functions work) to see if its compatible with the left side. If not it returns null.

CStyle cast are basically reinterpret_cast. You have no safety and if you mess up you'll get bitten.

since your using CStyled/reinterpret nothing is guaranteed so bPtr2 is not guaranteed to be good although this code should compile and run properly since it doesnt look like you mess up or depend on anything compiler or platform specific.

If you want complete safety you can add a virtual function call getType or safeCast(). IIRC you may only need to do this once in every derived base (i could be wrong) and it only will add 32 or 64bits to your vtable and vtables are only stored once (then every obj has a pointer to its vtable). So. thats pretty much a non existent performance penalty and you cant implement a more efficient safety check in code so you should use it if you want one. You can then use dynamic cast to upcast an object.

Answer 6

EDIT: Following a comment by dribeas, I did some further research and it turns out that my main conclusion was incorrect. It turns out that the standard states in 5.4.7 that C-style casts can actually do more than any sequence of new-style casts can do -- specifically including casting from a pointer-to-derived to pointer-to-base even when the base class is inaccessible, which is precisely what happens here with private inheritance. (Why this should be allowed, and in particular why it should be allowed only for C-style casts, is utterly beyond me; but it's undeniably allowed.)

So dribeas is right, compilers are obliged to handle the OP's C-style pointer conversion correctly, even when B inherits from multiple base classes. My own testing with MSVC++8 and MinGW confirms his results in practice -- when B inherits from multiple base classes, the compiler will adjust pointers when converting a B* to an A* or vice versa so that the correct object or subobject is identified.

I stand by my assertion that you ought to derive B publicly from A if you ever intend to treat a B as an A, since using private inheritance instead necessitates using C-style casts.

The original (somewhat incorrect) answer appears below.

---

Ultimately, if you want to be able to treat a B as an A, you need to derive B publicly from A. Using C-style casts may work sometimes on some architectures and with some compiler versions, but it's simply an unportable hack that's liable to break at any time (e.g. when turning on compiler optimisations).

As an example of a case that will definitely break on all compilers I know of, if B was actually specified as follows:

class B : public X, private A { ... };    // X is any other class

Then the following code:

A* aPtr3 = (A*)bPtr1;

Will point aPtr3 at the wrong subobject of bPtr1, leading to crashes as soon as a member is accessed or a virtual method is called. (The C-style cast will be converted to a reinterpret_cast because no valid conversion using static_cast or dynamic_cast is available, meaning that aPtr3 will be assigned the same memory address held in bPtr1 -- but because multiple inheritance is in effect, the A subobject contained in *bPtr1 is not located at the same memory adress as bPtr1.)

The moral of the story is that deriving a class privately from another class does not specify an is-a relationship. It's probably best not to think of it as inheritance at all.