三个交换函数,三份代码只差类型:

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 各调用一次,目标文件里就是三份互不相干的函数,各自占一段代码。

这意味着模板的抽象发生在编译期:没有虚函数表,没有运行时的类型判断,生成的代码和手写三份几乎一样快。代价也在这里——它不省目标文件的体积,只省写重复代码的工夫;类型用得越多,生成的代码越多。

中间的模板只有一份,三组实参从左边进来,编译器分别把它们推成 double、int、char,在右边生成三个只看类型就能区分的 Swap。箭头标的是“类型推演”,不是运行时的分支

隐式实例化: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'。

处理办法有三种:

  1. 调用处自己转换:Add(a1, static_cast<int>(d1)),由调用者承担精度损失;
  2. 显式实例化:Add<int>(a1, d1),尖括号里写死 T,剩下的交给普通函数匹配规则;
  3. 把模板改成两个参数:
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; 这里没有实参可推,仍然得写。

图把模板分成两支:上面是函数模板,下面是类模板。这张图只画到分类为止;再往下,函数模板靠实参推类型,类模板要在名字后面写 Stack<int> 这样的类型

上面的 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。