struct A 
{ 
  void foo(int i) { cout << (this != NULL ? "not NULL" : "NULL") << " " << i << endl; }
};

void foo(A* this_, int i) { cout << (this_ != NULL ? "not NULL" : "NULL") << " " << i << endl; }

struct B { int x; };

struct C : B, A {};

C* p = NULL;

p->foo(5); // (1)

foo(p, 5); // (2)

((A*) p)->foo(5); // (3)

struct SX { int x; };

struct SB : SX, SA {};

((SB*) 0)->Func();

struct SA
{
  void Func() //невиртуальная
  {
    if (this == NULL) 
      return;
  }  
  static void StaticFunc() {}
};

void main()
{
  ((SA*)0)->StaticFunc(); //ИМХО, тут должно быть все нормально
  ((SA*)0)->Func(); //а вот здесь не понятно, мало ли чего может компилятор напихать
}

#include <afxwin.h>

class CHelloAppAndFrame : public CFrameWnd, public CWinApp
{ 
public:
    CHelloAppAndFrame()
        { }

    // Necessary evil for MI disambiguity
    void* operator new(size_t nSize)
        { return CFrameWnd::operator new(nSize); }
    void operator delete(void* p)
        { CFrameWnd::operator delete(p); }

// Implementation
    // CWinApp overrides
    virtual BOOL InitInstance();
    // CFrameWnd overrides
    virtual void PostNcDestroy();
    afx_msg void OnPaint();

    DECLARE_MESSAGE_MAP()

};

BEGIN_MESSAGE_MAP(CHelloAppAndFrame, CFrameWnd)
    ON_WM_PAINT()
END_MESSAGE_MAP()

// since the frame window is not allocated on the heap, we must
// override PostNCDestroy not to delete the frame object
void CHelloAppAndFrame::PostNcDestroy()
{
    // do nothing (do not call base class)
}

void CHelloAppAndFrame::OnPaint()
{
    CPaintDC dc(this);
    CRect rect;
    GetClientRect(rect);

    CString s = "Hello, Windows!";
    dc.SetTextAlign(TA_BASELINE | TA_CENTER);
    dc.SetTextColor(::GetSysColor(COLOR_WINDOWTEXT));
    dc.SetBkMode(TRANSPARENT);
    dc.TextOut(rect.right / 2, rect.bottom / 2, s);
}

// Application initialization
BOOL CHelloAppAndFrame::InitInstance()
{
    // first create the main frame
    if (!CFrameWnd::Create(NULL, "Multiple Inheritance Sample",
        WS_OVERLAPPEDWINDOW, rectDefault))
        return FALSE;

    // the application object is also a frame window
    m_pMainWnd = this;          
    ShowWindow(m_nCmdShow);
    return TRUE;
}

CHelloAppAndFrame theHelloAppAndFrame;

IT>Зря он это делает, может он ещё и проверку выхода за границы массивов мне делать будет

class A { int i; };
class B { int i; };
class C : public A, public B { };

C* c = 0;
B* b = c; // если здесь не будет проверки на 0,
          // на типичной 32-битной реализации значением указателя b 
          // станет что-нибудь типа 0x00000004

IT>>struct SA
IT>>{
IT>>  void Func(); //невиртуальная и не важно

DG>//как раз важно что функция не виртуальная, для виртуальной функции все будет падать со свистом при нулевом указателе

IT>>  static void StaticFunc();
IT>>};

IT>>void f(SA*)
IT>>{
IT>>  SA->Func(); // откуда компилятору знать, что у программера на уме
IT>>}

IT>>void main()
IT>>{
IT>>  SA::StaticFunc(); // можно обойтись и без объекта
IT>>  f((SA*)0);        // мало ли чего можно компилятору подсунуть
IT>>}
IT>>

/* BAD_STANDARD_OBJ
 *
 * This macro insures that the object is a writable object of the correct size
 * and that this method belongs to the object.
 *
 * NOTES ON USE!
 *  This depends upon using the standard method of declaring the object
 *  interface.
 *
 *  prefix is the method prefix you chose when declaring the object interface.
 *  method is the standard method name of the calling method.
 *  lpVtbl is the name of the lpVtbl element of your object.
 */
#define BAD_STANDARD_OBJ( lpObj, prefix, method, lpVtbl)     (   IsBadWritePtr( (lpObj), sizeof(*lpObj))      || IsBadReadPtr( (void *) &(lpObj->lpVtbl->method), sizeof(LPVOID))      ||( ( LPVOID) (lpObj->lpVtbl->method) != (LPVOID) (prefix##method)))

#define FBadUnknown( lpObj )     (   IsBadReadPtr( (lpObj), sizeof(LPVOID) )      || IsBadReadPtr( (lpObj)->lpVtbl, 3 * sizeof(LPUNKNOWN) )      || IsBadCodePtr( (FARPROC)(lpObj)->lpVtbl->QueryInterface ))

_AFXWIN_INLINE HWND CWnd::GetSafeHwnd() const
    { return this == NULL ? NULL : m_hWnd; }

struct SA
{
  void Func() //невиртуальная
  {
    if (this == NULL) 
      return;
  }  
  static void StaticFunc() {}
};

void main()
{
  ((SA*)0)->StaticFunc(); //ИМХО, тут должно быть все нормально
  ((SA*)0)->Func(); //а вот здесь не понятно, мало ли чего может компилятор напихать
}

