31-1-나.구체화

함수 템플릿은 어디까지나 함수를 만들기 위한 형틀에 지나지 않으며 그 자체가 함수인 것은 아니다. 컴파일러는 함수 템플릿 정의문으로부터 앞으로 만들어질 함수의 모양만 기억하며 실제 함수가 호출될 때 타입에 맞는 함수를 작성한다. 함수 템플릿으로부터 함수를 만드는 과정을 구체화 또는 인스턴스화(Instantiation)라고 하는데 호출에 의해 구체화되어야만 실제 함수가 만들어진다. 존재하는 모든 타입에 대해 함수를 미리 만들어 놓는 것이 아니다.

이때 함수 템플릿으로부터 만들어지는 함수를 템플릿 함수라고 한다. 용어가 비슷해서 다소 헷갈리는데 둘 다 뒤쪽에 강세를 두고 읽으면 실체 파악이 쉽다. 함수 템플릿은 함수를 만들기 위한 템플릿이고 템플릿 함수는 템플릿으로부터 만들어지는 함수이다. 배열 포인터, 포인터 배열 등의 용어도 마찬가지인데 한국말은 대체로 뒤쪽 단어에 진짜 뜻이 있으며 끝까지 들어 봐야 무슨 말인지 알 수 있다. 용어 중간에 서술어를 넣어서 이해하면 잘 외워진다.

컴파일러가 템플릿으로부터 함수를 구체화를 하는 방법은 사람의 몸으로 떼우기 작전과 사실상 동일하다. 소스를 분석하는 중간 단계에서 템플릿의 정의를 잘 기억해 두었다가 호출되는 함수들을 템플릿으로부터 일일이 생성해 낸다. 호출부의 인수를 보고 주인님이 뭘 원하는지 알아내며 템플릿에 이 재료를 집어 넣어 함수를 찍어내는 것이다. 사람이 해야 할 잡다한 작업을 컴파일러가 대신하는 것 뿐이다.

만약 템플릿만 정의하고 함수를 호출하지 않으면 아무런 일도 일어나지 않으며 템플릿 자체는 메모리를 소모하지 않는다. 마치 붕어빵틀이 붕어빵이 아니어서 먹을 수도 없고 재료를 소모하지 않는 것과 마찬가지이다. 호출에 의해 템플릿이 구체화되어 실제 함수가 될 때만 프로그램의 크기가 늘어난다. 호출되지도 않는 함수를 만들 필요는 전혀 없는 것이다. 템플릿만 선언해 놓고 비주얼 C++로 맵 파일을 만들어서 확인해 보면 과연 그렇다는 것을 확인할 수 있다.

SwapTemp 예제를 통해 템플릿 함수가 구체화되는 것을 확인해 보자. main에서 정수, 실수, 문자, 구조체 등 각각의 타입으로 Swap 함수를 호출하는데 이때마다 컴파일러는 Swap 함수 템플릿을 참조하여 실인수의 타입에 맞는 실제 Swap 함수를 구체화한다. 이 예제의 경우 네가지 버전의 함수가 구체화될 것이다.

맵 파일을 만들어 확인해 보면 과연 4개의 Swap 함수가 작성되어 있음을 눈으로 직접 확인할 수 있다. 맵 파일(Map File)은 함수나 변수가 어느 주소에 배치되었는지에 대한 일종의 컴파일 결과 보고서인데 프로젝트 설정 페이지의 링크 탭에서 옵션을 선택하면 Debug 디렉토리에 *.map 파일로 생성된다. 물론 long, short, char *, float 등등 다양한 타입에 대해 Swap 함수를 호출하면 더 많은 Swap 함수들이 생성될 것이다.

0001:000001b0 ?Swap@@YAXAAH0@Z 004011b0 f i SwapTemp.obj

0001:00000200 ?Swap@@YAXAAN0@Z 00401200 f i SwapTemp.obj

