class abc {
public:
    start {
      void* ptr = this->action;
      }
    action ();    
  }

R>class abc {
R>public:
R>    start { // Это еще что такое ? 
R>      void* ptr = this->action;
R>      }
R>    action ();    
R>  }

class abc 
{ 
public: 
  typedef void (abc::*ptr_to_action_function)();
  void start()
  { 
    ptr_to_action_function ptr = action; 
    // (this->*ptr)(); // Вызов
  } 
  void action(); 
};

class A
{
public:
    void start()
    {
        void (A::*ptr)() = action;
    }
    
    void action ()
    {}
};

class abc {
public:
    int data;
    void action () { }
    void func () {
        void *ptr;
        ptr=&data;
        ptr=&action; //не работает
        }
    };

int glob_data;
void glob_action () { }

void main () {
void *ptr;
ptr = &glob_data;
ptr = &glob_action;
}

R>class abc {
R>public:
R>    int data;
R>    void action () { }
R>    void func () {
R>        void *ptr;
R>        ptr=&data;
R>        ptr=&action; //не работает
R>

R>int glob_data;
R>void glob_action () { }

R>void main () {

int main() {

R>void *ptr;
R>ptr = &glob_data;
R>ptr = &glob_action;

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 implementationdefined.
All implementations
shall allow both of the following definitions of main:

int main() { /* ... */ }

and

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

struct A 
{ 
  int i; 
  void foo(); 
  static int bar(double);
};

A a;
int i;

void foo();

int* p = &i;
int* q = &a.i;

void (*p)() = &foo;
int (*q)(double) = &A::bar;

void (A::*p)() = &A::foo;

int A::*p = &A::i;