C++（第六篇）：模板详解（函数模板、类模板、非类型模板参数、模板特化、模板分离编译问题及一些题目）

前面的话

模板是C++支持参数化多态的工具，使用模板可以使用户为类或者函数声明一种一般模式，使得类中的某些数据成员或者成员函数的参数、返回值取得任意类型。使用模板的目的就是能够让程序员编写与类型无关的代码。比如编写了一个交换两个整型int 类型的swap函数，这个函数就只能实现int 型，对double，字符这些类型无法实现，要实现这些类型的交换就要重新编写另一个swap函数。使用模板的目的就是要让这程序的实现与类型无关，比如一个swap模板函数，即可以实现int 型，又可以实现double型的交换。模板可以应用于函数和类。

博客主页：要早起的杨同学的博客
欢迎关注点赞收藏⭐️留言
本文所属专栏： 【C++拒绝从入门到跑路】
✉️坚持和努力从早起开始！
参考在线编程网站：牛客网力扣
作者水平有限，如果发现错误，敬请指正！感谢感谢！

文章目录

• 一. 泛型编程
• 二. 函数模板
• • 2.1 函数模板概念
  • 2.2 函数模板格式
  • 2.3 函数模板的原理
  • 2.4 函数模板的实例化
  • • ① 概念
    • ② 隐式实例化
    • ③ 显式实例化
  • 2.5 模板参数的匹配原则
• 三. 类模板
• • 3.1 类模板的定义格式
  • • ① 格式：
    • ② 运用：
  • 3.2 类模板的实例化
• 四. 非类型模板参数
• 五. 模板特化
• • 5.1 概念
  • 5.2 函数模板特化
  • 5.3 类模板特化
  • • ① 全特化
    • ② 偏特化
• 六. 模板分离编译
• • 6.1 概念
  • 6.2 模板的分离编译
  • • ① 程序编译（）
    • ② 问题分析
    • ③ 解决方法
• 七. 一些题目
• 小结

一. 泛型编程

提问：如何实现一个通用的交换函数呢？

在我们学习模板之前，我们往往都是通过函数重载来解决这个问题：

void Swap(int& left, int& right)
{
	int temp = left;
	left = right;
	right = temp;
}
void Swap(double& left, double& right)
{
	double temp = left;
	left = right;
	right = temp;
}
void Swap(char& left, char& right)
{
	char temp = left;
	left = right;
	right = temp;
}

• 弊端：

1. 重载的函数仅仅只是类型不同，代码的复用率比较低，只要有新类型出现时，就需要增加对应的函数
2. 代码的可维护性比较低，一个出错可能所有的重载均出错

C++为了解决这样的问题，采用模板让编译器根据不同的类型利用该模子来生成相对应参数需要的函数代码，而这也就是泛型编程，对于广泛的类型参数都适用

泛型编程：编写与类型无关的通用代码，是代码复用的一种手段，模板是泛型编程的基础。

模板是一种对类型进行参数化的工具；通常有两种形式：函数模板和类模板；

1. 函数模板针对仅参数类型不同的函数；
2. 类模板针对仅数据成员和成员函数类型不同的类。

二. 函数模板 2.1 函数模板概念

函数模板代表了一个函数家族，该函数模板与类型无关，在使用时被参数化，根据实参类型产生函数的特定类型版本。

2.2 函数模板格式

template
返回值类型 函数名(参数列表){}

template
void Swap( T& left, T& right)
{
    T temp = left;
    left = right;
    right = temp;
}

注意：typename是用来定义模板参数关键字，也可以使用class(切记：不能使用struct代替class)

1. 如果模板参数列表中有多个类型的参数，每个参数前都必须要添加typename
2. 在模板参数列表中既可以使用typename声明类型，也可以使用class声明类型
3. 虽然在class和struct几乎相同，但在模板参数列表中不能使用struct来声明类型

2.3 函数模板的原理

• 模板是一个蓝图，它本身并不是函数，是编译器用使用方式产生特定具体类型函数的模具。所以其实模板就是将本来应该我们做的重复的事情交给了编译器
• 函数模板不是真正的函数，只是编译器生成代码的模具，是程序员给编译器指定了一种生成代码的规则