0001:00000260 ?Swap@@YAXAAD0@Z 00401260 f i SwapTemp.obj

0001:000002b0 ?Swap@@YAXAAUtag_st@@0@Z 004012b0 f i SwapTemp.obj

컴파일러에 의해 구체화된 함수는 실행 파일에 실제로 존재하며 컴파일 단계에서 미리 만들어지므로 실행시의 부담은 전혀 없다. 함수가 호출될 때 만들어지는 것이 아니다. 대신 매 타입마다 함수들이 새로 만들어지므로 구체화되는 수만큼 실행 파일의 용량이 늘어난다. 템플릿은 크기를 포기하는 대신 속도를 얻는 방식인데 크기와 속도는 항상 반비례 관계에 있다.

타입만 다른 함수들을 직접 복사해서 정의하는 방법과 함수 템플릿을 정의한 후 컴파일러가 구체화하도록 하는 것과는 어떤 차이점이 있을까? 일단은 반복되는 부분이 통합되므로 소스 길이가 짧아지고 수정할 필요가 있을 때 템플릿만 수정하면 된다. 따라서 관리하기 편리해진다는 이점이 있으며 이후 임의의 타입에 대한 함수를 새로 구체화하는 것도 컴파일러가 알아서 하므로 확장성도 훨씬 더 좋다.

더 이상 사용하지 않는 함수를 삭제하는 것도 컴파일러의 몫이다. Swap(c, d) 호출문을 삭제하고 재컴파일해 보면 Swap(double, double) 함수는 다시 생성되지 않음을 확인할 수 있다. 그러나 함수 템플릿을 쓴다고 해서 실행 파일의 크기가 작아지는 것은 아님을 유의하자. 구체화되는 함수들은 각자가 메모리를 따로 차지하므로 실행 파일의 크기면에서는 별다른 이점이 없다. 복사해서 수정하는 방법과 똑같이 메모리를 차지한다. 이런 면에서 볼 때 템플릿보다는 오히려 SwapVoid 예제의 방식이 메모리 절약면에서는 유리한데 SwapVoid는 어떤 타입에 대해서건 함수는 딱 하나밖에 생성되지 않는다.

명시적 인수 지정

컴파일러는 호출부의 실인수 타입을 판별하여 필요한 함수를 구체화하는데 예를 들어 Swap(a, b)는 a, b가 정수이므로 Swap(int, int) 함수를 구체화할 것이고 Swap(c, d)는 c, d가 실수형이므로 Swap(double, double) 함수를 구체화할 것이다. 템플릿 타입 정의에 의해 두 인수의 타입은 같아야 하므로 SwapTemp 예제에서 Swap(a, c)는 두 인수의 타입이 int, double로 달라 에러로 처리된다. Swap(a, c) 호출에 대해 Swap(double, double) 함수를 구체화하고 a를 double로 암시적 변환해서 호출할 수도 있을 것 같지만 템플릿은 타입이 정확해야 하므로 암시적 변환까지는 고려하지 않는다.

상수는 변수와 달리 그 형태만으로 타입을 정확하게 판단하기 힘든 경우가 있다. 그래서 템플릿 함수를 호출할 때 실인수와는 다른 타입을 강제로 지정할 수 있는데 이때는 함수명 다음의 < > 괄호안에 원하는 타입을 밝힌다. 다음 템플릿 함수는 큰 값을 조사한다.

template <typename T>

T Max(T a, T b)

{

return (a > b) ? a:b;

}

Max(3, 4)는 두 인수가 정수형이므로 Max(int, int) 함수를 구체화하여 호출할 것이다. 그러나 Max<double>(3, 4)로 호출하면 실인수 3, 4가 정수형 상수지만 산술 변환되어 Max(double, double) 함수가 호출된다. 물론 Max(3.0, 4.0)이라고 호출해도 마찬가지이다. 정수형 변수 둘에 대해 실수형 Max를 호출하고 싶으면 Max((double)a, (double)b)로 캐스트 연산자를 사용할 수도 있다.

