Templates(ํ ํ๋ฆฟ)
- ์ปดํ์ผ๋ฌ๋ฅผ ์ํ ํจํด์ ์ข ๋ฅ
- ์๋ก ๋ค๋ฅธ ํ์ ์ด๋ ๊ฐ์ผ๋ก ํ ํ๋ฆฟ์ ์ธ์คํด์คํ ํ ์ ์์
- ํ ํ๋ฆฟ์ ํ๋ก๊ทธ๋๋จธ์ ์์ ์ ์ค์ฌ์ฃผ๋ฉฐ, ์ฝ๊ฐ ๋ค๋ฅธ ํ์ ๋๋ฌธ์ ์ฌ๋ฌ ๋ฒ ํจ์๋ฅผ ๊ตฌํํ์ง ์์๋ ๋จ
- ํ ํ๋ฆฟ์ ํญ์ ํค์๋ template ์ผ๋ก ์์๋จ
์์ )
cout << min(i1, i2) << endl; ์์ ์ปดํ์ผ๋ฌ๋ int๋ก minํจ์๋ฅผ ์์ฑํ๊ณ ,
cout << min<float> (f1, f2) << endl; ์์ ์ปดํ์ผ๋ฌ๋ float๋ก minํจ์๋ฅผ ์์ฑํ๋ค
์ด์ฒ๋ผ ์ฌ๋ฌ ๋ฒ ํจ์๋ฅผ ๊ตฌํํ์ง ์๊ณ ๋ ๋ค๋ฅธ ํ์ ์ ์ธ์ํ๊ฒ ํด์ฃผ๋ ๊ฒ์ด ํ ํ๋ฆฟ์ ์ฅ์ ์ด๋ค.
์ธ์คํด์คํ๋?
- ํ ํ๋ฆฟ์ ์ฌ์ฉํ๋ฉด ์ธ์คํด์ค(๊ฐ์ฒด)ํ ๋๋๋ฐ, ์ด๋ ์ปดํ์ผ๋ฌ๊ฐ ํ ํ๋ฆฟ์ ๊ตฌ์ฒด์ ์ธ ์ธ์๋ก ๋์ฒดํ๊ธฐ ๋๋ฌธ
- ์ปดํ์ผ๋ฌ๋ ํจ์๋ก ๋๊ฒจ์ง ์ธ์๊ฐ์ ์ด์ฉํด ํ ํ๋ฆฟ์ ์๋์ผ๋ก ์ธ์คํด์คํ ํ๋ค
- ์ปดํ์ผ๋ฌ๊ฐ ์ธ์๋ฅผ ๊ฒฐ์ ํ์ง ๋ชปํ๋ฉด ๋ช ์์ ์ผ๋ก ๊ธฐ์ ํด์ผ ํ๋ค
Specializations
ํ ํ๋ฆฟ ๊ฐ์ฒด์ ํน์ ํ ๊ฒฝ์ฐ์ ์ ์ฐ์ฑ์ด๋ ์คํ ํ๋์ ์ค์ํ ํด๋ก์ ์์ฉํ๊ธฐ ์ํด
๋ค์๊ณผ ๊ฐ์ด ํ ํ๋ฆฟ์ Specializationsํ๊ฒ ์ฌ์ฉํ ์๋ ์๋ค.
template <>
bool equal (const double& a, const double& b) {
return std::abs(a-b) < 0.00001;
}
์ฌ์ฉํ ๋๋, ๋ค์๊ณผ ๊ฐ์ด general version์ ๋จผ์ ์ ์ํ๊ณ ํน์ ๊ฒฝ์ฐ์ ํ ํ๋ฆฟ์ ์ ์ํด์ผ ํ๋ค
// general version์ ๋จผ์ ์ ์ํ๋ค
template <class T> void sort(List<T>& v) {
...
}
// specializations๋ฅผ ๋ค์์ ์ ์ํ๋ค
template <> void sort(List<char *>& v) {
...
}
Templates(ํ ํ๋ฆฟ)์ Parameter(ํ๋ผ๋ฏธํฐ)
<ํ ํ๋ฆฟ์ ์ข ๋ฅ>
1. ํจ์ ํ ํ๋ฆฟ(Function Template)
2. ํด๋์ค ํ ํ๋ฆฟ(Class Template) : ์ปจํ ์ด๋ ํด๋์ค(List, Array, Set, Queue, Stack ...)์์ ๋ง์ด ์ฌ์ฉ
3. ๊ฐ๋ณ ๊ธธ์ด ํ ํ๋ฆฟ(Variadic Template) : parameter pack
4. ๋ณ์ ํ ํ๋ฆฟ
ํจ์ ํ ํ๋ฆฟ (Function Template)
- ์๋ก ๋ค๋ฅธ ํ์ ์ ๋ํด ํต์ผ๋ ๊ธฐ๋ฅ์ ๊ตฌํํ ์ ์์
- ํ ํ๋ฆฟ ํ๋ผ๋ฏธํฐ๋ ํ์ (types)์ด๋ ๊ฐ(values)
- ํ์ ์ typename์ด๋ class๋ก ์์ํจ
- ํ ํ๋ฆฟ ํ๋ผ๋ฏธํฐ์ ์ด๋ฆ์ typename ๋ค์ ์ด
- ์ด๋ฆ์ ์ฒซ ๋ฒ์งธ ํ๋ผ๋ฏธํฐ๋ ๋ณดํต T๋ก ๋ ๋ฒ์งธ ํ๋ผ๋ฏธํฐ๋ U๋ฅผ ์ ex) template <typename T=int, typename U=double>
- ํจ์ ์์์ ์ด ์ด๋ฆ์ ํน์ ํ์ ๋์ ์ ์ฌ์ฉํจ
#include <iostream>
template <typename T>
T min(const T& a, const T& b) {
return (a < b) ? a : b
}
int main(){
const int a = 2;
const int b = 1;
std::cout << min(a, b) << std::endl;
}
#include <vector>
using namespace std;
template <typename T>
const T* find(const vector<t>& data, const T& v) {
for (auto i = 0; i < data.size(); i++)
if(data[i] == y)
return &data[i];
return nullptr;
}
int main() {
vector <int> v;
//insert some elements
const int *found = find(v, 7);
if (found != nullptr)
...
}
ํด๋์ค ํ ํ๋ฆฟ (Class Template)
- ํจ์ ํ ํ๋ฆฟ๊ณผ ๋ง์ฐฌ๊ฐ์ง๋ก ํค์๋ template์ผ๋ก ์์ํจ
- ํจ์ ํ ํ๋ฆฟ์ ๋๋ถ๋ถ ๊ท์น์ด ํด๋์ค ํ ํ๋ฆฟ์๋ ์ ์ฉ๋จ
- ๋ฉค๋ฒ ํจ์๋ ํด๋์ค์ ๋ด๋ถ๋ ๋ฐ์์ ๊ตฌํ ๊ฐ๋ฅํจ
- ํด๋์ค ๋ฐ์์ ๊ตฌํํ ๋๋ template-head๊ฐ ํ์ํจ
C++ 17๋ถํฐ ํด๋์ค ํ ํ๋ฆฟ์ ์ธ์๋ฅผ ์๋์ผ๋ก ์ถ๋ก ํ ์ ์์ *** (์๋ ์ธ์คํด์คํ๊ฐ ๋ถ๊ฐ๋ฅํ๋ค)
๊ทธ๋ฌ๋ฏ๋ก ๊ฐ๋ณ ํ ํ๋ฆฟ ์ธ์๋ค์ ๋ช ์์ ์ผ๋ก ๊ธฐ์ ๋์ด์ผ ํ๋ค
#include <iostream>
#include <vector>
using namespace std;
int main(){
vector vec = {1, 2, 3};
for (const auto& i : vec)
cout << i << " ";
}
Method Templates
ํด๋์ค ํ ํ๋ฆฟ์ ๋ฉ์๋๋ ์์ ๋ง์ ํ ํ๋ฆฟ์ ๊ฐ์ง ์ ์์
- ๋ฉ์๋ ํ ํ๋ฆฟ์ ํด๋์ค์ ๋ด๋ถ๋ ๋ฐ์ ์ ์๋ ์ ์์
- ๋ณต์ฌ ์์ฑ์์ ์๋ฉธ์๋ ํ ํ๋ฆฟ์ด ๋ ์ ์์
#include <iostream>
template <typename T> // T ์ฒซ ๋ฒ์งธ ํ๋ผ๋ฏธํฐ
class Foo {
public:
Foo(const T& x) : mX{x} {}
template<typename U> // U ๋ ๋ฒ์งธ ํ๋ผ๋ฏธํฐ
Foo<T>& operator=(const U& u){
mX = static_cast<T>(u);
return *this;
}
private:
T mX;
};
๊ฐ๋ณ ๊ธธ์ด ํ ํ๋ฆฟ(Variadic Template)
1. typenema... Ts : optional name์ ๊ฐ์ง ํ ํ๋ฆฟ ํ๋ผ๋ฏธํฐ ํฉ. ํ์ ์ ์์ฑ
2. Args... ts : optional name์ ๊ฐ์ง ํจ์ ์ธ์ ํ๋ผ๋ฏธํฐ ํฉ
3. sizeof...(ts) : ์ ๋ฌ๋ฐ์ ์ธ์์ ๊ฐ์๋ฅผ ๊ฒฐ์
4. ts... : ํจ์ ๋ด๋ถ์์ ์ธ์๋ค์ ์ธํฉ(unpack)ํจ. ts๋ฅผ ์ธ์๋ก ๋ฐ์์ ์ฝค๋ง(,)๋ก ๊ตฌ๋ถ