Can anyone tell me why this doesn't compile:
struct A { }; struct B : public A { }; int main() { B b; A* a = &b; B* &b1 = static_cast<B*&>(a); return 0; } Now, if you replace the static cast with:
B* b1 = static_cast<B*>(a); then it does compile.
Edit: It is obvious that the compiler treats A* and B* as independent types, otherwise this would work. The question is more about why is that desirable?
B is derived from A, but B* isn't derived from A*. A pointer to a B is not a pointer to an A, it can only be converted to one. But the types remain distinct (and the conversion can, and often will, change the value of the pointer). A B*& can only refer to a B*, not to any other pointer type.
Handling of references is something the compiler does for you, there should be no need to cast to reference.
If we refactor the code to:
B b; A* a = &b; B* b_ptr = static_cast<B*>(a); B*& p1 = b_ptr; It will compile.
p1 doesn't change the pointee in a.You are trying to cast an A* to a B*. This is the wrong way around and not very useful. You probably want to store a pointer to derived in a pointer to base, which is useful and doesn't even need a cast.
I suppose a dynamic_cast might work here, but the result is implementation defined if I'm not mistaken.
dynamic_cast to convert a A* to a B*&. It's not legal, and the code won't compile.A* to B* is the only direction in which static_cast make sense. In the other direction, there is nothing to be done.
ais not a reference to pointers its a pointer.B*&is a reference to a pointer toB.dynamic_castforces the compiler to embed runtime type information into that class hierarchy. Combine this with the relatively slow operation ofdynamic_castand it's a solution which you don't want to use unless it's necessary.dynamic_castwould not be legal here.