Template

템플릿이란?

 

: 함수나 클래스를 개별적으로 작성하지 않아도, 여러 자료형으로 사용할 수 있도록 만들어 놓은 틀

• 함수 템플릿
• 클래스 템플릿

- 컴파일 시간에 ~

- 객체의 자료형을 인수로 처리함

 

---

 

1. Function Template 

• 함수를 만들어낼 때, 함수의 기능은 명확하지만, 자료형을 모호하게 두는 것.

- 템플릿으로 사용하는 변수가 2개 이상일 경우, 함수이름 뒤에 <>안에 명확하게 사용하지 않는다.

→ 컴파일러가 스스로 자료형 판단 

- template 선언 시 <typename T>, <class T> 둘 다 사용 가능 

 

 

기본 문법

template <typename T>
T functionName (T parameter1, Tparameter2, ...) {
	// code
    }
    
a = functionName<int> (4,6); 
b = functionName<double> (4.4, 6.6);

 

 

Different return Type 

 

 

---

 

 

2. Class Template

 

기본 문법

template <typename T>
class className {
private:
 T var;
public:
 T functionName (T arg);
};

 

- 오버로딩과 다르게 '다른' 함수로 취급된다. 

- 디폴트 템플릿 인자를 명시할 수 있음. template<typename T = int > 는 디폴트 템플릿 인자가 int 임

- 기초 클래스로 상속할 수 있음. 

- 함수 템플릿을 호출할 때와 달리, 클래스 템플릿을 사용할 때는 반드시 타입을 명시해야 함. 

≫ 클래스의 생성자가 호출되기 이전에 멤버 변수의 타입을 확인해, 객체의 메모리 공간을 할당해야 할 필요가 있기 때문이다. 

 

 

 

non-type parameter

 

 

#include <iostream>
using namespace std;
template <typename T>//class Array 정의 
//template<typename T, int arraySize>//arraySize는 멤버변수처럼 사용될 수 있음 

//template은 템플릿 데이터 타입 + 어떠한 primitive data types을 받을 수 있음 !
class Array {
public:
	explicit Array(int size) : arraySize{ size } {
		ptr = new T[arraySize];//배열을 가리키는 포인터 
	}
	int getSize() const {
		return arraySize * sizeof(T);
	}
	~Array() {
		delete[] ptr;
	}
private:
	T* ptr = nullptr;
	int arraySize = 0;
};
int main() {
	Array<int> arr1{ 5 };//Array<int>타입의 객체 생성 
	//Array <int, 5>arr1; 
	cout << arr1.getSize() << endl;
	Array<double> arr2{ 5 };
	cout << arr2.getSize() << endl;
	return 0;
}

 

 

Type Inference

 

 

---

 

3. Specialization

- 함수 템플릿과 클래스 템플릿는 특정 데이터 타입으로 그것의 버전을 정의할 수 있다. 

- 컴파일러는 템플릿 버전을 우선적으로 체크한 후, 메인 템플릿을 체크한다. 

- 함수 템플릿 -> 명시적 특수화 가능, 부분 특수화 불가능

  ※ 오버로딩으로 해결할 수 있음. 명시적 특수화된 함수보다 위에 있을 것!!

- 클래스 템플릿 -> 명시적 특수화, 부분 특수화 가능

순서 : 일반함수 > 템플릿 특수화 함수 > 템플릿 알맞은 함수

 

• 완전 특수화 → 템플릿 매개 변수들을 전부 다 특수화 함
• 부분 특수화 → 템플릿 매개 변수들이 여러개일 때 그 중 일부만 특수화 함
  • 전역 함수의 경우 문제 없이 가능
  • 멤버 함수의 경우 클래스 외부에선 부분 특수화 불가능
    • 클래스 내부에서만 가능하므로 상속을 이용함

 

template <typename T>
class className {
 T functionName (T arg);
};
template <>
class className <int> {
 int functionName (int arg);
};

 

 

/ Example. char * Specializtion /

#include <iostream>
using namespace std;

template <typename T>//main
T add(T a, T b) {
	return a + b;
}

template<>//specialization
const char* add(const char* a, const char* b){
	return "char*"; 
}

int main() {
	cout << add(1, 2) << endl; 
	cout << add("rlo", "lo") << endl; 
}

/* 출력
3
rlo lo*/

 

- 인자 수 다를 수 있음

- 특수화 템플릿에  기본 parameter 표시 x (main template 승계)

 

/ Example . 클래스 명시적 특수화

#include <iostream>
using namespace std;
 
// 클래스 템플릿
template <typename T>
class MyClass {
private:
	T x;
public:
	MyClass(T _x);
	T Caldouble();
};
 
// double 형에 대한 명시적 특수화
template <>
class MyClass<double> {
private:
	double x;
public:
	MyClass(double _x) { x = _x; }
	double Caldouble() {
		cout << "double 형 데이터를 2배하여 출력합니다. " << endl;
		return x * 2;
	};
};

 

 

 

/ Example. 클래스 부분적 특수화 

// 3개의 인자를 가지는 클래스 템플릿 예
 
// 일반적인 클래스 템플릿
template <typename A, typename B, typename C>
class MyClass {};
 
// 첫 번째 인자에 대한 특수화 - A가 int일 경우
template <typename B, typename C>
class MyClass<int> {};
 
// 첫 번째, 세 번째 인자에 대한 특수화 - A가 int, C가 double일 경우
template <typename B>
class MyClass<int, B, double> {};
 
// 모든 인자에 대한 특수화 - A가 int, B가 int, C가 double일 경우
template <>
class MyClass<int, int, double> {};

 

 

 

 

//Example. const char* 

#include <iostream>
#include <exception>
#include<stdexcept>
using namespace std;


template <typename T>
class MyData {
public:
	explicit MyData(T value) : data{ value } {}
	T getData() const { return data;  }
private: 
	T data; 

};

template <>
class MyData<char*> {
public:
	explicit MyData(const char* value) : data{ new char[strlen(value)] } {
		strcpy_s(data, strlen(value)+1, value);//널문자 포함 목적지 버퍼의 크기 전달
	}
	const char* getData() const { return data; }
	~MyData() { delete[] data; }
private:
	char* data;
}; 

int main() {
	cout << MyData{ 5 }.getData() << endl;
	cout << MyData<char*>{"dlwlrma"}.getData() << endl;
}