강좌

Hitel에 있던 강좌 중 일부입니다.

제목 :[강좌] Template (틀)

<1.틀 이란?>=====================================================
우리는 C++이 똑같은 이름을가진 함수들의 사용을 허용한다고 알고있
읍니다. 즉, 중복을 허용한다는 이야기지요. 그러나, 아래의 예를 봅
시다.

   dad(int,int)       ;        ----------->(1)
   dad(double,double); ----------->(2)
   dad(char,char);         ----------->(3)

위에서 보면 아시겠지만, 인자형들이 모두 다릅니다. 만일 , dad라
는 함수가 하는일이 위의 3가지 모두 기억장소를 해제하는 기능을 한
다고 가정합시다. 즉, (1), (2), (3) 모두 하는일은 같다고 가정하자
는 말입니다. 그런데, 위처럼 단지, 인자형을 구별하여 입력받을 필요
성이 있을때, 선언과 정의를 위처럼 3가지로 각각해주어야하는 불편이
있읍니다. 얼마나 시간낭비이고, 에너지 낭비입니까? 이것은 지적노동
이 아니라, 단순육체노동이라 할수 있읍니다. 불편하지요? 이때 "틀"
을 사용하면 되는 것입니다. 즉, 인자형을 하나의 변수로 잡고 사용하
는 것이지요.. 즉,

   dad(F,F);

위처럼 인자형을 위한 변수 F를 지정해놓고 F대신에 int를 넣으면,
(1)처럼 되는 것이고, F대신에 double를 넣으면, (2)처럼 되는것이지
요. 여기서 F는 인자형을 담는 그릇임을 알수 있읍니다. 얼마나 간편
하고 편리한 기능입니까? 이것을 바로 template(틀)이라고 합니다.

<2. 함수틀>======================================================
함수틀은 위에서 보인 예와같은 경우를 말합니다. 형식은 다음과 같습니다.

  template <틀인자들> 형 함수틀이름 (인자들) {함수본체}

  template    F     babo    (F x,F y) { .... }   // 예(1)

  <틀인자들> : 인자형을 대신할 변수들. 예(1)에서 보면 그 부분에
                 가 들어가 있지요? 여기서 class는 일종의
                기호일뿐 클래스를 의미하지는 않습니다. 단지, 틀인
                자임을 나타내는 기호입니다.

   형        : 리턴값이 있는 함수는 그 리턴값의 자료형을 써주면
               됩니다. 예(1)에서 F를 써준것은, F라는 그릇에 담겨
               있는 자료형을 리턴값으로 한다는 이야기지요. 예를
               들어 F라는 그릇에 int가 들어있으면, int형 값이 리
               턴이 된다는 이야기지요... 만일 리턴값이 없을때는
                void를 써주면 되겠습니다.

  함수틀이름 : 그냥 보통 함수이름처럼 아무이름이나 붙여주면 됨.
  (인자들)   : 인자들은 틀인자들에 있는것들을 자료형으로하는 인자
                   들을 말합니다. (예1)에서는 F형 인자들이 있지요? x와 y
                   말입니다.

  { .... }   : 이것은 F형 인자를 사용한 함수 본체로써 일반 함수에
               서 처럼 작성하시면 됩니다.

다시 <틀인자들>에 대해 자세히 알아봅시다. 규칙이 있습니다.
    +-----------------------------------------------------+
    | template                                                                       |
    | F babo(F x,E y);             // 옳게된 경우                          |
    |                                                                                     |
    | template                                                                       |
    | F babo(E x,E y);             // 틀린경우 (1)                         |    (예2)
    +-----------------------------------------------------+
1. 하나이상의 틀인자를 사용할수 있는데, 그들사이의 구별은 함수에
   서의 인자리스트들간의 구별에서처럼 ','을 사용한다.
2. <틀인자들>에 선언된 틀인자들은 최소한 한번이상은 함수틀의 인
    자리스트 중에 나타나야 한다.
3. 모든 틀인자들 앞에는 class라는 기호를 붙여야 한다.
4. extern, static, inline 와같은 예약어들은 <틀인자들>다음에 위
    치한다.
5. 틀은 template가 선언된곳부터 함수끝까지를 범위로 갖는다. 따라
    서 처음에 설명한 (예1)처럼 해도 좋고, (예2)에서처럼 여러줄로
    해도 좋다. 취향에 맞게 선택해라.

