C++模板入门：从“写三遍交换函数”到一次搞定

C++模板入门：从“写三遍交换函数”到一次搞定

本文是 《现代C++模板深度解析》 专栏的第一篇。我们将从最朴素的代码痛点出发，一步步理解C++为什么需要模板，以及模板如何做到“一次定义，多类型适配”。

文章目录

• C++模板入门：从“写三遍交换函数”到一次搞定
• • 一、从一个小需求说起
  • 二、宏定义能解决吗？
  • 三、模板：一次定义，多类型适配
  • • 3.1 函数模板的基本语法
    • 3.2 模板的实例化
    • 3.3 完整可运行示例
  • 四、模板 vs 宏：为什么模板更安全
  • 五、初步理解：模板不是“一个函数”，而是“一族函数”
  • 六、总结与下一篇预告

一、从一个小需求说起

假设你正在写一个工具库，需要一个交换两个变量的函数。这还不简单？三行代码搞定：

void swapInt(int& a, int& b) {
int temp = a;
a = b;
b = temp;
}

但很快，产品经理说：“double 类型也要交换。” 于是你复制粘贴，改个类型名：

void swapDouble(double& a, double& b) {
double temp = a;
a = b;
b = temp;
}

接着，std::string 也要交换，自定义的 Student 类也要交换……你发现自己的代码里出现了大量长得几乎一模一样的函数，唯一的区别就是类型。

这就是函数重载的困境：逻辑完全相同，却要为每种类型重复编写。更麻烦的是，如果某天交换逻辑需要修改（比如加入日志），你得把所有重载版本都改一遍，漏掉一个就是隐藏的 bug。

二、宏定义能解决吗？

有过C语言经验的开发者会想到宏：

#define SWAP(a, b) do { auto temp = a; a = b; b = temp; } while(0)

宏确实可以做到“一次定义，多类型使用”。但它有几个致命缺陷：

宏是“文本替换”，而我们需要的是“类型安全的代码生成”。这正是模板要解决的问题。

三、模板：一次定义，多类型适配

C++ 的 函数模板 允许我们定义一个“类型参数化”的函数。编译器会根据调用时传入的实参类型，自动生成对应的函数版本。

3.1 函数模板的基本语法

template<typename T>
void mySwap(T& a, T& b) {
T temp = a;
a = b;
b = temp;
}

• template<typename T> 声明这是一个模板，T 是类型参数（也可以用 class 代替 typename，二者在此处等价）。
• T& 表示接受任意类型的引用。
• 函数体内 T 就像一个普通类型名，可以声明变量、传递参数。

3.2 模板的实例化

当你写下 mySwap(x, y) 时，编译器会进行 模板实参推导，根据 x 和 y 的类型推断出 T 的具体类型，然后生成一个专门处理该类型的函数。这个过程称为 实例化。

int a = 10, b = 20;
mySwap(a, b); // 编译器生成 mySwap<int>(int&, int&)

double c = 3.14, d = 2.71;
mySwap(c, d); // 编译器生成 mySwap<double>(double&, double&)

std::string e = "foo", f = "bar";
mySwap(e, f); // 编译器生成 mySwap<std::string>(std::string&, std::string&)

注意：模板本身不是函数，而是生成函数的“蓝图”。只有被调用时，编译器才会根据具体类型生成真正的函数代码。

3.3 完整可运行示例

#include <iostream>
#include <string>

// 普通重载版本：每种类型都要写一遍
void swapInt(int& a, int& b) {
int temp = a;
a = b;
b = temp;
}

void swapDouble(double& a, double& b) {
double temp = a;
a = b;
b = temp;
}

void swapString(std::string& a, std::string& b) {
std::string temp = a;
a = b;
b = temp;
}

// 模板版本：一次定义，多类型适配
template<typename T>
void mySwap(T& a, T& b) {
T temp = a;
a = b;
b = temp;
}

int main() {
// 使用普通重载
int x = 1, y = 2;
swapInt(x, y);
std::cout << "x=" << x << ", y=" << y << std::endl;

double d1 = 1.1, d2 = 2.2;
swapDouble(d1, d2);
std::cout << "d1=" << d1 << ", d2=" << d2 << std::endl;

std::string s1 = "hello", s2 = "world";
swapString(s1, s2);
std::cout << "s1=" << s1 << ", s2=" << s2 << std::endl;

// 使用模板
int a = 10, b = 20;
mySwap(a, b);
std::cout << "a=" << a << ", b=" << b << std::endl;

double c = 3.14, d = 2.71;
mySwap(c, d);
std::cout << "c=" << c << ", d=" << d << std::endl;

std::string e = "foo", f = "bar";
mySwap(e, f);
std::cout << "e=" << e << ", f=" << f << std::endl;

return 0;
}

输出结果：

x=2, y=1
d1=2.2, d2=1.1
s1=world, s2=hello
a=20, b=10
c=2.71, d=3.14
e=bar, f=foo

可以看到，模板版本的 mySwap 用一份代码完成了三种类型的交换，而且代码逻辑清晰、类型安全。

四、模板 vs 宏：为什么模板更安全

模板的本质是 编译期的代码生成器：你给出逻辑框架，编译器根据具体类型填充细节。它既保留了代码复用的优势，又避免了宏的种种陷阱。

五、初步理解：模板不是“一个函数”，而是“一族函数”

当你写下 template<typename T> void mySwap(T&, T&) 时，你并没有定义一个具体的函数，而是定义了一个 函数模板。编译器在遇到 mySwap(a, b) 时，才会根据 a、b 的类型生成一个具体的函数实例。

这种“按需生成”的机制带来两个重要特性：

六、总结与下一篇预告

本文从“写三遍交换函数”的痛点出发，介绍了函数模板的基本语法、实例化过程，以及它相比宏定义的优势。模板让C++具备了 泛型编程 的能力：用一份逻辑处理多种类型，同时保持类型安全和运行效率。

下一篇我们将深入 函数模板的推导规则与重载决议，回答几个关键问题：

• f(1, 2.0) 这样的调用，模板参数 T 会推导成什么？
• 函数模板和普通函数重载同时存在时，编译器优先选择谁？
• 显式实例化和隐式实例化有什么区别？

敬请期待《函数模板的推导规则与重载决议：一次讲透》。

面试视角 面试官可能会问：“函数模板和宏有什么区别？”或“模板为什么能实现类型安全？” 回答时抓住两点：编译期类型推导与检查，以及按需实例化生成具体代码。如果能举出宏的副作用例子，会是不错的加分项。