C++ Template.

C++ Template.

1.C++ Template

벡터(vector) 는 쉽게 생각하면 가변 길이 배열로 사용자가 배열 처럼 사용하는데 크기를 마음대로 줄이고 늘일 수 있는 편리한 자료형이다. 스택(stack)의 경우 나중에 들어간 것이 먼저 나온다(LIFO - last in first out) 형태의 자료형으로 pop 과 push 를 통해서 여러가지 작업들을 처리할 수 있다. 하지만 한 가지 문제는 담으려고 하는 데이터 타입이 바뀔 때 마다 다른 벡터를 만들어주어야 한다는 점이 있다. 예를 들어서 아래의 Vector 클래스를 살펴본다.

 

class Vector {

	string* data;
	
        int capacity;
	int length;

public:
	// 생성자 
	Vector(int n = 1) : data(new string[n]), capacity(n), length(0) {
	}

	// 맨 뒤에 새로운 원소를 추가.
	void push_back(string s) {
		if (capacity <= length) {
			string* temp = new string[capacity * 2];
			for (int i = 0; i < length; i++) {
				temp[i] = data[i];
			}
			delete[] data;
			data = temp;
			capacity *= 2;

		}
               	data[length] = s;
		length++;

	}
	// 임의의 위치의 원소에 접근.
	string operator[] (int i) {
		return data[i];

	}
	// x 번째 위치한 원소를 제거.
	void remove(int x) {
		for (int i = x + 1; i < length; i++) {
			data[i - 1] = data[i];

		}
		length--;

	}
	// 현재 벡터의 크기를 구한다.
	int size() {
		return length;

	}
	~Vector() {
		if (data) {
			delete[] data;


		}

	}

};

위 Vector 클래스의 경우 string 데이터 밖에 저장할 수 없다. 만일 사용자가 int 를 원한다면 어떻게 될까? Or char 데이터를 담고 싶다면 어떻게 할까? 물론,각각의 경우에서 코드만 살짝 살짝 바꿔주면 될 것이다. 예를 들어서 char 을 담는 Vector 의 경우

class Vector {

	char* data;

	int capacity;

	int length;

public:

	// 생성자 

	Vector(int n = 1) : data(new char[n]), capacity(n), length(0) 

	}

	// 맨 뒤에 새로운 원소를 추가.

	void push_back(char s) {

		if (capacity <= length) {

			char* temp = new char[capacity * 2];

			for (int i = 0; i < length; i++) {

				temp[i] = data[i];

			}

			delete[] data;
			
                        data = temp;

			capacity *= 2;


		}

		data[length] = s;

		length++;

	}

	// 임의의 위치의 원소에 접근.
	char operator[] (int i) {

		return data[i];

	}

	// x 번째 위치한 원소를 제거.

	void remove(int x) {

		for (int i = x + 1; i < length; i++) {

			data[i - 1] = data[i];

		}

		length--;

	}
	// 현재 벡터의 크기를 구한다.

	int size() {


		return length;


	}

	~Vector() {



		if (data) {



			delete[] data;


		}


	}


};

위와 같이 string 부분만 살짝 char 로 바꿔주면 된다. 하지만 이는 큰 낭비다. 위 char 을 보관하는 vector 와 string 을 보관하는 vector 의 코드는 단순히 string 부분이 char 로 바뀐 차이 밖에 없다. 나머지 부분은 정확히 일치한다. 쉽게 말해서 우리가 T 라는 타입의 객체들을 보관하는 vector 를 만들고 싶을 경우

class Vector {


	T* data;

	int capacity;

	int length;



public:

	// 생성자 


	Vector(int n = 1) : data(new T[n]), capacity(n), length(0) {


	}


	// 맨 뒤에 새로운 원소를 추가.


	void push_back(T s) {


		if (capacity <= length) {


			T* temp = new T[capacity * 2];

			for (int i = 0; i < length; i++) {


				temp[i] = data[i];


			}

			delete[] data;

			data = temp;

			capacity *= 2;


		}


		data[length] = s;

		length++;



	}