위 예(2)에서 (1)은 왜 틀렸을까요? 규칙 2번을 만족하지 못했기 때
문입니다. 즉, F는 인자리스트중에 쓰이지 않고 있지요? 그래서 틀린
것입니다.
이제 구체적인 소스를 올려드리죠..

/******************************
      함수틀을 위한 소스
******************************/

#include

template
F sub(F x,F y)
{
     F z;                  // F형이 함수내부에서 사용된 예
     z=x+y;
     return z;
}

template F func(F x,E y) { return (x+y); }
                                            // 한줄로 쓴 예 (5)
void main()
{
     printf("%d\n",sub(3,4));                //(1)
     printf("%5.2f\n",sub(5.5,6.8));        //(2)
     printf("%d\n",func(4,5.4));            //(3)
     printf("%5.2f\n",func(3.3,7));         //(4)
}

/*************************************************************/
위 소스를 살펴보지요..
첫번째 함수틀인 sub()는 여러줄로 틀을 만든경우이고, 두번째 함수
틀인 func()는 한줄로 틀을 만든 경우입니다. 취향에 맞는것을 각자가
알아서 골라쓰세요..
sub()내부에 F로 선언된 z가 쓰이고 있읍니다. 만일, F라는 그릇속에
int가 들어 있다면, z는 int형이 되는 겁니다.
func()함수를 봅시다. 좀 헤깔리시죠? 여기서 <틀인자들>을 두종류(F
와 E)로 쓴이유는 서로다른형의 인자를 받아들일경우를 위해서 사용한
것입니다. 즉, (3)과 (4)를 보세요. (3)은 func(int,double)의 형태를
가지고 있지요? (4)는 func(double,int)의 형태를 가지고 있습니다.
즉, 서로다른 형을 가지고 있다는 이야기 입니다. 그리고, func()정의
부를 보면 <틀인자들>다음에 F형을 지정하고 있지요? 즉, func이름 앞
에 F말입니다. 이것은 결과값의 자료형을 나타냅니다. 이것에 대해서
따로 설명 드리겠읍니다.
우선 실행시켜 보세요..

------ 컴파일러가 자료형을 구별하는 법 -------
위에서 보여드린 소스중 func(F x,E y)를 예로 들지요..

만일 func()를 사용할때 func(3,3)이라고 하면 이것은 func(int,int)
의 형태를 하고 있지요? 그리고, func(2.2,4)라고 하면 이것은
func(double,int)의 형태를 하고 있습니다.

첫번째의 경우 F와 E에 모두 int가 들어갑니다.
두번째의 경우 F에는 double가, E에는 int가 들어갑니다.
그럼, 어떻게해서 이렇게 들어갈수 있을까요?

컴파일러는 우선 func(2.2,4)을 분석을 합니다. 여기서 첫번째 인자
의 내용을 살펴보고, double형임을 알아낸후 func(F,E)로 가서 F대신
에 double를 넣습니다. 다시 func(2.2,4)를 분석하여 두번째 인자인 4
가 int형임을 알아내고, func(F,E)로 가서 E대신에 int를 넣습니다.
그래서 그 과정이 끝난후에는 F는 double로 , E는 int로 취급이 되는
겁니다.

정리를 하면, 컴파일러는 어떠한 함수가 구체적으로 사용된
지점에서 가지고있는 형식인자의 자료형을 자체적으로 검사한후 검사
한 결과를 함수의 정의부에와서 그 인자부분에 각각 넣는 것입니다.

즉, func(F,E)라고 했을때 컴파일러는 아직 func(F,E)에서 F와 E가 어
떤 자료형을 가질지 모르고 있으며, 그 func()가 구체적으로 사용될 때
쓰여진 인자를 검사해서 그 결과를 알아내는 것이죠. 위 소스의 func()
를 보면, (3)에서 F 는 int가 되며, E는 double가 됩니다.

아까 <틀인자들>뒤에 F가 붙은 이유를 설명하다 말았지요?
결과값이 F형이라는 이야기 말입니다.
(3)에서 비로소 F가 int형이라는 것을 알고는 결과값
을 F대신에 int로 인식을 하는 것입니다. 실행해보시면, 아시겠지만,
결과가 double형이 나와야 정상(double + int == double) 이지만, 결
과형이 int형이므로 int형으로 변환된 상태가 출력이 됩니다.

