이전 된 블로그 http://alones.kr

목차

//--------------------------------------------------------
// 1.2 소개 예제 또는 switch 문을 대처하는 방법
// Task: '+', '-', '*' 또는 '/' 문자들로 구분되는 4개 기본 산술 연산 중 하나 수행

// 4개의 산술 연산들 ... 실행 중switch 문 또는 함수 포인터에 의해서 이중 하나가 
// 선택된다.
float Plus    (float a, float b) { return a+b; }
float Minus   (float a, float b) { return a-b; }
float Multiply(float a, float b) { return a*b; }
float Divide  (float a, float b) { return a/b; }


// switch 문으로 해결 - <opCode>가 어떤 연산이 수행되어야하는지를 결정
void Switch(float a, float b, char opCode)
{
   float result;

   // 연산 수행
   switch(opCode)
   {
      case '+' : result = Plus     (a, b); break;
      case '-' : result = Minus    (a, b); break;
      case '*' : result = Multiply (a, b); break;
      case '/' : result = Divide   (a, b); break;
   }

   cout << "Switch: 2+5=" << result << endl;         // 결과 출력
}


// 함수 포인터를 이용해서 해결 - <pt2Func>은 함수 포인터 이고 두 개의 float를 받아서
// float 하나를 반환하는 함수에 대한 포인터이다. 이 함수 포인터는 어떤 연산이 수행
// 되어야하는지를 "결정 한다."
void Switch_With_Function_Pointer(float a, float b, float (*pt2Func)(float, float))
{
   float result = pt2Func(a, b);    // 함수 포인터를 이용해서 호출

   cout << "Switch replaced by function pointer: 2-5=";  // 결과 출력
   cout << result << endl;
}


// 예제 코드 수행
void Replace_A_Switch()
{
   cout << endl << "Executing function 'Replace_A_Switch'" << endl;

   Switch(2, 5, /* '+' specifies function 'Plus' to be executed */ '+');
   Switch_With_Function_Pointer(2, 5, /* pointer to function 'Minus' */ &Minus);
}

// 2.1 함수 포인터를 선언하고 NULL로 초기화 시킴
int (*pt2Function)(float, char, char) = NULL;                        // C
int (TMyClass::*pt2Member)(float, char, char) = NULL;                // C++
int (TMyClass::*pt2ConstMember)(float, char, char) const = NULL;     // C++
//[alones] 두개의 class 멤버 함수에 대한 함수 포인터 선언을 주목해보라

// 2.2 함수 규약 정의
void __cdecl DoIt(float a, char b, char c);                         // Borland and Microsoft
void         DoIt(float a, char b, char c)  __attribute__((cdecl)); // GNU GCC

// 2.3 함수 포인터 주소를 함수 포인터에 대입
//     Note: 대부분의 컴파일러에서 주소 연산자를 쓰지 않아도 되지만
//     포팅 이슈를 고려해서 항상 정확하게 쓰는 것이 좋다.

// C [alones] 두 개의 함수가 있을 때 
int DoIt  (float a, char b, char c){ printf("DoIt\n");   return a+b+c; }
int DoMore(float a, char b, char c)const{ printf("DoMore\n"); return a-b+c; }

pt2Function = DoIt;      // 간단한 방식
pt2Function = &DoMore;   // 주소 연산자를 사용한 정확한 대입 [alones] 권장 사항

//[alones] C++을 잘 보라 경이롭다.
// C++
class TMyClass
{
public:
   int DoIt(float a, char b, char c){ cout << "TMyClass::DoIt"<< endl; return a+b+c;};
   int DoMore(float a, char b, char c) const
         { cout << "TMyClass::DoMore" << endl; return a-b+c; };

   /* TMyClass의 나머지 부분*/
};
// 주소 연산자를 사용한 정확한 대입 [alones] 권장 사항
pt2ConstMember = &TMyClass::DoMore;

// note: <pt2Member>는 또한 문제 없이 &DoMore를 가르킨다. [alones check]
pt2Member = &TMyClass::DoIt;

// 2.4 함수 포인터 비교

// C
if(pt2Function >0){                    // 초기화 (NULL로) 되었는지 체크
   if(pt2Function == &DoIt)
      printf("Pointer points to DoIt\n"); }
else
   printf("Pointer not initialized!!\n");


