#include <iostream>template<class T1, class T2>
class Data
{
public:Data() { std::cout << "Data<T1, T2>" << std::endl; }
private:T1 _d1;T2 _d2;
};template<>
class Data<int, char>
{
public:Data() { std::cout << "Data<int, char>" << std::endl; }
private:int _d1;char _d2;
};void TestVector()
{Data<int, int> d1;Data<int, char> d2;
}int main()
{TestVector();return 0;
}

偏特化

任何针对模版参数进一步进行条件限制设计的特化版本。

// 将第二个参数特化为int
template <class T1>
class Data<T1, int>
{
public:Data() { cout << "Data<T1, int>" << endl; }
private:T1 _d1;int _d2;
};

#include <iostream>template <class T1, class T2>
class Data<T1*, T2*>
{
public:Data() { std::cout << "Data<T1*, T2*>" << std::endl; }private:T1* _d1;T2* _d2;
};template <class T1, class T2>
class Data<T1&, T2&>
{
public:Data(const T1& d1, const T2& d2): _d1(d1), _d2(d2){std::cout << "Data<T1&, T2&>" << std::endl;}private:const T1& _d1;const T2& _d2;
};void test2()
{Data<double, int> d1;           // 调用基础的模板Data<int, double> d2;           // 调用基础的模板Data<int*, int*> d3;            // 调用特化的指针版本Data<int&, int&> d4(1, 2);      // 调用特化的引用版本
}int main()
{test2();return 0;
}

3、例题

#include <iostream>
using namespace std;template<class T1, class T2>
class Data
{
public:Data() { cout << "Data<T1, T2>" << endl; }
private:T1 _d1;T2 _d2;
};template <class T1>
class Data<T1, int>
{
public:Data() { cout << "Data<T1, int>" << endl; }
private:T1 _d1;int _d2;
};template <typename T1, typename T2>
class Data <T1*,T2*>
{
public:Data() { cout << "Data<T1*, T2*>" << endl; }
private:T1 _d1;T2 _d2;
};template <typename T1, typename T2>
class Data <T1&, T2&>
{
public:Data(const T1& d1, const T2& d2): _d1(d1), _d2(d2){cout << "Data<T1&, T2&>" << endl;}
private:const T1 & _d1;const T2 & _d2;
};int main()
{Data<double, int> d1; Data<int, double> d2; Data<int *, int*> d3; Data<int&, int&> d4(1, 2);return 0;
}

以下程序运行结果正确的是( )

A.Data<T1, T2> Data<T1, int> Data<T1*, T2*> Data<T1&, T2&>

B.Data<T1, int> Data<T1, T2> Data<T1&, T2&> Data<T1*, T2*>

C.Data<T1, int> Data<T1, T2> Data<T1*, T2*> Data<T1&, T2&>

D.Data<T1, T2> Data<T1, T2> Data<T1*, T2*> Data<T1&, T2&>

分析:

Data<double, int> d1; // 调用特化的int版本

Data<int, double> d2; // 调用基础的模板

Data<int *, int*> d3; // 调用特化的指针版本

Data<int&, int&> d4(1, 2); //调用特化的引用版本

故答案为: C 

#include <iostream>
using namespace std;template<typename Type>
Type Max(const Type &a, const Type &b)
{cout<<"This is Max<Type>"<<endl;return a > b ? a : b;
}template<>
int Max<int>(const int &a, const int &b)
{cout<<"This is Max<int>"<<endl;return a > b ? a : b;
}template<>
char Max<char>(const char &a, const char &b)
{cout<<"This is Max<char>"<<endl;return a > b ? a : b;
}int Max(const int &a, const int &b)
{cout<<"This is Max"<<endl;return a > b ? a : b;
} int main()
{Max(10,20);Max(12.34,23.45);Max('A','B');Max<int>(20,30);return 0;
}

以下程序运行结果正确的是( )

A.This is Max This is Max<Type> This is Max<char> This is Max<int>

B.This is Max<int> This is Max<Type> This is Max<char> This is Max<int>

C.This is Max This is Max<int> This is Max<char> This is Max<int>

D.This is Max This is Max<Type> This is Max<char> This is Max

分析:

在调用Max函数时，编译器会优先选择非模板函数。如果没有找到合适的非模板函数，编译器会再去查找模板函数。

Max(10,20);    //能够直接匹配int参数，调动非模板函数

Max(12.34,23.45); //double类型参数没有最佳匹配函数，此时只能调动模板函数

Max('A','B');   //能够直接匹配char参数,调动非模板函数

Max<int>(20,30); //由于直接实例化了函数，因此要调动模板函数，但是，由于进行函数的int特化，所以会调用特化版本的模板函数

故答案为: A

三、模板分离编译

1、定义

一个程序（项目）由若干个源文件共同实现，而每个源文件单独编译生成目标文件，最后将所有目标文件链接起来形成单一的可执行文件的过程称为分离编译模式。

// a.h
template<class T>
T Add(const T& left, const T& right);// a.cpp
template<class T>
T Add(const T & left, const T & right)
{return left + right;
}// main.cpp
#include "a.h"
int main()
{Add(1, 2);Add(1.0, 2.0);return 0;
}

• 在给定的示例中，模板函数 Add 的声明和定义被分离到了不同的文件中。Add 函数的声明位于头文件 "a.h" 中，而定义位于源文件 "a.cpp" 中。
• 然后，在主文件 "main.cpp" 中，通过包含 "a.h" 头文件来使用 Add 函数。 然而，这样的分离编译方式会导致编译错误。这是因为模板的实例化需要在编译时进行，而编译器在编译 "main.cpp" 时无法看到 "a.cpp" 中的模板定义，这是因为在C++中，模板的实例化是在编译时进行的。当编译器编译一个源文件时，它只能看到当前源文件中的代码以及通过包含的头文件中的代码。编译器无法直接访问其他源文件中的代码。
• 在给定的示例中，"main.cpp" 文件包含了 "a.h" 头文件，其中包含了模板函数 `Add` 的声明。编译器可以看到这个声明，并知道 `Add` 是一个模板函数，但它无法看到模板函数的具体定义，因为定义位于另一个源文件 "a.cpp" 中。
• 因此，当编译器在编译 "main.cpp" 时，它无法为 `Add` 函数生成特定类型的实例化代码，因为它没有模板定义的上下文。因此，编译器无法为 Add 函数生成特定类型的实例化代码。

2、解决方法

template<class T>
T Add(const T& left, const T& right);template<class T>
T Add(const T& left, const T& right)
{return left + right;
}