리턴 타입이나 인수로 직접 사용되지 않는 타입을 가지는 함수를 호출하기 위해서는 명시적으로 템플릿의 인수 타입을 지정해야 한다. 리턴 타입은 호출할 함수를 결정할 때는 사용되지 않으며 또한 인수로 전달되지 않고 함수 내부에서만 사용하는 타입도 함수 호출문에는 나타나지 않는다. 이럴 때는 컴파일러가 함수 호출문만으로 구체화할 함수를 결정할 수 없으므로 어떤 타입의 템플릿 함수를 원하는지를 분명히 지정해야 한다.

예 제 : TempReturn

#include <Turboc.h>

#include <iostream>

using namespace std;

template <typename T>

T cast(int s)

{

return (T)s;

}

template <typename T>

void func(void)

{

T v;

cin >> v;

cout << v;

}

void main()

{

unsigned i=cast<unsigned>(1234);

double d=cast<double>(5678);

printf("i=%d, d=%f\n",i,d);

func<int>();

}

cast는 인수로 전달된 s를 템플릿 인수가 지정하는 타입으로 캐스팅하는 함수이다. cast(1234) 호출문만으로는 어떤 버전의 함수를 만들지 결정할 수 없으므로 명시적으로 인수를 밝혀서 호출해야 한다. 1234라는 상수는 cast의 정수형 인수로 고정되어 있을 뿐이지 T를 결정하는데는 사용할 수 없다. 이 예제의 경우 unsigned cast(int), double cast(int) 두 버전의 함수가 구체화되는데 이 두 함수는 이름이 동일하고 인수 목록까지 같으므로 오버로딩 조건을 만족하지 못한다. 이처럼 리턴 타입만 다른 경우라도 템플릿에 의해 각각 따로 구체화될 수는 있지만 호출할 때 어떤 함수를 호출하는지를 반드시 밝혀야 한다.

그냥 cast(1) 이라고 호출해 버리면 어떤 함수를 원하는지 결정할 수 없어 모호하므로 에러로 처리된다. 1234라는 정수 상수를 unsigned형으로 캐스트하고 싶다면 cast<unsigned>(1234)로 호출하고 5678이라는 정수 상수를 double 타입으로 캐스트하려면 cast<double>(5678)로 호출한다. cast라는 템플릿 이름만으로는 정보가 부족하다.

func 함수는 내부적인 처리를 위해 T형의 지역변수 v를 선언하여 사용한다. 물론 T가 가변적인 타입이므로 본체는 전달된 모든 타입에 대해 가능한 코드만 사용해야 한다. func는 인수도 리턴값도 없으므로 호출부만 봐서는 도대체 어떤 함수를 구체화할 지 전혀 결정할 수 없다. 따라서 func()라고 호출하면 컴파일러는 뭘 원하는지 어리둥절해 할 것이다. 이때도 func<int>() 처럼 지역변수 v의 타입을 명시적으로 전달해야 한다.

리턴 타입만 다른 템플릿이나 알지도 못하는 타입의 지역변수를 선언하는 함수는 그다지 실용성이 없어 보이고 저런 걸 어디다 쓸까 싶지만 호환되는 여러 가지 타입의 객체 중 원하는 것을 선택해서 대신 생성해 주는 래퍼 함수를 만들고 싶을 때 이런 기법이 가끔 사용되기도 한다. STL을 연구하다 보면 이런 함수를 실제로 볼 수 있는데 그때를 위해 이런 문법도 있다는 것은 기억해 두도록 하자.

명시적 인수 지정 기법은 비슷 비슷한 함수를 여러 벌 만들지 않고 특정한 한 타입에 대해서만 함수를 구체화하고 싶을 때도 아주 실용적이다. 다음 예제를 보자.

예 제 : ExplicitPara

