AG>float f1;
AG>float f2;
AG>f2 = f1;
AG>

#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;
    Base * p2;
    p2 = p1;
    printf("p2 = %p\r\n", (void *)p2);
    return 0;
}

С++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

SomeType * x;
AnotherType * y;

//
// здесь много разного кода.
// x и y присваиваются всякие значения,
//    а может и не присваиваются...
//

x = y;

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;
}

struct A {
  int *x, *y;
  void fn() {
    x=y;
  }
};

int main(int argc,char** argv) {
    A *a=0;
    a->fn();
    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;
}

Всегда инициализируйте указатели в конструкторах и всегда обнуляйте указатель после освобождения памяти, на которую он указывает. Эти действия лишними не бывают.

O>SomeType * x;
O>AnotherType * y;
O>

char* x;
char* y;

O>SomeType * x;
O>AnotherType * y;

O>//
O>// здесь много разного кода.
O>// x и y присваиваются всякие значения,
O>//    а может и не присваиваются...
O>//

O>x = y;
O>

if (dynamic_cast<SomeType*>(y))
{
   x = y;
}

float f1;
float f2;
f2 = f1;

If the destination operand is a segment register (DS, ES, FS, GS, or SS), the source operand must be a valid segment selector. In protected mode, moving a segment selector into a segment register automatically causes the segment descriptor information associated with that segment selector to be loaded into the hidden (shadow) part of the segment register. While loading this information, the segment selector and segment descriptor information is validated (see the "Operation" algorithm below).

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;
}

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;
}

struct A // ...
{
  virtual void f(){}
};
struct B // ...
{
  virtual void f(){}
};

sizeof( &A::f ) != sizeof( &B::f ); // ?