// C++
if(pt2ConstMember == &TMyClass::DoMore)
   cout << "Pointer points to TMyClass::DoMore" << endl;

// 2.5 함수 포인터를 이용한 함수 호출 
int result1 = pt2Function    (12, 'a', 'b');          // C의 간단한 방식
int result2 = (*pt2Function) (12, 'a', 'b');          // C

TMyClass instance1;
int result3 = (instance1.*pt2Member)(12, 'a', 'b');   // C++
// C++ this 포인터가 가능한 경우
int result4 = (*this.*pt2Member)(12, 'a', 'b');

TMyClass* instance2 = new TMyClass;
// C++, instance2는 포인터 이다.
int result4 = (instance2->*pt2Member)(12, 'a', 'b');
delete instance2;

//------------------------------------------------------------------------------------
// 2.6 함수 포인터를 어떻게 아규먼트로 전달할 것인가?

// <pt2Func>는 int를 반환하고 한 개의 float와 두 개의 char를 인자로 받는 함수를
// 가르키고 있다.
void PassPtr(int (*pt2Func)(float, char, char))
{
   int result = (*pt2Func)(12, 'a', 'b');     // 함수 포인터를 이용한 호출
   cout << result << endl;
}

// 예제 코드를 수행 시킨다 - 'Dolt'는 2.1-4에 정의된 것 처럼 적절한 함수이다.
void Pass_A_Function_Pointer()
{
   cout << endl << "Executing 'Pass_A_Function_Pointer'" << endl;
   PassPtr(&DoIt);
}

//------------------------------------------------------------------------------------
// 2.7 함수 포인터를 어떻게 반환할 것이가
//     'Plus' and 'Minus' 위에 정의 되었다. ([alones] 가정)
//      두 개의 float를 인자로 받고 float를 반환한다.


// 직접 해결하는 방법: 함수 포인터를 반환할 함수는 하나의 char를 인자로 받고
// 함수 포인터를 반환한다. 반환되는 함수 포인터는 두 개의 float를 인자로 받고 
// float를 반환한다. 
// <opCode>는 어느 함수가 반환될 지를 명시한다.

// [alones] GetPrt1이 함수 이름이고 opCode는 GetPrt1의 함수 인자이다.
// float와 '*' 그리고 (float, float)는 반환되는 함수 포인터의 정의이다.
// 즉 float (*aPtFunc)(float, float)와 함수 포인터가 반환된다는 뜻이다.
float (*GetPtr1(const char opCode))(float, float)
{
   if(opCode == '+')
      return &Plus;
   else
      return &Minus; // 잘 못된 연산자가 전달되면 디폴트로 반환
}

// typedef를 이용한 해결 법: 두 개의 float를 인자로 받고 float를 반환하는
// 함수에 대한 포인터를 정의한다.
typedef float(*pt2Func)(float, float);

// 함수는 char를 인자로 받고 위에서 typedef로 정의된 함수 포인터를 반환한다.
// <opCode>는 어떤 함수가 반환될지를 명시한다.
pt2Func GetPtr2(const char opCode)
{
   if(opCode == '+')
      return &Plus;
   else
      return &Minus; // 잘 못된 연산자가 전달되면 디폴트로 반환
}


// 예제 코드 실행
void Return_A_Function_Pointer()
{
   cout << endl << "Executing 'Return_A_Function_Pointer'" << endl;

   // 함수 포인터를 정의하고 NULL로 초기화 한다.
   float (*pt2Function)(float, float) = NULL;

   //'GetPtr1' 함수로 부터 함수 포인터를 얻는다.
   pt2Function=GetPtr1('+');
   // 반환된 포인터를 이용해서 함수를 호출한다.
   cout << (*pt2Function)(2, 4) << endl;

   //'GetPtr2' 함수로 부터 함수 포인터를 얻는다.
   pt2Function=GetPtr2('-');
   // 반환된 포인터를 이용해서 함수를 호출한다.
   cout << (*pt2Function)(2, 4) << endl;
}

//------------------------------------------------------------------------------------
// 2.8 함수 포인터 배열은 어떻게 사용하는가?

// C ---------------------------------------------------------------------------------

// 타입 정의: 'pt2Function'은 이제 타입으로 사용될 수 있다.
typedef int (*pt2Function)(float, char, char);

