C++ type casting. When will static_cast succeed and reinterpret_cast will cause an issue?

Question

I understand that a static_cast is a cast from one type to another that (intuitively) is a cast that could under some circumstance succeed and be meaningful in the absence of a dangerous cast. Meanwhile, a reinterpret_cast is a cast that represents an unsafe conversion that might reinterpret the bits of one value as the bits of another value.

Can someone describe a scenario when the code will compile, cast and static_cast will cause no issue, but with reinterpret_cast there will be an issue?

Answer 1

This will do it:

#include <iostream> using namespace std;  struct C{int n;}; struct A{int n;}; struct B : A, C{};  int main() {     B b;     B* pb = &b;     cout << static_cast<C*>(pb) << "\n";     cout << reinterpret_cast<C*>(pb); } 

Note the differences in the two addresses.

I've built some multiple inheritance here, and have put an explicit member in the base classes, in order to circumvent possible optimisation of empty base classes to size zero.

See https://ideone.com/QLvBku