template

templates的基本用法

  • 编译器根据你提供的规则为你编写代码。

  • 模板定义本身不参与编译，而是编译器根据模板的用户使用模板时提供的类型参数生成代码，再进行编译。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
#include <iostream>
#include <string>


template <typename T>

void Print(T value)		//函数模板
{
	std::cout << value << std::endl;
}


template <typename T, int N>
class Array		//类模板
{
private:
	T m_Array[N];
public:
	int GetSize() const {
		return N;
	}

};
int main() {
	Array<int, 5> array;
	std::cout << array.GetSize() << std::endl;

	Print(123);
	Print("Randolfluo");

	std::cin.get();
}

类模板的全特化与偏特化

  • 全特化是指对模板的所有模板参数进行特化。即限定全部参数。
  • 偏特化是指对模板的一部分模板参数进行特化。即限定部分参数。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
#include<iostream>


template <typename T0,typename T1>			//原始模板类
class Entity
{
public:
    Entity(T0 a, T1 b)
    {
        std::cout << "Primary Template" << std::endl;
        std::cout << "<" << typeid(T0).name() << "," << typeid(T1).name() << ">: "  << a << " " << b << std::endl << std::endl;
    }

};


template <>						//全特化
class Entity<float,float>
{
public:
    Entity(float a, float b)
    {
        std::cout << "Full Specialization" << std::endl;
        std::cout << "<float,float>:    " << a << " " << b << std::endl << std::endl;
    }
 
};

template<typename T>			//偏特化
class Entity<T, int>
{
public:
    Entity(T a, int b)
    {
        std::cout << "Partial Specialization" << std::endl;
        std::cout << "<" << typeid(T).name() << "," << "int" << ">: " << a << " " << b << std::endl << std::endl;
    }
};


int main()
{

    Entity<int,int>(1, 3);
    Entity<float,float>(1, 3);
    Entity<double,double>(1, 3);
    Entity<double, int>(1, 3);
    Entity<int, double>(1, 3);
   
}
Partial Specialization
<int,int>: 1 3

Full Specialization
<float,float>:    1 3

Primary Template
<double,double>: 1 3

Partial Specialization
<double,int>: 1 3

Primary Template
<int,double>: 1 3

函数特化

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
#include<iostream>



template <typename T>
void Print(T x)
{
    std::cout << "普通模板: "<< typeid(T).name() << x << std::endl;
    
}

template<>
void Print(int x)
{
    std::cout << "函数模板特化:int" << x << std::endl;
}
template<>
void Print(float x)
{
    std::cout << "函数模板特化:float" << x << std::endl;
}



int main()
{
    Print(1);
    Print(1.0f);
    Print(1.0L);
    Print("123");
    std::string a = "123";
    Print(a);
}

//函数模板特化:int1
//函数模板特化 : float1
//普通模板 : long double1
//普通模板 : char const* __ptr64123
//普通模板 : class std::basic_string < char, struct std::char_traits<char>, class std::allocator<char> >123

  • 模板函数特化是针对模板函数的特定类型提供特殊实现，而函数重载是根据参数列表的不同提供多个同名函数。

//TODO