在编译器编译阶段，对于模板函数的使用，编译器需要根据传入的实参类型来推演生成对应类型的函数以供调用。比如：当用double类型使用函数模板时，编译器通过对实参类型的推演，将T确定为double类型，然后产生一份专门处理double类型的代码，对于字符类型也是如此。

2.4 函数模板的实例化 ① 概念

用不同类型的参数使用函数模板时，称为函数模板的实例化。

模板参数实例化分为：隐式实例化和显式实例化。

② 隐式实例化

让编译器根据实参推演模板参数的实际类型，用推演的结果替换模板参数列表中的T，最后生成具体对应类型的函数。 参数类型不能完全匹配时，编译器不会进行隐式类型转化，直接报错。

template
T Add(const T& left, const T& right)
{
    return left + right;
}
int main()
{
    int a1 = 10, a2 = 20;
    double d1 = 10.0, d2 = 20.0;
    Add(a1, a2);
    Add(d1, d2);
    
    // 此时有两种处理方式：1. 用户自己来强制转化 2. 使用显式实例化
    Add(a, (int)d);
    return 0;
}

③ 显式实例化

在函数名后的<>中指定模板参数的实际类型

int main(void)
{
    int a = 10;
    double b = 20.0;
    // 显式实例化
    Add(a, b);
    return 0;
}

如果类型不匹配，编译器会尝试进行隐式类型转换，如果无法转换成功编译器将会报错。

2.5 模板参数的匹配原则

 一个非模板函数可以和一个同名的函数模板同时存在，而且该函数模板还可以被实例化为这个非模板函数

// 专门处理int的加法函数
int Add(int left, int right)
{
    return left + right;
}
// 通用加法函数
template
T Add(T left, T right)
{
    return left + right;
}
void Test()
{
    Add(1, 2); // 与非模板函数匹配，编译器不需要特化
    Add(1, 2); // 调用编译器特化的Add版本
}

两个int类型的函数是不会产生冲突的，不会产生冲突的原因在于两个函数的函数名称其实是不一样的，模板函数的函数名称其实是Add 所以两者的函数名称是并不相同的东西。

 对于非模板函数和同名函数模板，如果其他条件都相同，在调动时会优先调用非模板函数而不会从该模板产生出一个实例。如果模板可以产生一个具有更好匹配的函数， 那么将选择模板

// 专门处理int的加法函数
int Add(int left, int right)
{
    return left + right;
}
// 通用加法函数
template
    T1 Add(T1 left, T2 right)
{
    return left + right;
}
void Test()
{
    Add(1, 2); // 与非函数模板类型完全匹配，不需要函数模板实例化
    Add(1, 2.0); // 模板函数可以生成更加匹配的版本，编译器根据实参生成更加匹配的Add函数
}

模板函数不允许自动类型转换，但普通函数可以进行自动类型转换

三. 类模板 3.1 类模板的定义格式 ① 格式：

template
class 类模板名
{
    // 类内成员定义
};

② 运用：

// 动态顺序表
// 注意：Vector不是具体的类，是编译器根据被实例化的类型生成具体类的模具
template
class Vector
{
    public :
    Vector(size_t capacity = 10)
        : _pData(new T[capacity])
            , _size(0)
            , _capacity(capacity)
        {}
    // 使用析构函数演示：在类中声明，在类外定义。
    ~Vector();
    void PushBack(const T& data)；
        void PopBack()；
        // ...
        size_t Size() {return _size;}
    T& operator[](size_t pos)
    {
        assert(pos < _size);
        return _pData[pos];
    }
    private:
    T* _pData;
    size_t _size;
    size_t _capacity;
};
// 注意：类模板中函数放在类外进行定义时，需要加模板参数列表
template 
Vector::~Vector()
{
    if(_pData)
        delete[] _pData;
    _size = _capacity = 0;
}

3.2 类模板的实例化

// Vector类名，Vector才是类型
Vector s1;
Vector s2;

解释：

类模板实例化与函数模板实例化不同，类模板实例化需要在类模板名字后跟<>，然后将实例化的类型放在<>中即可，类模板名字不是真正的类，而实例化的结果才是真正的类。

注意：一个模板，如果没有实例化，编译器是不会去检查它内部的语法的。

四. 非类型模板参数

模板参数分为「类型形参」与「非类型形参」，注意：不管哪种模板参数，都可以给「缺省值」。

