C++ 模板入门：函数模板、类模板与实例化机制

C++ 模板入门：函数模板、类模板与实例化机制

假设要写一个交换函数，最直接的做法是为每种类型分别提供重载：

void Swap(int& left, int& right);
void Swap(double& left, double& right);
void Swap(char& left, char& right);

这些函数除了类型不同，内部逻辑几乎完全一样。增加一种类型就复制一份代码，修改算法时还要同步维护所有重载。模板解决的正是这类问题：把与类型无关的算法写一次，具体类型版本交给编译器按需生成。

这篇文章从函数模板开始，讲清模板参数推导、显式实例化、重载匹配和类模板。模板语法并不难，真正容易出错的是"编译器何时生成代码"和"为什么某些调用推导失败"。

一、什么是泛型编程

泛型编程是编写能够适用于多种类型的通用代码。算法关注类型需要具备什么能力，而不是把类型名称写死。

交换两个对象需要的能力很简单：对象可以被复制或移动，并且可以赋值。至于对象是 int、double 还是自定义类型，交换步骤并没有本质区别。

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

调用方式和普通函数一样：

int a = 10;
int b = 20;
Swap(a, b);

double x = 1.5;
double y = 2.5;
Swap(x, y);

编译器根据实参推导 T。第一次调用得到 T = int，第二次调用得到 T = double，再分别生成可用的函数版本。

模板并不是"一个函数可以接收任意类型"。更准确地说，它是一份生成函数或类的规则。某个类型只有满足模板内部使用的操作，这次实例化才能通过编译。

二、函数模板的基本语法

函数模板以模板参数列表开头：

template <typename T>
返回类型 函数名(参数列表) {
    // 函数体
}

模板参数可以有多个：

template <typename T1, typename T2>
void PrintPair(const T1& first, const T2& second) {
    std::cout << first << ", " << second << '\n';
}

typename 和 class 有什么区别

在模板类型参数列表中，下面两种写法等价：

template <typename T>
void Func(const T& value);

template <class T>
void Func(const T& value);

这里的 class 表示"这是一个类型参数"，不要求传入类型必须是类。int、指针、结构体和类都可以作为 T。

不能把这个位置的 class 随意替换成 struct：

// template <struct T>  // 错误语法

现代 C++ 代码通常更偏爱 typename，因为它直接表达"类型名称"，但两种写法都很常见。

三、函数模板是怎样生成具体函数的

