С++14
12.7 Construction and destruction

3. To explicitly or implicitly convert a pointer (a glvalue) referring to an object of class X to a pointer (reference) to a direct or indirect base class B of X, the construction of X and the construction of all of its direct or indirect bases that directly or indirectly derive from B shall have started and the destruction of these classes shall not have completed, otherwise the conversion results in undefined behavior. To form a pointer to (or access the value of) a direct non-static member of an object obj, the construction of obj shall have started and its destruction shall not have completed, otherwise the computation of the pointer value (or accessing the member value) results in undefined behavior.
[Example:

struct A { };
struct B : virtual A { };
struct C : B { };
struct D : virtual A { D(A*); };
struct X { X(A*); };



struct E : C, D, X { //undefined: upcast from E* to A*
    E() : D(this),   //might use path E* → D* → A*
                     // but D is not constructed
                     // D((C*)this), // defined:
                     // E* → C* defined because E() has started
                     // and C* → A* defined because
                     // C fully constructed
    X(this) {        // defined: upon construction of X,      
    }                // C/B/D/A sublattice is fully constructed            
};

— end example ]

    Base * p2;
    p2 = p1;
    delete p1;
    printf("p2 = %p\r\n", (void *)p2);//Ok

O>#include <cstdio>

O>struct Base
O>{
O>    virtual ~Base() {}
O>};

O>struct X1 : public virtual Base {};
O>struct X2 : public virtual Base {};
O>struct Child : public X1, public X2 {};

O>int main()
O>{
O>    X1 * p1 = new X1();
O>    delete p1;
O>    Base * p2;
O>    p2 = p1;
O>    printf("p2 = %p\r\n", (void *)p2);
O>    return 0;
O>}
O>

#include <cstdio>

struct Base
{
    virtual ~Base() {}
};

struct X1 : public virtual Base {};
struct X2 : public virtual Base {};
struct Child : public X1, public X2 {};

int main()
{
    X1 * p1 = new X1();
    delete p1;
    X1 * p2; // Эта строка изменена!!!
    p2 = p1;
    printf("p2 = %p\r\n", (void *)p2);
    return 0;
}

To explicitly or implicitly convert a pointer (a glvalue) referring to an object of class X to a
pointer (reference) to a direct or indirect base class B of X, the construction of X and the construction
of all of its direct or indirect bases that directly or indirectly derive from B shall have
started and the destruction of these classes shall not have completed, otherwise the conversion
results in undefined behavior.

//
//  The "obvious" converting constructor implementation:
//
//  template<class Y>
//  weak_ptr(weak_ptr<Y> const & r): px(r.px), pn(r.pn)
//  {
//  }
//
//  has a serious problem.
//
//  r.px may already have been invalidated. The px(r.px)
//  conversion may require access to *r.px (virtual inheritance).
//
//  It is not possible to avoid spurious access violations since
//  in multithreaded programs r.px may be invalidated at any point.
//

shared_ptr<X1> ptr = ...;
weak_ptr<X1> w1(ptr);
ptr.reset();
weak_ptr<Base> w2(w1); // BANG!

Derived* d;

Base* b = d;  // up-cast разрешён всегда
Derived* d1 = static_cast<Derived*>(b);  // down-cast должен быть явным
Base* b1 = d1;

assert(d == d1);
assert(b == b1);

#include <iostream>
#include <cassert>
using namespace std;

struct Alfa { char t[1024]; };
struct Base { char u[1024]; };
struct Derived: Alfa, Base { char v[1024]; };

Derived* downcast(Base* b) {
  return static_cast<Derived*>(b);
}

void test_bd(Base* b) {
  Derived* d = downcast(b);
  cout << "bd::" << b << " " << d << endl;
}

void test_dbd(Derived* d) {
  Base* b = d;
  const char* isnull = (b == nullptr) ? "" : "!=nullptr";
  const char* iszero = (intptr_t)(b) == 0 ? "" : "!=zero";
  Derived* d1 = downcast(b);
  cout << "dbd:" << d << " " << b << isnull << iszero << " " << d1 << " " << endl;
  test_bd(b);
}

void test_bdb(Base* b) {
  Derived* d = downcast(b);
  Base* b1 = d;
  cout << "bdb:" << b << " " << d << " " << b1 << endl;
}

int main() {
  test_dbd((intptr_t)0);                  // 0 0 0 / 0 0
  test_bdb((intptr_t)0);                  // 0 0 0
  test_dbd((Derived*)(intptr_t)(-1024));  // 0xfffffffffffffc00 0!=nullptr!=zero 0xfffffffffffffc00 / 0 0
  test_bdb((Base*)(intptr_t)(1024));      // 0x400 0 0
}

struct A { int x; };
 
struct B : virtual A { int y; };
 
int main() {
    B* b = (B*)(intptr_t(100500));
    A* a = b;
    cout << b << " " << a << endl;
}

class Foo 
{
public:
    int f(string str) 
    {
        std::cout << "Foo::f()" << std::endl;
        return 1;
    }
};

int main()
{
    int (Foo::*fptr) (string) = &Foo::f;
    std::cout << "sizeof-fptr=" << sizeof(fptr) << std::endl;
    ...
    return 0;
}

AG>

#include <iostream>
#include <string>
 
struct A
{
    virtual void f() = 0;
};
 
struct B : A
{
    void f() override {}
};
 
int main()
{
    const auto p = &B::f;
    const bool ok = sizeof(void *) == sizeof( p );
    if ( !ok )
        std::cout << "Not OK";
    return 0;
}

#include "stdafx.h"
#include <iostream>
#include <string>

struct A
{
    virtual void f() = 0;
};

struct B : A
{
    void f() override {}
};

int main()
{
    const auto p = &B::f;
    const bool ok = sizeof(void *) == sizeof(p);
    if (!ok)
        std::cout << "Not OK"; 

    std::cout << "sizeof(void *) = " << sizeof(void *) << std::endl; 
    std::cout << "sizeof(p) = " << sizeof(p) << std::endl;

    getchar();
    return 0;
}