	// 임의의 위치의 원소에 접근.

	T operator[] (int i) {


		return data[i];


	}


	// x 번째 위치한 원소를 제거.

	void remove(int x) {

		for (int i = x + 1; i < length; i++) {

			data[i - 1] = data[i];


		}

		length--;

	}


	// 현재 벡터의 크기를 구한다.

	int size() {


		return length;


	}

	~Vector() {

		if (data) {

			delete[] data;

		}

	}

};

int 를 담는 vector 가 필요할 경우 T 를 int 로 바뀌면 되고, string 을 담는 것이 필요하다면 T 가 string 으로 바꾸면 된다. 즉 컴파일러가 T 부분에 우리가 원하는 타입으로 채워서 코드를 생성해주면 엄청 편할 것이다. 2.C++ template part2 사용자가 원하는 작업을 C++ 에서는 template 이라는 이름으로 지원하고 있다. 즉 어떠한 물건을 찍어내는 틀 이라고 생각하면 된다. C++ 에서도 정확히 같은 의미로 사용되고 있다. 사용자가 원하는 타입을 넣어주면 알아서 코드를 찍어내는 틀 이라고 생각하면 된다.

// 템플릿 첫 활용 

#include 

#include 

using namespace std;




template 

class Vector {



	T* data;

	int capacity;

	int length;



public:

	// 생성자 



	Vector(int n = 1) : data(new T[n]), capacity(n), length(0) {



	}



	// 맨 뒤에 새로운 원소를 추가.

	void push_back(T s) {

		if (capacity <= length) {

			T* temp = new T[capacity * 2];

			for (int i = 0; i < length; i++) {

				temp[i] = data[i];

			}



			delete[] data;

			data = temp;

			capacity *= 2;



		}

		data[length] = s;

		length++;



	}



	// 임의의 위치의 원소에 접근.

	T operator[] (int i) {

		



              return data[i];



	}

	// x 번째 위치한 원소를 제거.

	void remove(int x) {


		for (int i = x + 1; i < length; i++) {


           		data[i - 1] = data[i];


		}

		length--;


	}
	// 현재 벡터의 크기를 구한다.
	int size() {
		return length;
	}
	~Vector() {
		if (data) {
			delete[] data;
		}
	}
};
int main()
{
	// int 를 보관하는 벡터를 생성.
	Vector int_vec;
	int_vec.push_back(3);
	int_vec.push_back(2);

	cout << "-------- int vector ----------" << endl;
	cout << "첫번째 원소 : " << int_vec[0] << endl;
	cout << "두번째 원소 : " << int_vec[1] << endl;

	Vector str_vec;
	str_vec.push_back("hello");
	str_vec.push_back("world");
	
        cout << "-------- string vector -------" << endl;
        cout << "첫번째 원소 : " << str_vec[0] << endl;
	cout << "두번째 원소 : " << str_vec[1] << endl;
}

 일단 클래스 상단의 템플릿이 정의된 부분 확인해보자.

