указатели на элементы класса

class A
{
    public:
    void C(void){return;}
        static int D(void){return 0;}
    int a;
        static int d;
};
 
int main(int argc, char** argv)
{
        A a_obj;
    int (A:: *p)= &A::a;// - работает
        //int *p= &a_obj.a; - не работает
        //int *p= &A::a; - не работает
        void (A::*f)(void)= &A::C; // - работает
        //void (*f)(void)= &A::C; - Не работает
        //void (*f)(void)= &a_obj.C; - Не работает
        int *e1= &a_obj.a;// - Работает
        int *e2= &A::a;// - Работает
        int (*F1)(void)= &A::D;// - работает
        int (*F2)(void)= &a_obj.D;// - работает
    system("Pause");
    return 0;
}

  
      //int *p= &a_obj.a; - не работает
        //int *p= &A::a; - не работает

LRESULT CALLBACK WndProc(HWND, UINT, WPARAM, LPARAM);
 
// ...
 
WNDCLASSEX wcex;
wcex.lpfnWndProc = WndProc;

#include <vector>
#include <algorithm>
#include <iostream>
 
bool predicate( int a, int b );
 
int main()
{
   std::vector< int > vec = { 1, 0, 3, -1, 10, 5, 16, 20, 2 };
   
   for ( std::vector< int >::iterator it = vec.begin(); it != vec.end(); ++it ) {
      std::cout << *it << ' ';
   }
   std::cout << std::endl;
 
   std::sort( vec.begin(), vec.end(), predicate );   
 
   for ( std::vector< int >::iterator it = vec.begin(); it != vec.end(); ++it ) {
      std::cout << *it << ' ';
   }
   std::cout << std::endl;
   
   return 0;
}
 
bool predicate( int a, int b )
{
   return a < b;
}

void (*funcPtr)() = func;
void (*funcPtr2)() = &func;

funcPtr();
(*funcPtr)();

int f(int a){return a;}
 
void F(int val){return val;}
 
int main(void)
{
   F(f(1)); // Передаю функцию ^_^
}

#include <iostream>
 
class Foo
{ 
public:
   void a() { std::cout << "Foo::a()" << std::endl; }
};
 
void invokeMember( Foo* foo, void( Foo::* ptr )() )
{
   (foo->*ptr)(); // Вызов метода по указателю на экземпляр класса и указателю на метод
}
 
int main()
{
   Foo foo;
 
 
   invokeMember( &foo, &Foo::a );
 
   void ( Foo::* ptr )() = &Foo::a;
   (foo.*ptr)(); // Вызов метода по указателю на экземпляре объекта
     
   return 0;
}

Foo* foo = NULL;
foo->bar();

typedef void (Foo::*MethodPtr)();
//примерно эквивалентно
struct MethodPtr
{
  bool isVirtual;
  void (*nonVirtPtr)(Foo*);
  int virtFunPtrOffset;
};
 
{
  MethodPtr nonVirtPtr = &Foo::NonVirtual;
  MethodPtr virtPtr = &Foo::Virtual;
 
  // после этого поля у ptr будут такими:
  //nonvirtPtr.isVirtual == false;
  //nonvirtPtr.NonVirtPtr == указатель на функцию
  //nonvirtPtr.virtFunPtrOffset == неопределено. пусть будет -1
 
  //virtPtr.isVirtual == true;
  //virtPtr.NonVirtPtr == не определено. пусть будет 0
  //virtPtr.virtFunPtrOffset == смещение в таблице. пусть будет 0 (т.е. первый метод в таблице)
 
   //далее код вызова превращается в следующее
 
   MethodPtr ptr = nonVirtPtr;
   //MethodPtr ptr = virtPtr;
 
   Foo* foo = 0;
   foo->*method)();
   if (ptr.isVirtual)
   {
      // Получение указателя на табличку. Может крашнутся,
      // а может и нет. Просто вернется указатель на хз что.
      // Ведь чтобы получить указатель на таблицу, компилятору
      // нужно знать лишь адрес объекта и сместится относительно
      // него на определенное известное во время компиляции значение.
      // нет особого смысла проверять корректность адреса объекта,
      // к нему достаточно прибавить нужное смещение. Если адрес
      // объекта будет кривой, то и адрес таблички тоже будет кривым
      // жопа случится при попытке вызвать что-то из этой таблицы.
      
      VTable vtbl = GetVTableOfObject(foo);
      // В этом месте у нас есть таблица и индекс функции в этой
      // таблице. Сигнатура метода тоже известна.
      (vtbl[ptr.virtFuncOffset])(foo);
 
      // в случае кривого указателя на таблицу вот это:
      // vtbl[ptr.virtFuncOffset] - тоже кривое.
 
   }
   else
   {
     // в этой ветке для вызова метода сам объект вроде как и не нужен.
     // метод вызовится ну а крашнется или нет уже зависит от кода 
     // самого метода. Главное что метод вызовится.
     (ptr.nonVirtPtr)(foo);
   }
}

typedef void (Foo::*MethodPtr)();
//примерно эквивалентно
struct MethodPtr
{
  bool isVirtual;
  void (*nonVirtPtr)(Foo*); // указатель на функцию (как бы свободную), которая возвращает void и принимает Foo*
  int virtFunPtrOffset;
};
 
{
  MethodPtr nonVirtPtr = &Foo::NonVirtual;
  MethodPtr virtPtr = &Foo::Virtual;
 
  // после этого поля у указателей будут такими:
  //nonvirtPtr.isVirtual == false;
  //nonvirtPtr.NonVirtPtr == указатель на функцию
  //nonvirtPtr.virtFunPtrOffset == неопределено. пусть будет -1
 
  //virtPtr.isVirtual == true;
  //virtPtr.NonVirtPtr == не определено. пусть будет 0
  //virtPtr.virtFunPtrOffset == смещение в таблице. пусть будет 0 (т.е. первый метод в таблице)
 
 
 
   MethodPtr methodPtr = nonVirtPtr;
   //MethodPtr methodPtr = virtPtr;
 
   Foo* foo = 0;
   (foo->*methodPtr)();
   //этот код превращается примерно в следующее
   if (methodPtr.isVirtual)
   {
      // Получение указателя на табличку. Может крашнутся,
      // а может и нет. Просто вернется указатель на хз что.
      // Ведь чтобы получить указатель на таблицу, компилятору
      // нужно знать лишь адрес объекта и сместится относительно
      // него на определенное известное во время компиляции значение.
      // нет особого смысла проверять корректность адреса объекта,
      // к нему достаточно прибавить нужное смещение. Если адрес
      // объекта будет кривой, то и адрес таблички тоже будет кривым
      // жопа случится при попытке вызвать что-то из этой таблицы.
      
      VTable vtbl = GetVTableOfObject(foo);
      // В этом месте у нас есть таблица и индекс функции в этой
      // таблице. Сигнатура метода тоже известна.
      (vtbl[methodPtr.virtFuncOffset])(foo);
 
      // в случае кривого указателя на таблицу вот это:
      // vtbl[methodPtr.virtFuncOffset] - тоже кривое.
 
   }
   else
   {
     // в этой ветке для вызова метода сам объект вроде как и не нужен.
     // метод вызовится ну а крашнется или нет уже зависит от кода 
     // самого метода. Главное что метод вызовится.
     (methodPtr.nonVirtPtr)(foo);
   }
}