C++:pointer

template <typename EventTag, typename Class, typename EventArg, typename EventHandler>
void Bind(const EventTag &eventType,
          void (Class::*method)(EventArg &),
          EventHandler *handler,
          int winid = wxID_ANY,
          int lastId = wxID_ANY,
          wxObject *userData = NULL)
{
    DoBind(winid, lastId, eventType,
              wxNewEventFunctor(eventType, method, handler),
              userData);
}

// Non member functions:
return_type (*varName)() = namespace::function; // no parameters 
return_type (*varName)(paramType1, paramTypeN) = namespace::function;

// Member functions:
return_type (Class::*varName)(paramType1, paramTypeN) = &Class::method;

// Typedefs for function pointer types:
typedef return_type (*TypeName)(paramType1, paramTypeN); 
typedef return_type (ExampleClass::*TypeName)(paramType1, paramTypeN); 

// declarations the type name is omitted, like when casting e.g.
static_cast<void(Class::*)()>(&Class::method)

// Calling a non-member function pointer:
void (*funcPtr)(paramType1, paramTypeN) = namespace::function; 
funcPtr(parameter1, parameterN); 

// Calling a member function pointer:
void (Class::*memberFuncPtr)() = &Class::method; 

Class* ptrInstance = new Class(); 
(ptrInstance->*memberFuncPtr)(); 

Class refInstance; 
(refInstance.*memberFuncPtr)(); 

namespace 
{ 
  int simple() { return 0; } 
  float test1(int first, float second, char third) { return 0.0; } 
  float test2(int first, float second, char third) { return 0.0; } 

  template <typename T_Example> 
  void templateExample(T_Example param) {} 

  class Class 
  { 
  public: // interface 
    void method(int var) {} 
    void overload(int var) {} 
    void overload(int first, float second) {} 

  }; // class 

  template <typename T_Example> 
  class TemplateClass 
  { 
  public: // interface 
    void templateDo(T_Example templateParam, int extraParam) {} 

  }; // class 

} // namespace 

int main(int arg, char** argv) 
{ 
  // non-member examples 
  int (*simpleNonMember)() = simple; 
  simpleNonMember(); 

  typedef float (*TestTypeFuncPtr)(int, float, char); 

  TestTypeFuncPtr test1FuncPtr = test1; 
  TestTypeFuncPtr test2FuncPtr = test2; 
  test1(7, 12.5, 'c'); // directly 
  test1FuncPtr(7, 12.5, 'c'); // through the function pointer 
  test2FuncPtr(11, 857.2, 'r'); 

  // non-member template examples 
  void (*templateExampleFuncPtr1)(int) = templateExample<int>; 
  void (*templateExampleFuncPtr2)(float) = templateExample<float>; 
  templateExampleFuncPtr1(7); 
  templateExampleFuncPtr2(7.f); 

  // member examples 
  Class* classPtr = new Class(); 
  Class classRef; 
  void (Class::*overload2FuncPtr)(int, float) = &Class::overload; 
  (classRef.*overload2FuncPtr)(0, 2.f); 

  typedef void (Class::*ClassIntParamTypeFuncPtr)(int); 
  ClassIntParamTypeFuncPtr overload1AndMethodFuncPtr = nullptr; 
  overload1AndMethodFuncPtr = &Class::method; 
  overload1AndMethodFuncPtr = &Class::overload; 
  (classPtr->*overload1AndMethodFuncPtr)(7); 
  (classRef.*overload1AndMethodFuncPtr)(7); 

  // template class member examples 
  TemplateClass<float>* templateClassPtr = new TemplateClass<float>(); 

  typedef void (TemplateClass<float>::*TemplateDoTypeFloat)(float, int); 
  TemplateDoTypeFloat templateDoFuncPtr = &TemplateClass<float>::templateDo; 
  (templateClassPtr->*templateDoFuncPtr)(11.f, 5); 

} // main