template 
class Vector {
	T* data;
	int capacity;
  // ... 

template 

아래에 정의되는 클래스에 대해 템플릿을 정의하고, 템플릿 인자로 T 를 받게 되며, T 는 반드시 어떠한 타입의 이름임을 명시하고 있다. 위 경우 템플릿 문장 아래 오는 것이 class Vector 이므로 이 Vector 클래스에 대한 템플릿을 명시한다. 만약에 밑에 오는 것이 함수일 경우 함수에 대한 템플릿이 된다. Cf) template =====typename T class T 라고 해서 T 자리에 꼭 클래스가 와야 하는 것이 아니다. 똑같이 int, char 등이 올 수 있다. 즉 template 와 template 는 같다. 템플릿의 인자에 값을 전달하기 위해서는 Vector int_vec; 와 같이, <> 안에 전달하려는 것을 명시해주면 된다. Vector 템플릿은 템플릿 인자로 타입을 받게 되는데, 위 경우 T 에 int 가 전달되게 된다. 여태까지는 인자로 특정한 '값' 혹은 '객체' 를 전달해왔지만 '타입' 그 자체를 전달한 적은 없었다. 하지만 템플릿을 통해 타입을 전달할 수 있게 된다. Vector, Vector Vector 의 템플릿의 인자에 타입을 전달하게 되면, 컴파일러는 이것을 보고 실제 코드를 생성하게 된다. template 에 인자로 어떠한 타입을 전달하냐에 따라 int 를 저장하는 Vector 를 만들거나, string 을 저장하는 Vector 를 만들어낼 수 있는 것이다. 마치 틀에 쇳물을 넣으면 쇠로 된 물건이 나오고, 구리물을 넣으면 구리로 된 물건이 나오는 것 처럼 말이다. Vector int_vec; 이 코드는 Vector 의 T 가 int 로 치환된 클래스의 객체 int_vec 을 생성하게 되는 것이다. 즉 클래스 템플릿에 인자를 전달해서 실제 코드를 생성하는 것을 클래스 템플릿 인스턴스화 (class template instantiation) 라고 한다. 템플릿이 인스턴스화 되지 않고 덩그러니 있다면 컴파일 시에 아무런 코드로 변환되지 않는다. 템플릿은 반드시 인스턴스화 되어야지만 비로소 컴파일러가 실제 코드를 생성하게 된다. 마치 틀 자체로는 아무런 의미가 없지만, 그 틀에 채워넣어 나오는 물건에 관심이 있는 것 처럼 말이다. 템플릿에 사용자가 원하는 타입을 템플릿 인자로 전달하면, 컴파일러는 그 인자를 바탕으로 코드를 생성하여 이를 컴파일 하게 된다. 하지만, 간혹 일부 타입에 대해서는 다른 방식으로 처리해야 할 경우가 있다. Ex) bool 데이터를 보관하는 벡터를 생각해보면. Vector int_vec; 그냥 위 처럼 템플릿 인자에 bool 을 전달하여 bool 을 저장하는 벡터로 사용할 수 도 있을 것이다. 하지만 문제가 하나 있는데, C++ 에서 기본으로 처리하는 단위가 1 byte 라는 점이다. 즉 사실 bool 데이터 형은 1개 비트 만으로도 충분히 저장할 수 있지만, 8 비트를 사용해서 1개 bool 값을 저장해야 된다는 뜻이다. 이는 엄청난 메모리 낭비다. 따라서 Vector 에 대해서는 특별히 따로 처리해줘야만 한다. ' 3.C++ Template specialization 일부 경우에 대해서 따로 처리하는 것을 템플릿 특수화라고 한다. 템플릿 특수화는 다음과 같이 수행할 수 있다.

template
class test {
};

위와 같은 클래스 템플릿이 정의되어 있을 때, A 가 int 고 C 가 double 일 때 따로 처리하고 싶다라고 하면,

template
class test {
};

위 소스코드와 같이 특수화 하고 싶은 부분에 원하는 타입을 전달하고 일반적인 템플릿을 쓰면 된다.

template<>
class test {
};

만약에 B 조차도 특수화 하고 싶다면 위 소스 코드와 같이 써주면 된다. 즉 전달하는 템플릿 인자가 없더라도 특수화 하고 싶다면 template<> 라도 남겨줘야 된다는 점이다.

template <>
class Vector {
... // 원하는 코드
}