• 类型形参：出现在模板参数列表中，跟在 class 或者 typename 之后的参数类型名称。

  // T: 类型模板参数，它是一个类型
  template  class A;
  

• 非类型形参：就是用一个常量作为类(函数)模板的一个参数，在类(函数)模板中可将该参数当成常量来使用。

  // T: 类型模板参数，它是一个类型
  // N: 非类型模板参数，它是一个常量
  template  class A;
  

  比如：C++11 增加了一个容器 array，就是一个静态数组，通过非类型模板参数来控制数组的大小：

  template < class T, size_t N > class array; // 不推荐使用，容易导致栈溢出（栈是非常小的）
  

 Example：只是举例子，不推荐这样写

现在实现了一个静态栈，可以存 10 个数据，实例化的每个对象都可以存 10 个数据，如果我想要第一个对象 st1 存 100 个数据，第二个对象存 200 个数据，这种结构就非常的不好。

#define N 10
template // 静态栈
class Stack 
{
private:
	T _a[N];
	size_t _top;
};

void test()
{
	Stack st1; // 10
    Stack st2; // 10
}

那该如何解决呢？-- 定义非类型模板参数(常量)：

template // 静态栈
class Stack 
{
private:
	T _a[N];
	size_t _top;
};

void test()
{
	Stack st1; // 100
	Stack st2; // 200
    
	
}

注意：

1. 浮点数、类对象以及字符串是不允许作为非类型模板参数的，一般都是用的 int 整型。
2. 非类型的模板参数必须在「编译期」就能确认结果。

拓展 & 思考：

1. C++ 缺点之一，后期如 C++11 等标准增加了不少鸡肋的语法，比如 array 和 forward_list，让语言变得很臃肿，学习成本增加。而一些刚需的东西，姗姗来迟，甚至还没来（比如官方的网络库）。
2. C++ 难点之一，C++ 的语法细节比较复杂。

---

五. 模板特化 5.1 概念

有时候，编译器默认实例化的函数模板或者类模板不能正确处理需要的逻辑，需要针对一些情况进行特殊化处理，就要做模板的特化。

通常情况下，使用模板可以实现一些与类型无关的代码，但对于一些特殊类型的可能会得到一些错误的结果。

比如：交换两个元素

template
void Swap(T& x, T& y)
{
	T tmp(x); 
    x = y; 
    y = tmp;
}

void test()
{
	int x = 1, y = 2;
	Swap(x, y);

	vector v1 = { 1, 2, 3, 4 };
	vector v2 = { 10, 20, 30, 40 };
	Swap(v1, v2); // 深拷贝式交换，代价太大，效率低
}

解决方案一：函数的匹配原则，写一个专门针对 vector 类型对象交换的函数：推荐这种

// 函数匹配原则，专门针对 vector 类型对象交换的函数 -- 推荐这种
void Swap(vector& v1, vector& v2)
{
	v1.swap(v2); // 只需要交换对象内部的几个指针即可
}

解决方案二：函数模板的特化，针对 vector 类型对象的交换进行特殊化处理：

// 函数模板的特化（针对某些具体类型进行特殊化处理） -- 最后还是要经过模板推演
template<>
void Swap>(vector& v1, vector& v2)
{
	v1.swap(v2);
}

此时，就需要对模板进行特化。即：在原模板类的基础上，针对特殊类型所进行特殊化的实现方式。

模板特化分为：函数模板特化与类模板特化。

---

5.2 函数模板特化

函数模板的特化步骤：

1. 必须要先有一个基础的函数模板。
2. 关键字 template 后面接一对空的尖括号 <>
3. 函数名后跟一对尖括号 <>，尖括号中指定需要特化的类型。
4. 函数形参表：必须要和 <> 中指定的类型完全相同，如果不同，编译器可能会报一些奇怪的错误。

template  // 基础函数模板
void add(T1& x, T2& y)
{
	cout << "void add(T1& x, T2& y)" << endl;
}

template<>
void add(int& x, char& y)  // 函数模板的特化
{
	cout << "void add" << endl;
}

void test()
{
	int a = 1, b = 2;
	add(a, b);   // 走基础函数模板

	int c = 1;
	char d = 'a';
	add(c, d); // 走特化的void add版本
}