struct SA
{
  void Func(); //невиртуальная и не важно
  static void StaticFunc();
};

void f(SA*)
{
  SA->Func(); // откуда компилятору знать, что у программера на уме
}

void main()
{
  SA::StaticFunc(); // можно обойтись и без объекта
  f((SA*)0);        // мало ли чего можно компилятору подсунуть
}

AF>_AFXWIN_INLINE HWND CWnd::GetSafeHwnd() const
AF>    { return this == NULL ? NULL : m_hWnd; }
AF>

inline HWND GetSafeHwnd(CWnd *pW)
{
   return pW == NULL ? NULL : pW->m_hWnd; 
}

AF>_AFXWIN_INLINE HWND CWnd::GetSafeHwnd() const
AF>    { return this == NULL ? NULL : m_hWnd; }
AF>

#define offsetof(s,m)   (size_t)&(((s *)0)->m)

АТ>struct A 
АТ>{ 
АТ>  void foo(int i) { cout << (this != NULL ? "not NULL" : "NULL") << " " << i << endl; }
АТ>};
АТ>

АТ>void foo(A* this_, int i) { cout << (this_ != NULL ? "not NULL" : "NULL") << " " << i << endl; }
АТ>

АТ>struct B { int x; };

АТ>struct C : B, A {};
АТ>

АТ>C* p = NULL;

p->>foo(5); // (1)
АТ>

АТ>foo(p, 5); // (2)
АТ>

АТ>((A*) p)->foo(5); // (3)
АТ>

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

struct A{
  void foo(int i) 
  { 
      cout << hex << this  << " " << i << endl; 
  }
};

void foo(A* this_, int i) 
{ 
    cout << hex << this_  << " " << i << endl; 
}


struct B{
    int x;
};

struct C: B, A{
};

int main(int argc, char* argv[])
{
    C *p=(C*)1;
    p->foo(5);

    foo(p, 5);

    return 0;
}

    // *** IUnknown methods ***
    STDMETHOD(QueryInterface) (THIS_ REFIID riid, LPVOID FAR * lppvObj) PURE;
    STDMETHOD_(ULONG,AddRef) (THIS)  PURE;
    STDMETHOD_(ULONG,Release) (THIS) PURE;

int main(int argc, char* argv[])
{
    C *p=(C*)NULL;
    p->foo(5);

    foo(p, 5);

    return 0;
}

27:   int main(int argc, char* argv[])
28:   {
00411680   push        ebp
00411681   mov         ebp,esp
00411683   sub         esp,48h
00411686   push        ebx
00411687   push        esi
00411688   push        edi
00411689   lea         edi,[ebp-48h]
0041168C   mov         ecx,12h
00411691   mov         eax,0CCCCCCCCh
00411696   rep stos    dword ptr [edi]
29:       C *p=(C*)NULL;
00411698   mov         dword ptr [ebp-4],0
30:       p->foo(5);
0041169F   push        5
004116A1   mov         ecx,dword ptr [ebp-4]
004116A4   add         ecx,4
004116A7   call        @ILT+15(A::foo) (00401014)
31:
32:       foo(p, 5);
004116AC   cmp         dword ptr [ebp-4],0
004116B0   je          main+3Dh (004116bd)
004116B2   mov         eax,dword ptr [ebp-4]
004116B5   add         eax,4
004116B8   mov         dword ptr [ebp-8],eax
004116BB   jmp         main+44h (004116c4)
004116BD   mov         dword ptr [ebp-8],0
004116C4   push        5
004116C6   mov         ecx,dword ptr [ebp-8]
004116C9   push        ecx
004116CA   call        @ILT+55(foo) (0040103c)
004116CF   add         esp,8
33:
34:       return 0;
004116D2   xor         eax,eax
35:   }

class Obj1 : public IUnknown{
  virtual int Sum();
  int x;
  int y;
  char buf[128];
};

class Obj2 : public IUnknown{
  virtual int Get();
  int q;
  int w;
  char name[256];
};

class MainObj: public IUnknown, public Obj1, public Obj2{
  int zzz;
  int xxx;
};

class IObj1:public IUnknown{
public:
  virtual int Sum()=0;
}

((S*)0)->StaticFunc();

((S*)0)->>StaticFunc();
DG>

*(S*) 0;
S::StaticFunc();

#include "stdafx.h"

class Mem{
public:
    unsigned char m[0x400000];
    unsigned char prg[256];
    void Print()
    {
        for(int i=0; i < 256; i++)
            printf("%c", prg[i] >= (unsigned char)' ' ? prg[i] : '.');
        printf("\n");
    }
};


int main(int argc, char* argv[])
{
    Mem *pm=(Mem*)NULL;
    
    for(int i=0; i < 256; i++)
        printf("%c", pm->prg[i] >= (unsigned char)' ' ? pm->prg[i] : '.');
    printf("\n");
    
    pm->Print();

    return 0;
}

struct SA
{
  void Func() //невиртуальная
  {
    if (this == NULL) 
      return;
  }  
  static void StaticFunc() {}
};

void main()
{
  ((SA*)0)->StaticFunc(); //ИМХО, тут должно быть все нормально
  ((SA*)0)->Func(); //а вот здесь не понятно, мало ли чего может компилятор напихать
}

VVV>если бы Вы привели конкретное место в стандарте (хотя бы ссылку) может быть этой дискуссии и не было бы