struct B {};
struct D : B {};

int main()
{
    B b;
    B* pb1 = reinterpret_cast<B*>( reinterpret_cast<D*>( &b ) ); // pb1 == &b
    B* pb2 = static_cast     <B*>( static_cast     <D*>( &b ) ); // значение pb2 неопределено согласно 5.2.9/1 :crash: 
}

F>struct B {};
F>struct D : B {};

F>int main()
F>{
F>    B b;
F>    B* pb1 = reinterpret_cast<B*>( reinterpret_cast<D*>( &b ) ); // pb1 == &b
F>    B* pb2 = static_cast     <B*>( static_cast     <D*>( &b ) ); // значение pb2 неопределено согласно 5.2.9/1 :crash: 
F>}
F>

[skipped]
If the rvalue of type "pointer to cv1 B" points to the B that is actually a sub-object of an object of type D, the resulting pointer points to the enclosing object of type D.
[skipped]

#pragma pack(1)
struct A { char x[0x100]; };
struct B { int y; };
struct C : A, B {};


B b;

main()
{
  B* pb = &b;
  C* pc = static_cast<C*>(pb);
  char* ps = reinterpret_cast<char*>(pb) - 0x100;
  // значения pc и ps совпадают
};

A>00411A10  mov         eax,dword ptr [pb] 
A>00411A13  sub         eax,100h 
A>00411A18  mov         dword ptr [ebp-0E8h],eax

jnc @okay
call overflow_in_address_arithmetics

struct A {...};
struct B {...};
struct C : A, B {...};

int main()
{
  C c;
  C* pc1 = &c;
  B* pb1 = pc1; // неявный static_cast
  C* pd1 = static_cast<C*>(pb1); // d значит downcast
  assert( pd1 == pc1 );

  C* pc0 = NULL;
  B* pb0 = pc0;
  assert( pb0 == NULL );
  C* pd0 = static_cast<C*>(pb0);
  assert( pd0 == NULL );

  static B b;
  B* pb2 = &b;
  C* pd2 = static_cast<B*>(pb2);
  assert( pd2 != NULL ); // увы, таких гарантий нет.
  B* pu2 = pd2; // если pd2 == 0, то и pu2 == 0
  assert( pb2 == pu2 ); // смотрим выше...
}

К>#pragma pack(1)
К>struct A { char x[0x100]; };
К>struct B { int y; };
К>struct C : A, B {};


К>B b;

К>main()
К>{
К>  B* pb = &b;
К>  C* pc = static_cast<C*>(pb);
К>  char* ps = reinterpret_cast<char*>(pb) - 0x100;
К>  // значения pc и ps совпадают
К>};
К>

int main()
{
  SomeClass* p; // неинициализированный указатель, как насчет загрузки селектора сегмента?
}

class Closure
{
 public:
    typedef int Func(int);
    
    template<class T> Closure(T*, Func T::*);
    
    int operator()(int i) const { return ( object_->*method_ )( i ); }
 
 private:
    // Наследование от A и B нужно, чтобы VC использовал для CommonBase
    // multiple inheritance member pointer representation без всяких прагм.
    // Для других компиляторов этого может не понадобиться, но хуже от этого не будет.
    class A {};
    class B {};
    class CommonBase : A, B {};
    
    CommonBase* object_;
    Func CommonBase::* method_;
};

template<class T>
Closure::Closure(T* object, Func T::* method)
{
    class CommonDeriver : public T, public CommonBase {};
    
    Func CommonDeriver::* pmf = method;
    this->method_ = static_cast<Func CommonBase::*>( pmf );
    
    CommonDeriver* po = static_cast<CommonDeriver*>( object ); // ub, обидно однако
    this->object_ = po;
}

#include<iostream>

struct Test
{
    int i;
    int add(int j) { return i + j; }
};

int main()
{
    Test t = { 5 };
    Closure c( &t, &Test::add );
    std::cout << c( 2 ) << '\n';
    return 0;
}