// 함수 포인터 배열을 어떻게 사용하는지를 보여준다.
void Array_Of_Function_Pointers()
{
   printf("\nExecuting 'Array_Of_Function_Pointers'\n");

   // 배열을 정의하고 각 각을 NULL로 초기화한다. <funcArr1>과 <funcArr2>는 [[br]]
   // int를 반환하고 float 하나와 두 개의 char를 인자로 받는 함수들에 대한 [[br]]
   // 10개의 포인터로 구성된 배열이다.

   // typedef를 이용한 첫 번째 방법
   pt2Function funcArr1[10] = {NULL};

   // 함수 포인터를 직접 사용하는 두 번째 방법
   int (*funcArr2[10])(float, char, char) = {NULL};


   // 함수 주소 대입 - 'DoIt'과 'DoMore'는 함수는 2.1-4에 정의되어 있는 것 [[br]]
   // 처럼 함수 시그너처가 적절한 함수이다.
   funcArr1[0] = funcArr2[1] = &DoIt;
   funcArr1[1] = funcArr2[0] = &DoMore;

   /* 좀더 대입 */

   // 함수 포인터 주소에 대한 인덱스를 이용해서 함수 호출
   printf("%d\n", funcArr1[1](12, 'a', 'b'));         //  간단한 방식
   printf("%d\n", (*funcArr1[0])(12, 'a', 'b'));      // "정확한" 호출 방법
   printf("%d\n", (*funcArr2[1])(56, 'a', 'b'));
   printf("%d\n", (*funcArr2[0])(34, 'a', 'b'));
}


// C++ -------------------------------------------------------------------------------

// 타입 정의: 'pt2Member'는 이제 타입으로 사용될 수 있다.
typedef int (TMyClass::*pt2Member)(float, char, char);

// 멤버 함수 포인터들의 배열이 어떻게 동작하는지를 보여준다.
void Array_Of_Member_Function_Pointers()
{
   cout << endl << "Executing 'Array_Of_Member_Function_Pointers'" << endl;

   // 배열을 정의하고 NULL로 각 배열의 요소들을 초기화한다. <funcArr1>과 [[br]]
   // <funcArr2>는 int를 반환하고 float하나와 두 개의 char를 인자로 받는 [[br]]
   // 멤버 함수들에 대한 10개의 포인터로 구성된 배열이다.

   // typedef를 이용한 첫 번째 방법
   pt2Member funcArr1[10] = {NULL};

   // 함수 포인터를 그대로 사용하는 두 번째 방법
   int (TMyClass::*funcArr2[10])(float, char, char) = {NULL};

   // 함수 주소 대입 - 'Doit'과 'DoMore'는 2.1-4에 정의된 것 처럼 TMyClass의 [[br]]
   // 적절한 멤버 함수이다.
   // 첫 번째 방법은 typedef를 사용했고, 두 번째 방법은 함수 포인터를 그대로 [[br]]
   // 사용했다. 어떤 방법을 사용할지는 프로그래머의 취향에 달려 있따.
   funcArr1[0] = funcArr2[1] = &TMyClass::DoIt;
   funcArr1[1] = funcArr2[0] = &TMyClass::DoMore;

   /* 좀 더 대입 */

   // 멤버 함수 포인터를 가르키는 인덱스를 이용해서 함수 호출
   // note: 멤버 함수를 호출하기 위해 TMyClass의 인스턴스가 필요하다.
   TMyClass instance;
   cout << (instance.*funcArr1[1])(12, 'a', 'b') << endl;
   cout << (instance.*funcArr1[0])(12, 'a', 'b') << endl;
   cout << (instance.*funcArr2[1])(34, 'a', 'b') << endl;
   cout << (instance.*funcArr2[0])(89, 'a', 'b') << endl;
}

void qsort(void* field, size_t nElements, size_t sizeOfAnElement,
                    int(_USERENTRY *cmpFunc)(const void*, const void*));

//[alones] _USERENTRY는 함수 호출 규약에 대한 매크로 일 것이다
void qsort( ... , int(_USERENTRY *cmpFunc)(const void*, const void*))
{
   /* 소팅 알고리즘 - note : item1과 item2는 void 포인터이다.

   int bigger=cmpFunc(item1, item2);  // 콜백 수행

   /* 결과 이용 */
}