bool 벡터의 경우, 위 소스 코드처럼 사용하면 된다. Vector 을 구현하기 위해서는 저는 평범한 int 배열을 이용할 것이다. 1 개의 int 는 4 바이트 이므로, 32 개의 bool 데이터들을 한데 묶어서 저장할 수 있다. 원래 방식대로라면 bool 이 1 바이트로 저장되지만, 이렇게 하면 bool 을 1 비트로 정확히 표현할 수 있게 된다. 여기 사진.... 묶어서 저장하면 메모리 관련 측면에서는 효율이 매우 높아지지만, 이를 구현하는데는 조금 더 복잡해진다. 왜냐하면 int 데이터에서 정확히 한 비트의 정보만 뽑아서 보여주어야 하기 때문이다. Ex) N 번째 bool 데이터는 N / 32 번째 int 에 들어가 있고, 그 안에서 정확히 N % 32 번째 비트가 된다.

#include 
#include 
using namespace std;
template 
class Vector {
	T* data;
	int capacity;
	int length;
public:
	// 어떤 타입을 보관하는지
	typedef T value_type;
	// 생성자 
	Vector(int n = 1) : data(new T[n]), capacity(n), length(0) {
	}
	// 맨 뒤에 새로운 원소를 추가한다.
	void push_back(T s) {
		if (capacity <= length) {
			T* temp = new T[capacity * 2];
			for (int i = 0; i < length; i++) {
				temp[i] = data[i];
			}
			delete[] data;
			data = temp;
			capacity *= 2;
		}
		data[length] = s;
		length++;
	}

	// 임의의 위치의 원소에 접근.
	T operator[] (int i) {
		return data[i];
	}
	// x 번째 위치한 원소를 제거.
	void remove(int x) {
		for (int i = x + 1; i < length; i++) {
			data[i - 1] = data[i];
		}
		length--;
	}
	// 현재 벡터의 크기를 구한다.
	int size() {
		return length;
	}
	~Vector() {
		if (data) {
			delete[] data;
		}
	}
};
template <>
class Vector {
	unsigned int* data;
	int capacity;
	int length;
public:
	typedef bool value_type;
	// 생성자 
	Vector(int n = 1) :
		data(new unsigned int[n / 32 + 1]),
		capacity(n / 32 + 1),
		length(0) {
		for (int i = 0; i < capacity; i++) {
			data[i] = 0;
		}
	}
	// 맨 뒤에 새로운 원소를 추가.
	void push_back(bool s) {
		if (capacity * 32 <= length) {
			unsigned int* temp = new unsigned int[capacity * 2];
			for (int i = 0; i < capacity; i++) {
				temp[i] = data[i];
			}
		for (int i = capacity; i < 2 * capacity; i++) {
		temp[i] = 0;
	}
			delete[] data;
			data = temp;
			capacity *= 2;

		}
		if (s) {
			data[length / 32] |= (1 << (length % 32));

		}
		length++;
	}
	// 임의의 위치의 원소에 접근.
	bool operator[] (int i) {
		return (data[i / 32] & (1 << (i % 32))) != 0;
	}
	// x 번째 위치한 원소를 제거한다.
	void remove(int x) {
		for (int i = x + 1; i < length; i++) {
			int prev = i - 1;
			int curr = i;
			// 만일 curr 위치에 있는 비트가 1 이라면
			// prev 위치에 있는 비트를 1 로 만든다. 
			if (data[curr / 32] & (1 << (curr % 32))) {
				data[prev / 32] |= (1 << (prev % 32));
			}
			// 아니면 prev 위치에 있는 비트를 0 으로 지운다.
			else {
				unsigned int all_ones_except_prev = 0xFFFFFFFF;
				all_ones_except_prev ^= (1 << (prev % 32));
				data[prev / 32] &= all_ones_except_prev;
                       }
		}
		length--;
	}
	// 현재 벡터의 크기를 구한다.
	int size() {
		return length;
	}
	~Vector() {
		if (data) {
		delete[] data;
		}
	}
};
int main()
{
	// int 를 보관하는 벡터를 만든다.
	Vector int_vec;
	int_vec.push_back(3);
	int_vec.push_back(2);
	cout << "-------- int vector ----------" << endl;
	cout << "첫번째 원소 : " << int_vec[0] << endl;
	cout << "두번째 원소 : " << int_vec[1] << endl;

	Vector str_vec;
	str_vec.push_back("hello");
	str_vec.push_back("world");
	
        cout << "-------- string vector -------" << endl;
	cout << "첫번째 원소 : " << str_vec[0] << endl;
	cout << "두번째 원소 : " << str_vec[1] << endl;

	Vector bool_vec;
	bool_vec.push_back(true);
	bool_vec.push_back(true);
	bool_vec.push_back(false);
	bool_vec.push_back(false);
	bool_vec.push_back(false);
	bool_vec.push_back(true);
	bool_vec.push_back(false);
	bool_vec.push_back(true);
	bool_vec.push_back(false);
	bool_vec.push_back(true);
	bool_vec.push_back(false);
	bool_vec.push_back(true);
	bool_vec.push_back(false);
	bool_vec.push_back(true);
	bool_vec.push_back(false);
	bool_vec.push_back(true);
	bool_vec.push_back(false);

	cout << "-------- bool vector ---------" << endl;

	or (int i = 0; i < bool_vec.size(); i++) {
		cout << bool_vec[i]; 
	}
	cout << endl;
}