函数模板本身不是某个确定的普通函数。编译器看到模板调用后，会结合实参类型形成一个具体版本，这个过程称为实例化。
#mermaid-svg-yTPecpRKCkrHDEJ4{font-family:"trebuchet ms",verdana,arial,sans-serif;font-size:16px;fill:#333;}@keyframes edge-animation-frame{from{stroke-dashoffset:0;}}@keyframes dash{to{stroke-dashoffset:0;}}#mermaid-svg-yTPecpRKCkrHDEJ4 .edge-animation-slow{stroke-dasharray:9,5!important;stroke-dashoffset:900;animation:dash 50s linear infinite;stroke-linecap:round;}#mermaid-svg-yTPecpRKCkrHDEJ4 .edge-animation-fast{stroke-dasharray:9,5!important;stroke-dashoffset:900;animation:dash 20s linear infinite;stroke-linecap:round;}#mermaid-svg-yTPecpRKCkrHDEJ4 .error-icon{fill:#552222;}#mermaid-svg-yTPecpRKCkrHDEJ4 .error-text{fill:#552222;stroke:#552222;}#mermaid-svg-yTPecpRKCkrHDEJ4 .edge-thickness-normal{stroke-width:1px;}#mermaid-svg-yTPecpRKCkrHDEJ4 .edge-thickness-thick{stroke-width:3.5px;}#mermaid-svg-yTPecpRKCkrHDEJ4 .edge-pattern-solid{stroke-dasharray:0;}#mermaid-svg-yTPecpRKCkrHDEJ4 .edge-thickness-invisible{stroke-width:0;fill:none;}#mermaid-svg-yTPecpRKCkrHDEJ4 .edge-pattern-dashed{stroke-dasharray:3;}#mermaid-svg-yTPecpRKCkrHDEJ4 .edge-pattern-dotted{stroke-dasharray:2;}#mermaid-svg-yTPecpRKCkrHDEJ4 .marker{fill:#333333;stroke:#333333;}#mermaid-svg-yTPecpRKCkrHDEJ4 .marker.cross{stroke:#333333;}#mermaid-svg-yTPecpRKCkrHDEJ4 svg{font-family:"trebuchet ms",verdana,arial,sans-serif;font-size:16px;}#mermaid-svg-yTPecpRKCkrHDEJ4 p{margin:0;}#mermaid-svg-yTPecpRKCkrHDEJ4 .label{font-family:"trebuchet ms",verdana,arial,sans-serif;color:#333;}#mermaid-svg-yTPecpRKCkrHDEJ4 .cluster-label text{fill:#333;}#mermaid-svg-yTPecpRKCkrHDEJ4 .cluster-label span{color:#333;}#mermaid-svg-yTPecpRKCkrHDEJ4 .cluster-label span p{background-color:transparent;}#mermaid-svg-yTPecpRKCkrHDEJ4 .label text,#mermaid-svg-yTPecpRKCkrHDEJ4 span{fill:#333;color:#333;}#mermaid-svg-yTPecpRKCkrHDEJ4 .node rect,#mermaid-svg-yTPecpRKCkrHDEJ4 .node circle,#mermaid-svg-yTPecpRKCkrHDEJ4 .node ellipse,#mermaid-svg-yTPecpRKCkrHDEJ4 .node polygon,#mermaid-svg-yTPecpRKCkrHDEJ4 .node path{fill:#ECECFF;stroke:#9370DB;stroke-width:1px;}#mermaid-svg-yTPecpRKCkrHDEJ4 .rough-node .label text,#mermaid-svg-yTPecpRKCkrHDEJ4 .node .label text,#mermaid-svg-yTPecpRKCkrHDEJ4 .image-shape .label,#mermaid-svg-yTPecpRKCkrHDEJ4 .icon-shape .label{text-anchor:middle;}#mermaid-svg-yTPecpRKCkrHDEJ4 .node .katex path{fill:#000;stroke:#000;stroke-width:1px;}#mermaid-svg-yTPecpRKCkrHDEJ4 .rough-node .label,#mermaid-svg-yTPecpRKCkrHDEJ4 .node .label,#mermaid-svg-yTPecpRKCkrHDEJ4 .image-shape .label,#mermaid-svg-yTPecpRKCkrHDEJ4 .icon-shape .label{text-align:center;}#mermaid-svg-yTPecpRKCkrHDEJ4 .node.clickable{cursor:pointer;}#mermaid-svg-yTPecpRKCkrHDEJ4 .root .anchor path{fill:#333333!important;stroke-width:0;stroke:#333333;}#mermaid-svg-yTPecpRKCkrHDEJ4 .arrowheadPath{fill:#333333;}#mermaid-svg-yTPecpRKCkrHDEJ4 .edgePath .path{stroke:#333333;stroke-width:2.0px;}#mermaid-svg-yTPecpRKCkrHDEJ4 .flowchart-link{stroke:#333333;fill:none;}#mermaid-svg-yTPecpRKCkrHDEJ4 .edgeLabel{background-color:rgba(232,232,232, 0.8);text-align:center;}#mermaid-svg-yTPecpRKCkrHDEJ4 .edgeLabel p{background-color:rgba(232,232,232, 0.8);}#mermaid-svg-yTPecpRKCkrHDEJ4 .edgeLabel rect{opacity:0.5;background-color:rgba(232,232,232, 0.8);fill:rgba(232,232,232, 0.8);}#mermaid-svg-yTPecpRKCkrHDEJ4 .labelBkg{background-color:rgba(232, 232, 232, 0.5);}#mermaid-svg-yTPecpRKCkrHDEJ4 .cluster rect{fill:#ffffde;stroke:#aaaa33;stroke-width:1px;}#mermaid-svg-yTPecpRKCkrHDEJ4 .cluster text{fill:#333;}#mermaid-svg-yTPecpRKCkrHDEJ4 .cluster span{color:#333;}#mermaid-svg-yTPecpRKCkrHDEJ4 div.mermaidTooltip{position:absolute;text-align:center;max-width:200px;padding:2px;font-family:"trebuchet ms",verdana,arial,sans-serif;font-size:12px;background:hsl(80, 100%, 96.2745098039%);border:1px solid #aaaa33;border-radius:2px;pointer-events:none;z-index:100;}#mermaid-svg-yTPecpRKCkrHDEJ4 .flowchartTitleText{text-anchor:middle;font-size:18px;fill:#333;}#mermaid-svg-yTPecpRKCkrHDEJ4 rect.text{fill:none;stroke-width:0;}#mermaid-svg-yTPecpRKCkrHDEJ4 .icon-shape,#mermaid-svg-yTPecpRKCkrHDEJ4 .image-shape{background-color:rgba(232,232,232, 0.8);text-align:center;}#mermaid-svg-yTPecpRKCkrHDEJ4 .icon-shape p,#mermaid-svg-yTPecpRKCkrHDEJ4 .image-shape p{background-color:rgba(232,232,232, 0.8);padding:2px;}#mermaid-svg-yTPecpRKCkrHDEJ4 .icon-shape .label rect,#mermaid-svg-yTPecpRKCkrHDEJ4 .image-shape .label rect{opacity:0.5;background-color:rgba(232,232,232, 0.8);fill:rgba(232,232,232, 0.8);}#mermaid-svg-yTPecpRKCkrHDEJ4 .label-icon{display:inline-block;height:1em;overflow:visible;vertical-align:-0.125em;}#mermaid-svg-yTPecpRKCkrHDEJ4 .node .label-icon path{fill:currentColor;stroke:revert;stroke-width:revert;}#mermaid-svg-yTPecpRKCkrHDEJ4 :root{--mermaid-font-family:"trebuchet ms",verdana,arial,sans-serif;} 函数模板 Swap(T&, T&)
Swap(int&, int&)
Swap(double&, double&)
Swap(char&, char&)
不同类型的调用