//--------------------------------------------------------------------------------
   // 3.3 소팅 함수인 qsort의 방법을 이용해서 콜백을 만드는 방법

   #include <stdlib.h>        // qsort를 위한 include
   #include <time.h>          // 랜덤을 위해
   #include <stdio.h>         // printf를 위해

   // 소트 알고리즘을 위한 비교 함수
   // 두 개의 아이템은 void 포인터에 의해 전달되고, 변경되어 비교된다
   int CmpFunc(const void* _a, const void* _b)
   {
      // 타입 변환 (지금 예제는 float 필드를 가지고 하는 것이다)
      const float* a = (const float*) _a;
      const float* b = (const float*) _b;

      // 첫 번째 아이템이 두 번째 아이템 보다 크면 1을 반환
      if(*a > *b) return 1;
      else
         if(*a == *b) return  0;         // 같으면 0을 반환
         else         return -1;         // 두 번째 아이템이 더 크면 -1 반환
   }

   // qsort()를 이용한 예
   void QSortExample()
   {
      float field[100];

      ::randomize();                     // 랜덤 번호 생성 초기화
      for(int c=0;c<100;c++)             // 필드의 모든 요소를 랜덤으로 생성
         field[c]=random(99);

      // qsort를 이용한 소팅
      qsort((void*) field, /*아이템의 수*/ 100, /*아이템의 크기*/ sizeof(field[0]),
            /*비교 함수*/ CmpFunc);

      // 소팅된 필드의 첫 10개의 요소들을 출력
      printf("The first ten elements of the sorted field are ...\n");
      for(int c=0;c<10;c++)
         printf("element #%d contains %.0f\n", c+1, field[c]);
      printf("\n");
   }

//----------------------------------------------------------------------------------
   // 3.5 예제 A: 파라미터를 이용한 멤버 함수의 콜백
   // Task: 'DoItA" 함수는 'Display' 멤버 함수에 대한 콜백을 가지고 무언가를 한다.
   // 따라서 랩퍼 함수 'Wrapper_To_Call_Display'가 사용된다.  

   #include <iostream.h>   // cout 때문에 포함

   class TClassA
   {
   public:

      void Display(const char* text) { cout << text << endl; };
      static void Wrapper_To_Call_Display(void* pt2Object, char* text);

      /* TClassA의 다른 부분들 */
   };

   // static 랩퍼 함수가 Display() 멤버 함수를 콜백할 수 있다.
   void TClassA::Wrapper_To_Call_Display(void* pt2Object, char* string)
   {
       // TClassA로의 명시적 캐스팅
       TClassA* mySelf = (TClassA*) pt2Object;

       // 멤버 함수 호출
       mySelf->Display(string);
   }

   // 함수는 콜백을 가지고 무엇인가를 수행한다.
   // note: 물론 이 함수 또한 멤버 함수일 수 있다.
   void DoItA(void* pt2Object, void (*pt2Function)(void* pt2Object, char* text))
   {
      /* 무엇 인가 수행 */

      //콜백
      pt2Function(pt2Object, "hi, i'm calling back using a argument ;-)");
   }


   // 예제 코드 수행
   void Callback_Using_Argument()
   {
      // 1. TClass의 오브젝트 인스턴스 생성
      TClassA objA;

      // 2. <objA>에 대한 'DoItA' 호출
      DoItA((void*) &objA, TClassA::Wrapper_To_Call_Display);
   }

//---------------------------------------------------------------------------------
   // 3.5 예제 B: 전역 변수를 이용한 콜백
   // Task: 'DoItB'는 'Display' 멤버 함수에 대한 콜백을 가지고 무엇인가를 수행한다.
   //       따라서 'Wrapper_To_Call_Display' 랩퍼 함수가 사용된다. 

   #include <iostream.h>   // cout 때문에 포함

   void* pt2Object;        // 임의의 오브젝트를 가르키는 전역 변수 

   class TClassB
   {
   public:

      void Display(const char* text) { cout << text << endl; };
      static void Wrapper_To_Call_Display(char* text);

      /* TClassB의 나머지 부분 */
   };


   // static 랩퍼 함수가 Display() 멤버 함수를 콜백할 수 있다.
   void TClassB::Wrapper_To_Call_Display(char* string)
   {
       // 전역 변수 <pt2Object>를 TClassB로 명시적 캐스팅
       // 주의: <pt2Object>는 반듯이 적절한 오브젝트를 가크리고 있어야 한다!
       TClassB* mySelf = (TClassB*) pt2Object;

       // 멤버 호출
       mySelf->Display(string);
   }

   // 함수는 콜백을 이용해서 무언가를 한다.
   // note: 물론 이 함수는 멤버 함수일 수도 있다.
   void DoItB(void (*pt2Function)(char* text))
   {
      /* 어떤 작업을 수행 */

      // 콜백
      pt2Function("hi, i'm calling back using a global ;-)");
   }


   // 예제 코드 수행
   void Callback_Using_Global()
   {
      // 1. TClassB 오브젝트의 인스턴스 생성
      TClassB objB;

      // 2. static 랩퍼 함수에서 사용될 전역 변수에 인스턴스 대입
      // 중요: 이 것을 절대 잊지 마라
      pt2Object = (void*) &objB;


      // 3. <objB>를 위한 'DoItB' 호출
      DoItB(TClassB::Wrapper_To_Call_Display);
   }