unsigned int* data;
   int capacity;
   int length;

int 배열로 unsigned int 를 사용하기로 했다.unsigned int 를 사용한 이유는 그냥 int 를 사용했을 때 shift 연산 시에 귀찮은 문제가 발생할 수 도 있기 때문이다. capacity 는 생성된 data 배열의 크기를 의미하고 length 는 실제 bool 데이터의 길이를 의미한다. 즉 1 capacity 에 32 개의 bool 이 들어갈 수 있게 되는 것이지요. int 가 32 비트라 생각했을 때.

if (s) {
			data[length / 32] |= (1 << (length % 32));
		}

위 처럼 만일 true 를 추가하였을 때에만 해당 비트를 true 로 바꿔주면 된다. 어떤 비트에 1 을 OR 연산하게 되면 그 비트는 무조건 1 이 된다. 그리고 0 을 OR 연산하게 되면 그 비트의 값은 그대로 보존이 된다. 따라서 OR 연산은 특정 비트에만 선택적으로 1로 바꾸는데 좋은 연산이다. 주변 나머지 비트들의 값은 보존하면서 특정 비트만 1 로 바꿔준다. 위 경우에도 1 << (length % 32) 을 통해서 정확히 length % 32 번째 비트만 1 로 바꾼다. OR 연산을 해서 해당 int 의 자리를 true 로 만들어 줄 수 있다. 임의의 위치에 접근하는 것은 어떻게 될지 살펴본다. 이번에는 거꾸로 AND 연산을 통해 해당 값을 가져올 수 있다. 어떤 비트에 0 을 AND 하게 되면 그 비트는 무조건 0 이 되고, 1 을 AND 연산 하게 되면 해당 비트가 1 이여야지만 1이 된다. 즉, 1 을 AND 하게 되면 해당 비트의 값이 무엇인지 알아낼 수 있는 것이다. remove 함수를 살펴본다. 사실 이전 버전에서는 그냥 오른쪽 원소를 왼쪽으로 쭈르륵 덮어 씌어나가는 방식으로 간단히 만들 수 있지만 이 bool 버전의 경우 그 '왼쪽' 과 '오른쪽' 원소를 읽어내는거 자체가 꽤나 복잡하므로 간단하게는 구현하기 힘들다.

 // 만일 curr 위치에 있는 비트가 1 이라면
			// prev 위치에 있는 비트를 1 로 만든다. 
			if (data[curr / 32] & (1 << (curr % 32))) {
				data[prev / 32] |= (1 << (prev % 32));
			}
==========================================================
 // 아니면 prev 위치에 있는 비트를 0 으로 지운다.
			else {
				unsigned int all_ones_except_prev = 0xFFFFFFFF;
				all_ones_except_prev ^= (1 << (prev % 32));
				data[prev / 32] &= all_ones_except_prev;
			}
