三个交换函数,三份代码只差类型:
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;
}重载能解决调用问题,代价写在明面上:每出现一种新类型就要补一份实现,重复的代码越多,改动时需要同步的地方越多,一份写错往往一排都错。模板要做的就是把“类型”从代码里抽出来,留一个空位给编译器填。
从三个重载到一个模板
泛型编程(generic programming)指的是编写与类型无关的通用代码,模板是它的基础。课件用铸造打了个比方:同一个模具,浇进钢水、绿色塑料、蓝色材料,得到形状相同、材质不同的铸件。

写法只有多出的一行:
template <typename T1, typename T2, typename Tn>
返回类型 函数名(参数列表)
{
}交换函数落到模板上是这样:
template <typename T>
void Swap(T& left, T& right)
{
T temp = left;
left = right;
right = temp;
}typename 是声明类型模板参数的关键字,class 在这里完全等价,写哪个都行;struct 不行。参数列表里出现几次 T,就有几处必须推导成同一个类型。
模板本身不是函数,实例化才生成代码
函数模板(function template)是编译器生成函数用的蓝图,它自己不是函数,也就没有对应的机器码。编译阶段遇到一次具体调用,编译器按实参把 T 定下来,再生成一份专用函数。Swap 被 int、double、char 各调用一次,目标文件里就是三份互不相干的函数,各自占一段代码。
这意味着模板的抽象发生在编译期:没有虚函数表,没有运行时的类型判断,生成的代码和手写三份几乎一样快。代价也在这里——它不省目标文件的体积,只省写重复代码的工夫;类型用得越多,生成的代码越多。