일반적으로 함수틀을 사용하게 되면, 위와같은경우 F대신에 int가 들
어간다는것을 컴파일러가 알게되면, 컴파일러는 자체적으로 F대신에
int가 쓰인 함수를 만듭니다. 그래서 우리가 여러 개의 함수를 만들것
을 컴파일러가 대신 만들어주므로 우리의 수고를 덜어줄 수 있는 것이지
요.

한편 함수틀도 중복이 가능한데.. 다음예와 같습니다.

template F babo(F,F);
template F babo(F,F,F,char);

만일 ,함수틀끼리 중복하는 것이 아니라, 일반함수와 중복할 경우는 그
일반함수는 같은화일에 존재해야 한다.

또 한편, 다음 예를 봅시다.

template F babo(F x,F y) { ... }   // 정의
babo(1,4.6);       // 오류 (1)

위와 같이 했을 경우 오류가 발생합니다. 왜냐면, babo()에 대입할 두
인자형이 같아야 합니다. 정의부분에서 babo()함수를 보세요.   2개의
인자 모두 F형임을 알수 있습니다.

F에 저장된 자료형이 int형이었다면, 2개의 인자의 자료형은 모두 int형이
되는 것입니다.   (1)과 같은경우는 인자형이 하나는 int형이고 다른하나는
double 이므로, 오류가 발생한다는 이야기입니다.
이때 이를 해결하기 위해서, 다음과 같이 합니다.

template F babo(F x,F y) { ... }   //틀 정의
double babo(double,double);     // 틀을 확장
babo(1,4.6);                    // 정상
babo(2,2);                       // 정상
babo(2.3,4.1);                  // 정상

위에서 보듯이 틀을 확장하는 방법이 있습니다. 즉, babo에 쓰일 두개
의 인자형이 서로 다를수 있다는것이 예상된다면, 위와같이 다시한번,
확장을 해주는 것입니다. 위의 예는 다음과 같이 해도 결과는 같습니다.

template F babo(F x,F y) { ... } // 틀 정의
int babo(int,int);        // 틀확장

"그럼, 왜 아까 소스에서의 (5)처럼 하지않고 구테여 이처럼 하냐 임
마!" 라고 하는 분은 그래도 열심히 하는 분입니다. 답은 이렇습니다.
방금 설명한것처럼하면 함수를 수행한후 결과값을 리턴할때 유연성이
있다는 것입니다.

즉, int형 결과가 나왔으면, int형으로 리턴이되고,
double형의 결과가 나왔으면, double형으로 리턴이 됩니다. 그러나,
위 소스의 (5)처럼 했을경우 F의 값에대해서만 리턴이 되므로, 값에대
한 상당한 오차가 있을수 있읍니다. 즉, 만일 결과는 double형인데, F
가 int형 이었다면, 소수점 이하 부분은 잘려나가고, 소수점 이상부분
만이 리턴이 되는 것이지요.. 이런 경우 상당한 위험성이 도사리고 있
기 때문에,, 방금설명한 방법을 사용하는 것이 더 좋을듯 싶습니다.

<3. 클래스 틀> ==================================================
함수틀의 경우와 거의 같지만, 몇가지 주의해야할 사항과 차이점이
존재합니다. 우선 클래스틀을 만들기 위한 형식을 알아봅시다.
+------------------------------------------------+
| template<틀인자들>                                             |
| class 클래스틀명 {                                               |
|       ....                                                                  |
| };                                                                        |
|                                                                             |
+------------------------------------------------+
| template                                                               |
| class tong {                                                          |
|        F x;                                                                |
| public:                                                                  |
|        tong(int p=0) { x=p; }                                      |
|        F sub(F i,F j) { x=i+j; return x; }                       |
|        F func(F m,int n) { return m+n; }                      |
|        F tmp() { return x; }; // (1)                             | (예3)
| };                                                                        |
+------------------------------------------------+
  위 예를 보면 상당히 이해하기 쉬울겁니다. 거의 일반 클래스와 비
