Skip to content

C++:pointer

Function 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);
}

참고로 위의 코드는 wxWidgets에서 추출하였다.

Declaring function pointer variables 

// 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)

Using function pointer variables 

// 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)();

Instructive Examples

좀 더 직접적인 예제는 아래와 같다. 

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

Types

포인터 관련 데이터 타입에 대한 설명.

  • size_t: 안전한 크기 타입 제공을 위해 사용.
  • ptrdiff_t : 포인터 연산을 처리하기 위해 사용.
  • intprt_t와 uintprt_t: 포인터 주소를 저장하기 위해 사용.

See also