可以把下面的模板：

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

理解成编译器按需生成类似这样的函数：

void Swap_int(int& left, int& right) {
    int temp = left;
    left = right;
    right = temp;
}

void Swap_double(double& left, double& right) {
    double temp = left;
    left = right;
    right = temp;
}

这只是帮助理解的等价模型，真实函数名称、符号修饰和代码合并由编译器决定。

模板不会凭空赋予类型能力

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

Add 要求 T 类型的两个对象可以执行 +，并且结果能够作为 T 返回。int 和 double 满足要求；某个没有定义加法的自定义类型在实例化时会编译失败。

模板的通用性来自"延迟确定类型"，不是绕过类型检查。实例化后的代码仍然要遵守完整的 C++ 类型规则。

四、隐式实例化与显式实例化

函数模板有两种常见使用方式：让编译器自行推导模板参数，或者在函数名后明确写出模板实参。

1. 隐式实例化

#include <iostream>

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

int main() {
    int intResult = Add(10, 20);
    double doubleResult = Add(1.5, 2.5);

    std::cout << intResult << '\n';
    std::cout << doubleResult << '\n';
}

编译器从 Add(10, 20) 推导出 T = int，从 Add(1.5, 2.5) 推导出 T = double。

编译运行：

g++ function_template.cpp -std=c++11 -o function_template
./function_template

预期输出：

30
4

2. 两个实参推导出不同的 T

下面的调用无法完成模板实参推导：

int number = 10;
double decimal = 2.5;

// Add(number, decimal);  // 推导失败

第一个实参要求 T 是 int，第二个实参要求 T 是 double。模板参数列表中只有一个 T，编译器不能自行选择其中一个。

很多初学者会把这个现象概括成"模板不允许类型转换"，这句话不够准确。问题发生在模板实参推导阶段：编译器通常不会先把某个实参转换成另一种类型，再用转换后的结果消除推导冲突。

可以在调用处明确转换：

int result = Add(number, static_cast<int>(decimal));

也可以显式指定 T：

int result = Add<int>(number, decimal);

指定 T = int 后，不再需要从两个实参推导 T。此时参数类型已经确定为 const int&，decimal 可以按照普通函数调用规则转换为 int。小数部分会丢失，这也是显式指定类型时必须注意的语义变化。

3. 显式写出模板实参

模板实参写在函数名后的尖括号中：

Add<int>(10, 20);
Add<double>(10, 20.5);

这常被口头称为显式实例化调用。严格区分术语时，它属于"显式指定模板实参"；独立的显式实例化声明或定义还有专门语法。入门阶段先记住它的实际作用：模板参数不再完全依赖编译器推导。

4. 使用多个类型参数

如果函数本来就应该接收不同类型，可以为两个参数分别设置模板类型：

template <typename T1, typename T2>
auto Add(const T1& left, const T2& right) -> decltype(left + right) {
    return left + right;
}

现在下面的调用可以直接成立：

auto result = Add(10, 2.5);  // 结果类型由 int + double 决定