注意：一般情况下如果函数模板遇到不能处理或者处理有误的类型，为了实现简单通常都是将该函数直接给出。

void add(int& x, char& y)
{
	cout << "void add(int& x, char& y)" << endl;
}

---

5.3 类模板特化

类模板的特化步骤：

1. 必须要先有一个基础的类模板。
2. 关键字 template 后面接一对空的尖括号 <>
3. 类名后跟一对尖括号 <>，尖括号中指定需要特化的类型。

类模板的特化分为：全特化 和 偏特化。

① 全特化

全特化：将模板参数列表中 所有的参数 都确定化。

template // 基础类模板
class Data
{
public:
	Data() { cout << "Data" << endl; }
private:
	T1 _d1;
	T2 _d2;
};

// 类模板的全特化 -- 最后还是要经过模板推演
// 将所有参数都确定化
template<>
class Data
{
public:
	Data() { cout << "Data" << endl; }
private:
	double _d1;
	double _d2;
};

void test()
{
	Data d1;       // 走基础类模板
	Data d2; // 走特化的double版本
}

② 偏特化

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

比如对于以下类模板：

template // 基础类模板
class Data
{
public:
	Data() { cout << "Data" << endl; }
private:
	T1 _d1;
	T2 _d2;
};

偏特化有两种表现方式：

1. 部分特化：将模板参数类表中的一部分参数特化。

   // 类模板的偏特化
   // 将部分参数确定化
   template
   class Data
   {
   public:
   	Data() { cout << "Data" << endl; }
   private:
   	T1 _d1;
   	char _d2;
   };
   
   void test()
   {
   	Data d1;  // 走基础类模板
   	Data d3; // 走特化版本
   }
   

2. 参数更进一步的限制：

   偏特化并不仅仅是指特化部分参数，而是针对模板参数更进一步的条件限制所设计出来的一个特化版本。

   // 不一定式特化部分参数，而是对参数更进一步的限制
   // 两个参数偏特化为指针类型
   template
   class Data
   {
   public:
   	Data() { cout << "Data" << endl; }
   private:
   	T1* _d1;
   	T2* _d2;
   };
   
   // 两个参数偏特化为引用类型
   template
   class Data
   {
   public:
   	Data(const T1& d1, const T2& d2) 
   		:_d1(d1)
   		,_d2(d2)
   	{ 
   		cout << "Data" << endl; 
   	}
   private:
   	const T1& _d1;
   	const T2& _d2;
   };
   
   void test()
   {
   	Data d1;         // 调用基础的类模板
       
       // 不管显示实例化什么类型的指针都可以
   	Data d4;      // 调用特化的指针版本
   	Data d5;       // 调用特化的指针版本
       
       // 不管显示实例化什么类型的引用都可以
       Data d6(1, 2); // 调用特化的引用版本
   }
   

---

六. 模板分离编译 6.1 概念

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

---

6.2 模板的分离编译

假如有以下场景，模板的声明与定义分离开，在头文件中进行声明，源文件中完成定义：

// func.h
template
T Add(const T& x, const T& y);
 
// func.cpp
#include"func.h"
template
T Add(const T& x, const T& y)
{
	return x + y;
}

// main.cpp
#include"func.h"
int main()
{
	Add(1, 2);
	Add(1.0, 2.0);
	return 0;
}

此段代码运行会报链接错误（链接错误一般是指在链接阶段找不到该函数的定义）：

无法解析的外部符号 "int __cdecl Add(int const &,int const &)" (??$Add@H@@YAHABH0@Z)，函数 _main 中引用了该符号

这是为什么呢？这就需要先了解下程序编译的过程了。

---

① 程序编译（）

编译 (compilation, compile) ，编译程序就是把从源语言编写的 源程序 产生 目标程序 的过程。 把高级语言变成计算机可以识别的二进制语言（因为计算机只认识 1 和 0）

 假设有如下代码：

// func.h
int Add(const int& x, int T& y); // 函数的声明
 
// func.cpp
#include"func.h"
int Add(const int& x, int T& y) // 函数的定义
{
	return x + y;
}

// main.cpp
#include"func.h"
int main()
{
	Add(1, 2);
	return 0;
}

C/C++程序要运行，一般要经历一下步骤：