===========================================================
unsigned int all_ones_except_prev = 0xFFFFFFFF; =====================E
				all_ones_except_prev ^= (1 << (prev % 32));

그래도 일단 특정 비트를 1 로 만드는 것은 간단하다.OR 을 수행해주면 된다. 그렇다면 오른쪽 비트가 0 일 때 왼쪽 비트를 0 으로 만드는 작업은? 앞서 AND 연산의 경우 1 을 AND 하게 되면 원래 비트가 보존되고, 0 을 AND 하면 0 이 된다. 따라서 해야할 일은 원하는 자리의 비트만 0 이고 나머지는 1 인 것을 AND 해주면 된다. 그 과정을 수행하는 부분이 E. all_ones_except_prev 는 0 으로 지우려고 하는 위치만 0 이고 나머지 부분은 1 인 값. ^ 는 XOR 연산자로, 두 비트가 같으면 0, 다르면 1 이되는 연산. 따라서 0xFFFFFFFF 는 모든 비트가 1 인 int 인데, XOR 연산을 통해서 해당 비트만 0 으로 바꿔준다. 그 후에 AND 연산을 하게 되면 해당 비트만 0 으로 지워버릴 수 있게 된다. 

 4.C++ Function template

template  =======================Q
T max(T& a, T& b) {
	return a > b ? a : b;
}
===========================
cout << "Max (" << a << "," << b << ") ? : " << max(a, b) << endl; ==============================W
===========================
max(a, b) ====================================E
===========================
cout << "Max (" << s << "," << t << ") ? : " << max(s, t) << endl; ==============================R

Q 부분에서 템플릿 함수를 정의하고 있다. 클래스 템플릿과 마찬가지로, Q 함수도 인스턴스화 되기 전 까지는 컴파일 시에 아무런 코드로 변환되지 않는다. 실제로 W 템플릿 함수가 인스턴스화 되는 부분은 바로 위 코드에서 max(a, b) 가 호출되는 부분이다. 클래스를 인스턴스화 했을 때 와는 다르게 <> 하는 부분이 없다. 원래 대로라면 E처럼 했을 것이다. 하지만 C++ 컴파일러는 똑똑해서, a 와 b 의 타입을 보고 알아서 max (a, b) 를 max(a, b) 로 인스턴스화 해준다. 템플릿으로 발생되는 오류는 프로그램이 실행되었을 때가 아니라 컴파일 할 때 발생한 다는 사실이다. 왜냐하면 컴파일 시에 모든 템플릿을 실제 코드로 변환하여 실행하기 때문이다. 컴파일 시에 모든 템플릿들이 인스턴스화 되다는 사실을 가지고 또 여러가지 흥미로운 코드를 짤 수 있는데 이러한 방식을 템플릿 메타프로그래밍 (template metaprogramming) 이라고 한다 bubble_sort 함수에서는 한 가지 부족한 점이 있다. 정렬 순서를 역순으로 하고 싶다면 어떻게 하지? 오름 차순으로 정렬하였지만, 간혹 내림 차순으로 정렬을 하고 싶을 수 도 있다. 아니면 아예 다른 기준으로 정렬을 할 수 도 있다. 크게 세 가지 방법이 있습다. 1.bubble_sort2 를 만들어서 부등호 방향을 반대로 바꿔준다. 2.operator> 를 오버로딩해서 원하는 방식으로 만들어준다. 3.cont[i] 와 cont[j] 의 비교를 > 로 하지 말고 특정 함수에 넣어서 전다. 첫번째 방법은 C 를 배우는 단계에서나 적합한 방법이고, C++ 를 배우고 있으니 더 나은 방법이 있을 것이다. 두번째 방법은 사용자가 만든 객체를 사용할 때 적용할 수 있는 방법이다. 

 5.C++ Fuction object