슷하지요? 단지, 맨위에 template(class F>이 쓰였다는것과 여기서 지
정한 틀인자 F를 사용해서 멤버와 멤버함수를 구성했다는것만 틀리지
요..

여기서 유념해야할것은 (1)입니다. 즉, 함수틀처럼 사용되고 있지
만, 함수틀에서의 규칙하나를 어기고 있음을 알수 있읍니다. 즉, 지정
된 F가 함수틀 인자리스트에 한번도 사용되지 않았다는 겁니다. 이것
은 함수틀 규칙2번에 위배되는 것임니다. 그럼에도 불구하고, 에러는
하나도 나지 않습니다. 이것이 일반 함수틀과 클래스틀에 사용된 멤버
함수틀과의 차이점입니다. 즉, 인자로써 한번도 사용않되도 상관 없다
는 이야기지요.

위에서 보여드린 '형식'을 봅시다.
<틀인자들> : 함수틀에서의 <틀인자들>과 의미는 같다. 하지만, 함수
              틀인경우는 반듯이 class를 앞에 부여주어야 하지만,
              여기서는 class외에 int, double와 같은 일반 자료형을
              사용한 틀인자들을 넣어줄수도 있다. 만일 int로 틀인
              자를 선언했다면, class기호를 사용한 변수처럼 "인자
              형을 담는 그릇"이 되는것이 아니라, "값을 담는 그릇"
              이 된다.

class : 클래스임을 알리는 예약어로써 일반적인 의미이며, <틀
인자들>에 쓰이는 class기호와는 성격이 다름

클래스틀명 : 일반적인 클래스처럼 아무이름이나 붙여도 좋다.

-------- 클래스틀의 구체적인 변환 --------

함수틀과는 완전히 다른 방식입니다. 함수틀인경우 컴파일러가 그 함
수가 쓰인곳의 인자들을 자체적으로 분석하여 <틀인자들>대신에 그 검
사결과를 넣어주지만, 클래스틀인 경우는 프로그래머가 직접 그 자료형
을 써주어야 합니다. 왜냐면, 함수틀인경우는 거기에 쓰인 '인자'를
검사하여 구별할수 있지만, 클래스인경우는 검사할 '인자'가 없기 때
문입니다. 따라서, (예3)을 예로 들자면,,,, 그 클래스를 사용할때 다
음처럼 해야 합니다.

  tong x;        // <틀인자>를 int형으로하고, 변수 x를 선언
  tong y;     // <틀인자>를 double형으로 함.
  x.sub(3,3);         // int형으로 변환된 클래스로 sub()를 참조

즉, < > 에다가 프로그래머가 원하는 자료형을 넣어서 컴파일러에게
알려주는 것입니다.
이제까지 설명한 내용들을 정리한다는 의미에서 소스를 올려드리죠..

/******************************
    클래스틀을 위한 소스
*******************************/

#include
#include

template
class tong {
       F x;
       public:
           tong(int p=0) { x=p; }         //초기화
           F sub(F i,F j) { x=i+j; return x; } // F형 함수
           F func(F m,int n) { return m

+n; } // 인자형이 틀린것
           F tmp() { return x; } // (1)   // 인자가 없는것
};

template     // 값이 대입되는 클래스틀
class lupin2 {
       public:
       int x;
       T sub() {
          x=F;             // F값이 x에 대입된다.
          return x;
          }
};

void main()
{
   clrscr();
   tong x;        // <틀인자>를 int형으로하고, 변수 x를 선언
   tong y;     // <틀인자>를 double형으로 함.
   lupin2 z;
   printf("%d\n",x.sub(3,3)); // int형으로 변환된x로 sub()를 참조
   printf("%4.2f\n",y.func(3.5,1));
   printf("%d %3.1f\n",x.tmp(),y.tmp());
   printf("%d\n",z.sub());
}

/***************************************************************/
설명은 필요없을것 같네요.. 이제까지 입이 닳도록 해드렸으니까..

한편, 클래스틀에서도 static멤버와 static함수가 있을수 있읍니다.
형식은 일반 클래스와 비슷합니다. satatic멤버의 경우 일반 멤버에서
는 클래스 밖에서 따로 정의를 해 주었지요? 클래스틀에서도 마찬가지
입니다. 다음이 예입니다.

  template
  class tong {
        static int x;
  };
  template int tong::x=0;

즉, static변수 x를 0으로 초기화 시켜주는 것입니다.

이상으로 간단하게나마,, <틀>의 강좌를 마칩니다.