这里使用 C++11 的尾置返回类型和 decltype，避免简单地把返回类型写成 T1。如果写成 T1，Add(10, 2.5) 的计算结果会被转换回 int，容易在不经意间丢失小数。

五、普通函数与函数模板如何匹配

普通函数可以和同名函数模板同时存在：

#include <iostream>

void Print(int value) {
    std::cout << "ordinary: " << value << '\n';
}

template <typename T>
void Print(T value) {
    std::cout << "template: " << value << '\n';
}

int main() {
    Print(10);
    Print(3.14);
    Print<int>(20);
}

预期输出：

ordinary: 10
template: 3.14
template: 20

三次调用的选择过程不同：

调用	选择结果	原因
Print(10)	普通函数	两边都能精确匹配，优先普通函数
Print(3.14)	模板生成的函数	模板能精确匹配 double，普通函数需要转换成 int
Print<int>(20)	模板生成的函数	尖括号明确要求使用模板

"有普通函数就一定不用模板"也是错误理解。重载决议会先比较匹配质量；普通函数只有在匹配程度不差于模板生成函数时，才会因为非模板身份获得优先。

模板版本可以生成与普通函数相同的签名

int Add(int left, int right) {
    return left + right;
}

template <typename T>
T Add(T left, T right) {
    return left + right;
}

Add(1, 2) 调用普通函数，Add<int>(1, 2) 则明确使用模板生成的 int 版本。两者可以同时存在，编译器会根据调用表达式完成选择。

六、类模板：让一种数据结构适配多种元素类型

函数模板复用算法，类模板复用类型结构。一个栈可以保存整数、浮点数或自定义对象，入栈和出栈规则并不会因为元素类型不同而改变。

类模板的基本格式如下：

template <typename T>
class ClassName {
    // 成员定义
};

下面实现一个可运行的简化栈。为了让示例具备完整生命周期，代码补上了析构、扩容和边界检查，并禁止直接拷贝，避免默认浅拷贝带来的重复释放。

#include <cstddef>
#include <iostream>
#include <stdexcept>

template <typename T>
class Stack {
public:
    explicit Stack(std::size_t capacity = 4)
        : _array(new T[capacity]),
          _capacity(capacity),
          _size(0) {
    }

    ~Stack() {
        delete[] _array;
    }

    Stack(const Stack&) = delete;
    Stack& operator=(const Stack&) = delete;

    void Push(const T& value) {
        if (_size == _capacity) {
            Expand();
        }

        _array[_size] = value;
        ++_size;
    }

    void Pop() {
        if (_size == 0) {
            throw std::out_of_range("stack is empty");
        }
        --_size;
    }

    const T& Top() const {
        if (_size == 0) {
            throw std::out_of_range("stack is empty");
        }
        return _array[_size - 1];
    }

    std::size_t Size() const {
        return _size;
    }

private:
    void Expand() {
        std::size_t newCapacity = _capacity == 0 ? 1 : _capacity * 2;
        T* newArray = new T[newCapacity];

        for (std::size_t i = 0; i < _size; ++i) {
            newArray[i] = _array[i];
        }

        delete[] _array;
        _array = newArray;
        _capacity = newCapacity;
    }

private:
    T* _array;
    std::size_t _capacity;
    std::size_t _size;
};

int main() {
    Stack<int> numbers;
    numbers.Push(10);
    numbers.Push(20);
    std::cout << numbers.Top() << '\n';

    Stack<double> decimals;
    decimals.Push(3.14);
    std::cout << decimals.Top() << '\n';
}

编译运行：

g++ stack_template.cpp -std=c++11 -o stack_template
./stack_template

预期输出：

20
3.14

Stack 和 Stack 的区别

Stack 是类模板名称，它描述怎样生成一组类。Stack<int> 才是使用 int 实例化后得到的具体类型：

Stack<int> intStack;
Stack<double> doubleStack;

Stack<int> 与 Stack<double> 是两个不同类型。它们的数据布局和成员函数都围绕各自的 T 形成，二者不能随意互相赋值。

七、类模板成员函数写在类外时怎么写

成员函数可以在类模板内部定义，也可以放在类定义之后。写在类外时，必须重新声明模板参数，并指明成员属于 Stack<T>：

template <typename T>
class Stack {
public:
    void Push(const T& value);

private:
    T* _array = nullptr;
    std::size_t _size = 0;
};

template <typename T>
void Stack<T>::Push(const T& value) {
    _array[_size] = value;
    ++_size;
}

这段定义中有三个容易漏掉的部分：