//-------------------------------------------------------------------------------
   // 4.2 Functor 구현

   // abstract base class
   // [alones] 멤버 함수가 모두 순수 가상 함수 (pure virtual function)
   class TFunctor
   {
   public:

      // 멤버 함수를 호출할 두 가지 가능한 함수들
      // 가상 함수들을 통해서 오브젝트에 대한 포인터와 멤버 함수에 대한 [[br]]
      // 포인터를 사용할 상속 받은 클래스들이 함수 콜을 쓸 수 있다.
      virtual void operator()(const char* string)=0;  // 연사자를 이용한 호출
      virtual void Call(const char* string)=0;        // 함수를 이용한 호출
   };


   // 상속 받은 템플릿 클래스
   template <class TClass> class TSpecificFunctor : public TFunctor
   {
   private:
      void (TClass::*fpt)(const char*);   // 멤버 함수에 대한 포인터
      TClass* pt2Object;                  // 오브젝트에 대한 포인터

   public:

      // 생성자 - 오브젝트에 대한 포인터와 멤버 함수에 대한 포인터를 취하며 [[br]]
      //          그 것들을 두 개의 prviate 변수에 저장한다.
      TSpecificFunctor(TClass* _pt2Object, void(TClass::*_fpt)(const char*))
         { pt2Object = _pt2Object;  fpt=_fpt; };

      // 연산자 "()" 재정의
      virtual void operator()(const char* string)
       { (*pt2Object.*fpt)(string);};              // 멤버 함수 수행

      // "Call" 함수 재정의 
      virtual void Call(const char* string)
        { (*pt2Object.*fpt)(string);};             // 멤버 함수 수행
   };

//----------------------------------------------------------------------------------
   // 4.3 Functor 사용 예

   // 더미 클래스 A
   class TClassA{
   public:

      TClassA(){};
      void Display(const char* text) { cout << text << endl; };

      /* TClassA의 나머지 부분*/
   };

   // 더미 클래스 B
   class TClassB{
   public:

      TClassB(){};
      void Display(const char* text) { cout << text << endl; };

      /* TClassB 나머지 부분 */
   };


   // main 프로그램
   int main(int /*argc*/, char* /*argv[]*/)
   {
      // 1. TClassA와 TClassB에 대한 인스턴스 생성
      TClassA objA;
      TClassB objB;


      // 2. TSpecificFunctor 인스턴스 생성 ...
      //    a ) TClassA의 오브젝트와 멤버에 대한 포인터를 은닉한 functor
      TSpecificFunctor<TClassA> specFuncA(&objA, &TClassA::Display);

      //    b ) TClassB의 오브젝트와 멤버에 대한 포인터를 은닉한 functor
      TSpecificFunctor<TClassB> specFuncB(&objB, &TClassB::Display);


      // 3. 베이스 클래스인 TFunctor에 대한 포인터의 배열 생성하고 초기화
      TFunctor* vTable[] = { &specFuncA, &specFuncB };


      // 4. 오브젝트 필요 없이 멤버 함수 호출을 위해 배열 사용
      vTable[0]->Call("TClassA::Display called!");        // "Call" 함수를 통해서
      (*vTable[1])   ("TClassB::Display called!");        // 연사자 "()"을 통해서


      // 종료를 위해 enter 키 치기
      cout << endl << "Hit Enter to terminate!" << endl;
      cin.get();

      return 0;
   }