class A {public: void f() { std::cout << "hello world!" << std::endl;};

  void main(void)
  {
    A* a = 0;
    a->f();
  }

void f(A* this)
{
  std::cout << "hello world!" << std::endl;
}

class MyClass
{
    int        a;
    static MyClass Array[100];
public:
    int Index() {return this?this-Array:0;}
    static MyClass* Get(int Index) {return &Array[Index];}
};

MyClass MyClass::Array[100];

int main()
{
    MyClass*            a1 = 0;
    MyClass*            a2 = MyClass::Get(1);
        int Integer;

    Integer = a1->Index(); // Равно 0
    Integer = a2->Index(); // Равно 1
        
        return 0;
}

struct Base
{
    void unsafe()
    {
        printf("unsafe %p\n", this);
    }
    static void bypass()
    {
        printf("bypass\n");
    }
    void safe()
    {
        if(this)
            unsafe();
        else
            bypass();
    }
};

struct Shift
{
    int x;
};

struct Derived : Shift, Base
{
};

int main()
{
    Base* pb = 0;
    pb->safe(); // bypass()
    Derived* pd = 0;
    pb = pd;    // static_cast корректно приводит 0 к 0
    pb->safe(); // далее - bypass()
    pd->safe(); // а вот здесь наблюдаем опаньки!
}

#include "iostream"

class A { public: virtual void f() =0; };
class B { public: virtual void f() { std::cout<< "My string"<<std::endl; } };

void main()
{
// обращаю внимание, что троиточия между кодом нет, весь код "как есть".

    A *a = 0; // здесь именно нули
    B *b = 0; // здесь именно нули

    //a->f();
    b->f();
}

  class A {public: void f() { std::cout << "hello world!" << std::endl;};

  void main(void)
  {
    A* a = 0;
    a->f();
  }

If E1 has the type “pointer to class X,” then the expression E1->E2 is converted to the equivalent form (*(E1)).E2; the remainder of 5.2.5 will address only the first option (dot)

An implementation shall not predefine the main function. This function shall not be overloaded. It shall have a return type of type int, but otherwise its type is implementation-defined.

An implementation shall not predefine the main function. This function shall not be overloaded. It shall
have a return type of type int, but otherwise its type is implementation-defined. All implementations
shall allow both of the following definitions of main:

int main() { /* ... */ }
and
int main(int argc, char* argv[]) { /* ... */ }

In the latter form argc shall be the number of arguments passed to the program from the environment in
which the program is run. If argc is nonzero these arguments shall be supplied in argv[0] through
argv[argc-1] as pointers to the initial characters of null-terminated multibyte strings (NTMBSs)
(17.3.2.1.3.2) and argv[0] shall be the pointer to the initial character of a NTMBS that represents the
name used to invoke the program or "". The value of argc shall be nonnegative. The value of
argv[argc] shall be 0. [Note: it is recommended that any further (optional) parameters be added after
argv. ]

void main(void); // твой вариант, совсем плохой, зато короткий
int main(); // правильный вариант