预处理 --> 编译 --> 汇编 --> 链接

比如有 func.h、func.cpp、main.cpp 三个文件：

• 预处理：头文件展开、宏替换、条件编译、去掉注释等等。

  func.h、func.cpp、main.cpp -> func.i、main.i

• 编译：语法检查，函数实例化，生成汇编 .s 文件（注意：头文件不参与编译，编译器对工程中的多个源文件是分离开单独编译的）。

  func.i、main.i -> func.s、main.s

  汇编文件 .s 中存放的是汇编指令，在 main.s 文件中有一句调用函数的代码：

  00FD187C  call   @__CheckForDebuggerJustMyCode@4 (?)
  

  call 后面跟的这个 @__CheckForDebuggerJustMyCode@4 是编译器用函数名修饰规则修饰后的函数名，链接之前，括号中是没有地址的，因为 main.s 文件中只有函数的声明(头文件展开)，定义在 func.s 文件中，函数是声明与定义分离编译的，所以没有函数地址。

• 汇编：把汇编代码转成二进制机器码（CPU是不认识汇编代码的），生成 .o 目标文件

  func.s、main.s -> func.o、main.o

• 链接：将多个 .o 目标文件合并成一个可执行目标文件，并处理没有解决的地址问题（把 main.o 里面调用函数但没有函数地址的地方，拿函数名去其它目标文件 func.o 中找，找到以后填上，替换原来的*“虚假”*地址，再把目标文件合并到一起，生成可执行文件）

  注意：声明与定义分离编译的函数没有函数地址，声明和定义未分离编译的函数是有函数地址的

  func.o、main.o -> a.out

  此时你把 a.out 转成对应的汇编代码，那句调用函数的代码是这样的：

  00FD187C  call  @__CheckForDebuggerJustMyCode@4 (0FD1311h)
  

  括号中有函数地址，因为链接阶段，编译器通过函数名去函数定义的文件func.o中找到了函数的地址

---

② 问题分析

了解完程序编译的过程，模板的分离编译之所以会报链接错误，是因为在编译阶段生成汇编文件的过程（func.i -> func.s）就出现问题了。

函数模板的代码不能直接编译成二进制代码，需要有一个 “ 实例化 ” 的过程，而实例化要求编译器知道函数模板的定义。

再回到刚才的例子（将模板的声明和定义分离）：

// func.h
template
T Add(const T& x, const T& y); // 函数模板的声明
 
// func.cpp
#include"func.h"
template
T Add(const T& x, const T& y) // 函数模板的实现
{
	return x + y;
}
// func.cpp中没有调用Add函数的语句
// 所以Add和Add不会被实例化出来

// main.cpp
#include"func.h"
int main()
{
	Add(1, 2);     // call Add
	Add(1.0, 2.0); // call Add
	return 0;
}

分析：

在 main.cpp 中调用了 Add 和 Add 函数，但编译器并不知道函数模板的定义，因为它不在 func.h 里面，于是编译器只好寄希望于链接器，希望它能够在其它目标文件 func.o 中找到 Add 函数的实例（地址），然而，func. o 中并没有 Add 函数的二进制代码，因此链接时报错。

C++ 标准明确表示，当一个模板不被用到的时侯它就不该被实例化出来，在 func.cpp 中 没有调用过 Add 函数，所以在编译阶段 Add 函数模板 不会被实例化出来生成具体的代码，所以 func.i 编译汇编出来的 func.o 目标文件中没有关于 Add 函数的一行二进制代码，于是链接器只好给出一个链接错误。

但是，如果在 func.cpp 中写了一个函数，其中调用 Add 函数，或者显式指定实例化，则编译器会将其实例化出来，因为在 func.cpp 中，编译器知道模板的定义，所以能够实例化，于是，main.o 的符号导出表中也就有了 Add 函数的地址，链接器就能够完成任务，顺利生成可执行目标程序。

结论：

模板不支持分离编译

---

③ 解决方法

1. 不分离编译，将声明和定义放到一个文件 “xxx.h” 中，这样头文件展开后，main.cpp 中就有函数的定义，链接时就不需要去找函数的地址了，推荐使用这种。