1. 函数定义前仍要写 template <typename T>。
2. 作用域必须写成 Stack<T>::，不能只写 Stack::。
3. 参数中的 T 来自当前这次类模板实例化。

上面的片段只用于说明类外定义语法，没有包含空间申请和越界处理。实际使用时应采用前一节那种生命周期完整的实现。

八、为什么模板通常把声明和定义放在头文件

普通函数可以把声明放在头文件，把定义放在 .cpp 文件中，因为编译 .cpp 时就能生成目标代码。模板的情况不同：编译器通常要在看到具体模板实参后，才能生成对应版本。

假设头文件里只有声明：

// stack.hpp
template <typename T>
class Stack {
public:
    void Push(const T& value);
};

定义被单独放进 stack.cpp：

// stack.cpp
template <typename T>
void Stack<T>::Push(const T& value) {
    // ...
}

另一个编译单元使用 Stack<int> 时，只看到了模板声明，没有看到 Push<int> 所需的定义，最终可能出现链接错误。

常见组织方式有两种：

• 直接把模板声明和定义都放在 .hpp 文件中。
• 将定义放在 .tpp 或 .ipp 文件中，再由 .hpp 在末尾包含该文件。

也可以在实现文件中为确定类型进行显式实例化，但这样只会生成事先列出的类型版本，失去了随意适配新类型的便利。对通用类模板而言，让定义在实例化位置可见通常最省心。

九、常见问题与易错点

1. 把模板理解成一个万能函数

模板只有在具体类型支持函数体中的操作时才能实例化。模板内部写了 left + right，传入类型就必须支持相应加法表达式。

2. 两个不同类型推导同一个 T

template <typename T>
T Add(T left, T right);

// Add(1, 2.5);  // T 同时被推导为 int 和 double

解决方式是显式转换、指定模板实参，或者把模板改成两个类型参数。选哪一种取决于函数语义，不要只为了通过编译就随意截断数据。

3. 认为模板推导会主动寻找所有转换路径

推导的目标是从实参结构确定模板参数，不是穷举转换方案。显式给出模板实参后，剩余参数才按照已经确定的函数参数类型参与普通转换检查。

4. 忘记尖括号中的类型才构成具体类

在 C++11 的常规类模板语法中，要写 Stack<int> object;，不能只写 Stack object;。Stack 是生成类的模板，Stack<int> 才是类型。

5. 类外定义成员时漏写模板声明

template <typename T>
void Stack<T>::Push(const T& value) {
    // ...
}

template <typename T> 和 Stack<T>:: 都不能省略。

6. 把模板定义单独藏在 cpp 文件里

如果使用模板的编译单元看不到定义，就可能无法生成对应实例。把模板定义放进头文件，或者采用头文件包含 .tpp 的组织方式。

7. 只关注类型复用，忽略资源管理

类模板里只要出现 new[]，就要同步考虑析构、拷贝和赋值。模板不会自动修复浅拷贝问题。入门实现可以像示例那样先禁用拷贝，后续再补充深拷贝或移动语义。

8. 被很长的模板错误信息带偏

模板报错经常展开多层实例化信息。排查时先找最早出现的"由此实例化"位置，再看具体类型不支持哪个表达式。错误的根源通常仍是普通问题：没有对应运算符、参数类型冲突、成员不存在或定义不可见。

十、模板适合解决什么问题

模板适合"处理逻辑相同，参与类型不同"的场景：

• 通用算法，例如交换、比较、查找和排序。
• 通用数据结构，例如栈、队列和动态数组。
• 只依赖某种操作能力，而不关心具体类型名称的工具函数。

如果不同类型需要完全不同的业务流程，强行塞进一个模板只会增加判断和阅读成本。模板的价值是消除真正重复的类型代码，不是把所有函数都改成带尖括号的形式。

十一、总结

函数模板是一份生成函数的规则，编译器根据实参推导模板参数，再形成具体函数。推导阶段遇到同一个模板参数对应多个冲突类型时，不会擅自选择转换方向；可以通过显式转换、指定模板实参或增加模板参数解决。

普通函数和函数模板可以同名共存。匹配质量更好的候选优先，匹配程度相同时通常选择普通函数。显式写出尖括号则可以明确要求使用模板版本。

类模板用于生成具体类，Stack 是模板名称，Stack<int> 才是类型。模板定义通常要对实例化位置可见，因此常与声明一起放在头文件中。理解"模板是生成规则，实例才是具体代码"，后面的模板特化、标准容器和泛型算法就都有了落脚点。