隐式实例化:Add(a1, d1) 为什么推不出来
用不同类型去使用模板,叫函数模板的实例化。不给尖括号、让编译器从实参推,是隐式实例化:
#include <iostream>
template <class T>
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;
std::cout << Add(a1, a2) << '\n'; /* T 推成 int */
std::cout << Add(d1, d2) << '\n'; /* T 推成 double */
/* Add(a1, d1); a1 要求 T = int,d1 要求 T = double,一个参数两个答案 */
std::cout << Add(a1, static_cast<int>(d1)) << '\n'; /* 自己转 */
std::cout << Add<int>(a1, d1) << '\n'; /* 显式指定 T */
return 0;
}Add(a1, d1) 编不过,原因不是 int 和 double 不能相加,而是模板参数只有一个 T。编译器从 a1 推出 int,从 d1 推出 double,两个结论冲突,推导失败,GCC 的报错里会出现 deduced conflicting types for parameter 'T'。
处理办法有三种:
- 调用处自己转换:
Add(a1, static_cast<int>(d1)),由调用者承担精度损失; - 显式实例化:
Add<int>(a1, d1),尖括号里写死T,剩下的交给普通函数匹配规则; - 把模板改成两个参数:
template <class T1, class T2>
T1 Add(T1 left, T2 right)
{
return left + right;
}第三种看起来最省事,但返回值押在 T1 上:Add(1, 2.5) 返回 int,结果是 3 而不是 3.5。三种做法各有代价,模板替不了类型决策。
课件有一句“模板函数不允许自动类型转换,但普通函数可以进行自动类型转换”,方向对,边界要说清:推导阶段确实不做转换,T 必须从实参唯一确定;一旦尖括号里写死了 T,推导结束,后面的匹配就是普通函数调用那一套,double 转 int 照常发生。推导阶段允许的调整只有几种不改变值的:数组退化成首元素指针、函数退化成函数指针、去掉顶层 const 和引用。
同名普通函数站在模板前面
一个普通函数和一个同名模板可以同时存在,挑选顺序有两条规则:
- 两者都精确匹配时,优先选普通函数,不为这组实参生成模板实例;
- 如果模板能生成一个更匹配的版本,就选模板。
#include <iostream>
int Add(int left, int right) { return left + right; }
template <class T1, class T2>
T1 Add(T1 left, T2 right) { return left + right; }
int main()
{
std::cout << Add(1, 2) << '\n'; /* 普通函数,两个实参都精确匹配 */
std::cout << Add(1, 2.0) << '\n'; /* 模板生成 Add(int, double),比截断更匹配 */
std::cout << Add<int>(1, 2) << '\n'; /* 显式指定,直接走模板 */
return 0;
}Add(1, 2.0) 这一行如果只有普通函数,2.0 会被截断成 2 再调用;有模板在,编译器宁可生成一份新代码,也不做这次有损转换。第三条调用写了 Add<int>,模板参数已经指定,普通函数不再是候选,走的是模板实例。
这也解释了一个常见困惑:新写的模板没人调用,很可能是同名的普通函数一直挡在前面。
类模板:Stack<int> 才是类型
类模板(class template)的格式与函数模板一致,只是把函数换成类:
template <class T1, class T2, class Tn>
class 类模板名
{
/* 类内成员定义 */
};课件给的 Stack 是个能说明语法、但不能直接用的版本:Push 的注释写着“扩容”,函数体里只有 _array[_size] = data; ++_size;,容量用满就写出界;类里没有析构函数,构造时 new T[capacity] 申请的空间没人释放;裸指针成员配上编译器自动生成的拷贝构造,复制出来的两个对象会对同一块内存各 delete[] 一次。
把这三处补上:
#include <cstddef>
template <class T>
class Stack
{
public:
explicit Stack(std::size_t capacity = 4)
: _array(new T[capacity]), _capacity(capacity), _size(0)
{
}
Stack(const Stack&) = delete;
Stack& operator=(const Stack&) = delete;
~Stack() { delete[] _array; }
void Push(const T& data);
bool Empty() const { return _size == 0; }
private:
T* _array;
std::size_t _capacity;
std::size_t _size;
};
template <class T>
void Stack<T>::Push(const T& data)
{
if (_size == _capacity)
{
std::size_t newCap = _capacity == 0 ? 4 : _capacity * 2;
T* tmp = new T[newCap];
for (std::size_t i = 0; i < _size; ++i)
tmp[i] = _array[i];
delete[] _array;
_array = tmp;
_capacity = newCap;
}
_array[_size++] = data;
}
int main()
{
Stack<int> st1;
Stack<double> st2;
st1.Push(1);
st2.Push(1.5);
return 0;
}成员函数写在类外,每一份前面都要带上自己的模板头 template <class T>,名字写成 Stack<T>::Push。漏掉模板头,编译器报的是“Stack 不是模板”,和真正的问题隔了一层。
Stack 是模板名,Stack<int> 才是类型。上面的 main 里,Stack<int> st1; 让编译器生成一个以 int 为元素的类,Stack<double> st2; 再生成另一份,两个类的成员函数彼此独立。直接写 Stack st; 编译不过,因为 Stack 自己没有类型。
C++17 起,构造函数能从实参推出类型时可以省尖括号(类模板实参推导,CTAD),比如 std::vector v{1, 2, 3};Stack<int> st1; 这里没有实参可推,仍然得写。

上面的 Push 用赋值搬元素,要求 T 可默认构造、可赋值,换成只可移动的类型就不够用了;真实容器的扩容会用定位 new 加移动构造。这里先保证不越界、不漏内存,异常安全和移动语义留到进阶。
定义不能拆到 .cpp
课件说“模板不建议声明和定义分离到两个文件,会出现链接错误”。这不是建议,是做不到——除非把用到的类型显式实例化出来。
编译器按翻译单元工作。main.cpp 里只看到 template <class T> T Add(const T&, const T&) 的声明,没有函数体,无法生成机器码;a.cpp 里有定义,但那个文件里没有任何调用,编译器不会主动替所有可能的类型生成实例。两边都没有 Add<int> 的代码,链接器只能报 undefined reference。
解法两种。常规做法是把声明和定义都放进头文件,每个包含它的翻译单元都能当场实例化,标准库的模板全在头文件里;另一种是在某个 .cpp 里显式实例化需要的类型:
template int Add<int>(const int&, const int&);
template double Add<double>(const double&, const double&);第二种可行,但每新增一种类型就要回来加一行,类型集合一大就没人维护得住,它更适合给外部提供预编译好的模板库。
定义全放头文件也有副作用:改一个字符,所有包含它的源文件都要重编,模板多的工程编译慢,一半原因在这里。模板报错也长,一个写错的小函数能拉出十几层“在此实例化”,真正的根因通常在最后那行 no matching function。
还没有评论 — 第一条由你来留。