2. 在模板定义的位置显式指定实例化。用一个类型就得显式实例化一个类型，很麻烦，不实用，不推荐使用。

   // func.h
   template
   T Add(const T& x, const T& y); // 函数模板的声明
    
   // func.cpp
   #include"func.h"
   template
   T Add(const T& x, const T& y) // 函数模板的实现
   {
   	return x + y;
   }
   template
   int Add(const int& x, const int& y); // 显示实例化函数模板
   template
   double Add(const double& x, const double& y); // 显示实例化函数模板
   
   // main.cpp
   #include"func.h"
   int main()
   {
   	Add(1, 2);     // call Add
   	Add(1.0, 2.0); // call Add
   	return 0;
   }
   

---

七. 一些题目

下面有关C++中为什么用模板类的原因，描述错误的是? ( ）

A.可用来创建动态增长和减小的数据结构

B.它是类型无关的，因此具有很高的可复用性

C.它运行时检查数据类型，保证了类型安全

D.它是平台无关的，可移植性

---

解释

A.模板可以具有非类型参数，用于指定大小，可以根据指定的大小创建动态结构

B.模板最重要的一点就是类型无关，提高了代码复用性

C.模板运行时不检查数据类型，也不保证类型安全，相当于类型的宏替换，故错误

D.只要支持模板语法，模板的代码就是可移植的

---

下列关于模板的说法正确的是（ ）

A.模板的实参在任何时候都可以省略

B.类模板与模板类所指的是同一概念

C.类模板的参数必须是虚拟类型的

D.类模板中的成员函数全是模板函数

---

解释

A.不一定，参数类型不同时有时需要显示指定类型参数

B.类模板是一个类家族，模板类是通过类模板实例化的具体类

C.C++中类模板的声明格式为template＜模板形参表声明＞＜类声明＞，并且类模板的成员函数都是模板函数

D.正确，定义时都必须通过完整的模板语法进行定义

---

下列的模板声明中，其中几个是正确的（ ）

template
template
template
template
template
template
template

template
template>
template

---

解释

1.模板语法错误，2.没有关键字class或typename指定类型，3.T2缺少class或typename，5.T2缺少class或typename，8.缺少template

4 6 7 9 10 11为正确声明

---

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

template
Type Max(const Type &a, const Type &b)
{
    cout<<"This is Max"< b ? a : b;
}

template<>
int Max(const int &a, const int &b)
{
    cout<<"This is Max"< b ? a : b;
}

template<>
char Max(const char &a, const char &b)
{
    cout<<"This is Max"< b ? a : b;
}

int Max(const int &a, const int &b)
{
    cout<<"This is Max"< b ? a : b;
}
int main()
{
    Max(10,20);
    Max(12.34,23.45);
    Max('A','B');
    Max(20,30);
}

选项

A.This is Max This is Max This is Max This is Max

B.This is Max This is Max This is Max This is Max

C.This is Max This is Max This is Max This is Max

D.This is Max This is Max This is Max This is Max

分析:

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

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

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

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

故答案为: A

---

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

template
class Data
{
public:
    Data() { cout << "Data" << endl; }
private:
    T1 _d1;
    T2 _d2;
};

template 
class Data
{
public:
    Data() { cout << "Data" << endl; }
private:
    T1 _d1;
    int _d2;
};

template 
class Data 
{
public:
    Data() { cout << "Data" << endl; }
private:
    T1 _d1;
    T2 _d2;
};

template 
class Data 
{
public:
    Data(const T1& d1, const T2& d2)
        : _d1(d1)
        , _d2(d2)
        {
            cout << "Data" << endl;
        }
private:
    const T1 & _d1;
    const T2 & _d2;
};

int main()
{
    Data d1;
    Data d2;
    Data d3;
    Data d4(1, 2);
}

选项

A.Data Data Data Data
B.Data Data Data Data
C.Data Data Data Data
D.Data Data Data Data

分析:

Data d1; // 调用特化的int版本

Data d2; // 调用基础的模板

Data d3; // 调用特化的指针版本

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

故答案为: C

---

小结

优点：

1. 模板复用了代码，节省资源，可以更快的迭代开发，C++的标准模板库(STL)因此而产生。
2. 增强了代码的灵活性。

缺陷：

1. 模板会导致代码膨胀问题，也会导致编译时间变长。
2. 出现模板编译错误时，错误信息非常凌乱，不易定位错误。