template 
void bubble_sort(Cont& cont, Comp& comp) {

	for (int i = 0; i < cont.size(); i++) {
		for (int j = i + 1; j < cont.size(); j++) {
			if (!comp(cont[i], cont[j])) {
				cont.swap(i, j);
			}
		}
	}
}

위 함수는 기존의 bubble_sort 와는 달리 아예 Comp 라는 클래스를 템플릿 인자로 받고, 함수 자체도 Comp 객체를 따로 받는다. 그렇다면 이 comp 객체가 무슨 일을 하냐면 if (!comp(cont[i], cont[j])) {========================== if 문에서 마치 함수를 호출하는 것 처럼 사용되는데, cont[i] 와 cont[j] 를 받아서 내부적으로 크기 비교를 수행한 뒤에 그 결과를 리턴하고 있다. 한 가지 중요한 사실은 comp 는 함수가 아니라 객체 이고, Comp 클래스에서 () 연산자를 오버로딩한 버전이다.

struct Comp1 {
	bool operator() (int a, int b) {
		return a > b;
	}
};
struct Comp2 {
	bool operator() (int a, int b) {
		return a < b;
	}
};

Comp1 과 Comp2 모두 아무 것도 하지 않고 단순히 operator() 만 정의하고 있다. 그리고 이 Comp1 과 Comp2 객체들은 bubble_sort 함수 안에서 if (!comp(cont[i], cont[j])) {는 마치 함수인양 사용되고 있다. 이렇게, 함수는 아니지만 함수 인 척을 하는 객체를 함수 객체 (Function Object), 혹은 줄여서 Functor 라고 부른다. 이 Functor 덕분에, bubble_sort 함수 내에서 두 객체간의 비교를 사용자가 원하는 대로 할 수 있게 된다.

template  ============================	Q
void bubble_sort(Cont& cont) 
=============================
template  ===================  W
void bubble_sort(Cont& cont, Comp& comp)

보통의 < 연산자로 비교를 수행하는 Q bubble_sort 함수를 사용하거나, 특수한 경우에 따로 비교 하는 것을 직접 수행하고 싶은 경우에 Comp 객체를 받아서 비교를 수행하는 새로운 bubble_sort 함수를 사용할 수 있다. 물론 bubble_sort(int_vec, comp1);를 했다면 두 번째 버전으로 템플릿 인스턴스화 되서 함수가 호출되고, bubble_sort(int_vec);한다면 첫 번째 버전으로 템플릿 인스턴스화 되서 함수가 호출될 것이다.

template< class RandomIt >================================ Q
void sort( RandomIt first, RandomIt last );
=============================================
template< class RandomIt, class Compare > ====================== W
void sort( RandomIt first, RandomIt last, Compare comp );

Sort 함수를 봐도 비교 클래스를 받지 않는 Q와 비교 클래스를 받는 W가 있다. 비교 클래스를 받아서 원하는 비교 작업을 수행할 수 있게 된다. 만약 C 였다면 위 sort 함수를 어떻게 만들었을 지 보면, 일단 원하는 클래스를 받는 다는 생각 자체가 불가능하기 때문에 (template 이 없으니까) functor 불가능하다. 대신에, 비교 작업을 수행하는 함수의 포인터를 받아서 이를 처리하였을 것이다. 이미 예상하셨겠지만, Functor 를 사용하는것이 여러 모로 훨씬 편리한 점이 많다. 일단, 클래스 자체에 여러가지 내부 state 를 저장해서 비교 자체가 복잡한 경우에도 손쉽게 사용자가 원하는 방식으로 만들어낼 수 있다. 뿐만 아니라, 함수포인터로 함수를 받아서 처리한다면 컴파일러가 최적화를 할 수 없지만, Functor 를 넘기게 된다면 컴파일러가 operator() 자체를 인라인화 시켜서 매우 빠르게 작업을 수행할 수 있다.