#include <Turboc.h>

template <typename T>

void LongFunc(T a)

{

// 아주 긴 함수의 본체

}

void main()

{

int i=1;

unsigned u=2;

long l=3;

LongFunc(i);

LongFunc(u);

LongFunc(l);

}

LongFunc은 본체가 굉장히 큰 함수이고 길이가 길다고 할 때 int, unsigned, long 각각에 대해 이 함수를 일일이 구체화하면 실행 파일의 용량이 무시못할 정도로 커질 것이다. 이 외에도 int와 호환되는 타입은 char, short, 열거형 등 아주 많은 타입이 있는데 사실 이 타입들은 int와 거의 똑같은 방법으로 처리할 수 있으므로 굳이 본체를 따로 만들 필요까지는 없을 것이다. 이럴 때는 호출문을 다음과 같이 작성하여 구체화되는 함수의 수를 줄일 수 있다.

LongFunc<int>(i);

LongFunc<int>(u);

LongFunc<int>(l);

실인수의 타입에 상관없이 LongFunc(int) 함수만 구체화되며 실인수가 정수로 산술 변환되어 전달된다. 물론 이 경우 정수로 산술 변환되어도 상관없는 실인수만 사용해야 한다.

명시적 구체화

함수의 호출부를 보고 컴파일러가 템플릿 함수를 알아서 만드는 것을 암시적 구체화라고 한다. 개발자가 원하는 타입으로 함수를 호출하기만 하면 나머지는 컴파일러가 다 알아서 하며 호출하지 않는 타입에 대해서는 구체화하지 않는다. 만약 특정 타입에 대한 템플릿 함수를 강제로 만들고 싶다면 이때는 명시적 구체화(Explicit Instantiation)를 하는데 이는 지정한 타입에 대해 함수를 생성하도록 컴파일러에게 지시하는 것이다. 예를 들어 float 타입을 교환하는 함수를 생성하고 싶다면 다음 명령을 사용한다.

template void Swap<float>(float, float);

명시적 구체화 명령의 표기는 일단 키워드 template가 앞에 오고 함수 이름 다음에 생성하고 싶은 타입을 < > 괄호안에 적는다. 이 선언에 의해 float형을 인수로 취하는 Swap(float, float) 함수가 만들어진다. 당연한 얘기겠지만 템플릿이 어떤 모양인지를 알아야 컴파일러가 이런 함수를 만들 수 있으므로 명시적 구체화 명령은 템플릿 선언보다 뒤에 와야 한다.

이 함수가 당장 필요치 않더라도 일단 만들어 놓고 싶다면 명시적 구체화로 강제 생성을 지시할 수 있다. 예를 들어 지금 작성하는 소스에서는 이 함수가 필요치 않지만 컴파일된 라이브러리로 배포하고 싶다면 명시적 구체화를 할 필요가 있다. 그러나 실제 상황에서 이런 경우는 거의 발생하지 않는데 왜냐하면 함수 템플릿 정의문은 보통 헤더 파일에 작성하며 헤더 파일을 배포하기 때문이다. 라이브러리를 사용하는 측에서 헤더 파일을 인클루드하고 Swap(float, float)를 호출하면 그때 컴파일러가 이 함수를 구체화할 것이므로 문제가 되지 않을 것이다.

다만 함수의 내용을 숨기고 싶을 때는 함수 템플릿을 공개할 수 없으므로 이럴 때는 명시적 구체화로 자주 사용할만한 타입에 대해 일련의 함수 집합을 미리 생성해 놓는다. 이 라이브러리의 사용자는 개발자가 명시적으로 구체화해 놓은 함수만 사용할 수 있을 것이다. 명시적 구체화는 컴파일 속도에도 긍정적인 효과가 있는데 미리 필요한 함수를 생성해 놓으면 컴파일러가 어떤 함수를 생성할 것인지를 판단하는 시간을 조금 절약할 수 있다.