模板与泛型编程
编写类型无关的模板代码并理解其编译机制
#模板不是"泛型擦除"
如果你熟悉 Java 泛型,请先忘掉它的一部分。Java 的泛型是类型擦除:List<String> 和 List<Integer> 在运行时是同一个 List,编译器插入强制转换,所以 new T()、new T[]、基本类型做类型参数统统做不到。
C++ 模板是完全不同的机制:实例化。std::vector<int> 和 std::vector<std::string> 是编译器生成的两份完全独立的代码,各有一份机器指令。这带来三个后果:
- 零运行时开销:没有装箱拆箱,没有类型转换,
vector<int>里就是紧密排列的 int。 - 类型参数可以是基本类型,甚至是非类型的值(见后文)。
- 代码膨胀:每个实例化都会产生一份代码,编译也慢一些。
Python 走的是第三条路——鸭子类型:根本不做类型检查,运行时有 __len__ 就能 len()。C++ 模板介于两者之间:编译期检查,但不要求类型之间有任何继承关系,只要"能用这些操作符"就行,这在精神上最接近 Python 的鸭子类型,只是把检查提前到了编译期。
#函数模板
语法是 template <typename T> 加在函数前面。typename 和 class 在这里完全等价,写 typename 更贴切(因为它可以是 int 而非类)。
绝大多数情况下编译器能自动推导 T,只有在"无法推导"或"想指定不同类型"时才显式写 func<int>(args)。
#include <iostream>
#include <string>
#include <vector>
// 1) 最简单的函数模板:自动推导 T
template <typename T>
T maximum(T a, T b) {
return a > b ? a : b;
}
// 2) 多个类型参数,返回类型也可以独立
template <typename T, typename U>
auto pair_sum(T a, U b) {
return a + b; // 返回类型由 decltype 推导(C++14)
}
// 3) 显式指定类型参数:当推导有歧义或需要强制转换时
template <typename T>
T create_default() {
return T{}; // 值初始化,int 是 0,指针是 nullptr
}
// 4) 模板参数可以是容器,配合 STL 使用
template <typename Container>
void print_all(const Container& c) {
for (const auto& item : c) {
std::cout << item << " ";
}
std::cout << "\n";
}
// 5) 模板 + 迭代器:最通用的形式,甚至能作用于 C 数组
template <typename Iter>
void print_range(Iter first, Iter last) {
while (first != last) {
std::cout << *first << " ";
++first;
}
std::cout << "\n";
}
int main() {
// 自动推导:所有实例化在编译期生成
std::cout << maximum(3, 5) << "\n"; // int 版本
std::cout << maximum(3.14, 2.71) << "\n"; // double 版本
std::cout << maximum(std::string("abc"), std::string("abd")) << "\n";
// maximum(3, 3.14) 会推导失败:int 和 double 冲突
std::cout << maximum<double>(3, 3.14) << "\n"; // 显式指定解决
std::cout << pair_sum(1, 2.5) << "\n"; // T=int, U=double
int zero = create_default<int>();
std::cout << "默认 int = " << zero << "\n";
std::vector<int> v{1, 2, 3};
print_all(v);
int arr[]{4, 5, 6};
print_range(arr, arr + 3); // C 数组也能用
// print_all(42) 会编译失败,因为 int 不支持范围 for ——
// 这就是"编译期鸭子类型":不检查类型名,只检查操作是否合法
return 0;
}注意最后一点:print_all(42) 的错误信息是一大串模板嵌套(新手常被吓到)。C++20 的 concepts 就是为了让这个报错变得可读,见本章最后一节。
#类模板
类模板让你定义"一族类"。std::vector<T>、std::unique_ptr<T> 都是类模板。
关键细节:类模板的成员函数定义必须和声明放在同一个文件里(通常是头文件)。这是因为编译器在实例化时需要看到完整定义——不像普通类可以分离 .h/.cpp。这也是为什么 STL 和 Boost 大量使用头文件。
#include <iostream>
#include <stdexcept>
#include <string>
#include <vector>
// 一个简易栈:类模板
template <typename T>
class Stack {
public:
void push(const T& value) {
data_.push_back(value);
}
// 类内定义时,返回类型里的 Stack 可以省略 <T>(注入类名)
T pop() {
if (data_.empty()) {
throw std::out_of_range("栈为空");
}
T value = data_.back();
data_.pop_back();
return value;
}
const T& top() const {
if (data_.empty()) {
throw std::out_of_range("栈为空");
}
return data_.back();
}
bool empty() const { return data_.empty(); }
std::size_t size() const { return data_.size(); }
private:
std::vector<T> data_; // 用 vector 做底层存储,复用它的内存管理
};
// 类外定义成员函数时,必须写完整的模板头
template <typename T>
void clear_stack(Stack<T>& s) {
while (!s.empty()) {
s.pop();
}
}
int main() {
Stack<int> ints;
Stack<std::string> strings;
ints.push(1);
ints.push(2);
std::cout << "栈顶 = " << ints.top() << ",大小 = " << ints.size() << "\n";
strings.push("hello");
strings.push("world");
std::cout << "栈顶 = " << strings.top() << "\n";
// 类模板的成员函数只有被调用时才会实例化:
// 下面这行不会触发 Stack<int>::pop 的实例化检查
Stack<std::vector<int>> unused;
clear_stack(ints);
std::cout << "清空后是否为空: " << std::boolalpha << ints.empty() << "\n";
return 0;
}"成员函数用到才实例化"是一条重要规则:它意味着模板类里可以包含对某些类型不合法的操作,只要你不调用它就没事。这也是为什么 std::vector<不可拷贝类型> 可以编译,只要你不去拷贝它。
#typename 关键字与非类型模板参数
typename 有两种完全不同的用法,容易混淆:
- 声明类型参数:
template <typename T>(等价于class T)。 - 消歧义:
typename T::value_type——告诉编译器"这个嵌套名字是个类型,不是静态成员"。因为编译模板时T还未知,编译器无法判断T::value_type是类型还是变量,必须你显式说明。
非类型模板参数(NTTP)是 C++ 相对 Java/C# 的独有能力:模板参数可以是值而不只是类型,比如整数、指针、引用。最典型的应用是 std::array<T, N>——数组长度在编译期确定,零运行时开销。C++17 起还支持 auto 类型的非类型模板参数。
#include <array>
#include <iostream>
#include <string>
#include <vector>
// 1) typename 的消歧义用法:告诉编译器 iterator 是个类型
template <typename Container>
typename Container::value_type sum_of(const Container& c) {
typename Container::value_type total{}; // 值初始化,适配 int/double/string
for (const auto& item : c) {
total = total + item;
}
return total;
}
// 2) 非类型模板参数:N 是一个编译期整数
template <typename T, std::size_t N>
class FixedArray {
public:
constexpr std::size_t size() const { return N; }
T& operator[](std::size_t i) {
return data_[i]; // 不做边界检查,越界即未定义行为
}
const T& operator[](std::size_t i) const { return data_[i]; }
// 编译期计算:constexpr 函数可以用在 static_assert 里
constexpr std::size_t byte_size() const { return N * sizeof(T); }
private:
T data_[N]{}; // 真正的栈上数组,无动态分配
};
// 3) 非类型参数还能做编译期计算:阶乘
template <unsigned N>
struct Factorial {
static constexpr unsigned value = N * Factorial<N - 1>::value;
};
// 模板特化作为递归终止条件
template <>
struct Factorial<0> {
static constexpr unsigned value = 1;
};
// 4) C++17:非类型参数用 auto,类型自动推导(C++20 才放宽到浮点/类类型)
template <auto Value>
void show_value() {
std::cout << "值 = " << Value << "\n";
}
int main() {
std::vector<int> v{1, 2, 3, 4};
std::vector<double> d{1.5, 2.5};
std::cout << "int 容器求和 = " << sum_of(v) << "\n";
std::cout << "double 容器求和 = " << sum_of(d) << "\n";
// 非类型参数:长度是类型的一部分,FixedArray<int, 3> 和 <int, 4> 是不同类型
FixedArray<int, 5> arr;
arr[0] = 10;
std::cout << "大小 " << arr.size() << ",字节数 " << arr.byte_size() << "\n";
// std::array 就是标准库里的同款实现
std::array<std::string, 3> names{"Qt", "C++", "STL"};
std::cout << "names[0] = " << names[0] << "\n";
// 编译期阶乘:值在编译时就已算好
static_assert(Factorial<5>::value == 120, "算错了");
std::cout << "10! = " << Factorial<10>::value << "\n";
show_value<42>();
show_value<'A'>();
// 长度不匹配会在编译期报错,这是编译期数组的好处
// FixedArray<int, 5> wrong = arr; // 不同类型,无法赋值
return 0;
}#模板特化与偏特化
全特化(full specialization)为某个具体类型提供完全不同的实现,语法是 template <>。典型用途:对 const char* 做特殊处理、对 bool 优化存储。
偏特化(partial specialization)只对类模板有效(函数模板不支持偏特化,只能用重载代替),用于"部分参数固定"的场景,比如 Wrapper<T*> 匹配所有指针类型。
#include <cstring>
#include <iostream>
#include <string>
#include <type_traits>
#include <vector>
// 主模板
template <typename T>
struct TypeName {
static std::string get() { return "未知类型"; }
};
// 全特化:为具体类型提供专门实现
template <>
struct TypeName<int> {
static std::string get() { return "int"; }
};
template <>
struct TypeName<double> {
static std::string get() { return "double"; }
};
template <>
struct TypeName<std::string> {
static std::string get() { return "std::string"; }
};
// 偏特化:匹配"任意类型的指针"
template <typename T>
struct TypeName<T*> {
static std::string get() { return TypeName<T>::get() + " 的指针"; }
};
// 偏特化:匹配 vector<T>
template <typename T>
struct TypeName<std::vector<T>> {
static std::string get() { return "vector<" + TypeName<T>::get() + ">"; }
};
// 函数模板没有偏特化,用重载 + 标签分发代替
// 这里用 std::is_integral 配合编译期 if(C++17)实现"条件分支"
template <typename T>
std::string describe(T value) {
if constexpr (std::is_integral_v<T>) {
return "整数类型,值 = " + std::to_string(value);
} else if constexpr (std::is_floating_point_v<T>) {
return "浮点类型,值 = " + std::to_string(value);
} else {
return "其他类型";
}
}
int main() {
std::cout << TypeName<int>::get() << "\n"; // int
std::cout << TypeName<double>::get() << "\n"; // double
std::cout << TypeName<std::string>::get() << "\n"; // std::string
std::cout << TypeName<char*>::get() << "\n"; // char 的指针
std::cout << TypeName<std::vector<int>>::get() << "\n"; // vector<int>
std::cout << TypeName<float>::get() << "\n"; // 未知类型(走主模板)
std::cout << describe(42) << "\n";
std::cout << describe(3.14) << "\n";
std::cout << describe(std::string("abc")) << "\n";
// if constexpr 是 C++17 的编译期分支:
// 不满足的分支根本不会被实例化,因此可以对不同类型写不兼容的代码
return 0;
}if constexpr 是 C++17 的利器:它和普通 if 的区别在于,被丢弃的分支不会实例化,所以里面可以写对该类型非法的表达式。这大大简化了模板元编程,取代了 C++11 时代大量 SFINAE 技巧。
#auto 返回类型与 decltype
C++14 起,函数返回类型可以写 auto,让编译器从 return 语句推导。这在模板里几乎是必需的——你往往写不出返回类型的名字。
补两个细节:decltype(expr) 求表达式的精确类型(保留引用和 const);decltype(auto)(C++14)则用 decltype 的规则推导,能保留引用。写泛型转发函数时,返回引用必须靠 decltype(auto),否则 auto 会剥掉引用产生副本。
C++20 还允许在函数参数里写 auto,等价于一个匿名模板参数(简写函数模板)。
#include <iostream>
#include <string>
#include <vector>
// 1) auto 返回类型:编译器从 return 推导
template <typename T, typename U>
auto add(T a, U b) {
return a + b; // int + double → double
}
// 2) 尾置返回类型(trailing return type):C++11 写法,复杂表达式时仍需它
template <typename T, typename U>
auto multiply(T a, U b) -> decltype(a * b) {
return a * b;
}
// 3) auto 会剥掉引用:这个版本返回的是副本
template <typename Container>
auto bad_front(Container& c) {
return c.front(); // 返回 T(副本),修改它不影响容器
}
// 4) decltype(auto) 保留引用:返回容器内元素的真实引用
template <typename Container>
decltype(auto) good_front(Container& c) {
return c.front(); // 返回 T&,可以修改
}
// 5) 转发引用 + decltype(auto):完美转发返回值的经典组合
template <typename Container>
decltype(auto) at_index(Container&& c, std::size_t i) {
return c[i];
}
int main() {
std::cout << add(1, 2.5) << "\n"; // 3.5
std::cout << multiply(3, 4.5) << "\n"; // 13.5
std::vector<int> v{1, 2, 3};
// auto 版本:拿到副本
auto a = bad_front(v);
a = 99;
std::cout << "副本改了,容器首元素仍是 " << v.front() << "\n";
// decltype(auto) 版本:拿到引用
decltype(auto) b = good_front(v);
b = 99;
std::cout << "引用改了,容器首元素变成 " << v.front() << "\n";
std::cout << at_index(v, 1) << "\n";
// 6) decltype 求表达式类型,常用于声明同类型变量
decltype(v.size()) n = v.size(); // std::size_t
std::cout << "元素个数 = " << n << "\n";
return 0;
}#Concepts 入门(C++20)
模板错误信息冗长是 C++ 长期被诟病的问题——写错一个类型,编译器会吐出几十行内部实现细节。C++20 的 concepts 解决了两件事:让约束写进签名,让错误说人话。
概念(concept)本质上是"编译期的谓词",用来约束模板参数必须满足什么条件。语法上可以用 requires 子句,也可以直接把 concept 名写在 template <...> 里替代 typename。
// 注意:本段需要 C++20,编译时加 -std=c++20
#include <concepts>
#include <iostream>
#include <string>
#include <vector>
// 1) 自定义 concept:要求类型支持 << 输出到流
template <typename T>
concept Printable = requires(T value, std::ostream& os) {
{ os << value } -> std::convertible_to<std::ostream&>;
};
// 2) 用 concept 约束函数模板,替代 typename
template <Printable T>
void print_one(const T& value) {
std::cout << value << "\n";
}
// 3) requires 子句的等价写法,可组合多个约束
template <typename T>
requires Printable<T> && std::copy_constructible<T>
void print_twice(const T& value) {
std::cout << value << " " << value << "\n";
}
// 4) 标准库预置 concept:integral / floating_point / 等
template <std::integral T>
T gcd(T a, T b) {
while (b != 0) {
T t = b;
b = a % b;
a = t;
}
return a;
}
// 5) auto 参数 + concept(C++20 简写函数模板)
void print_number(std::integral auto value) {
std::cout << "数字: " << value << "\n";
}
int main() {
print_one(42);
print_one(std::string("hello"));
print_twice(3.14);
std::cout << "gcd(48, 18) = " << gcd(48, 18) << "\n";
print_number(100);
// 下面这行会给出清晰的错误:"constraints not satisfied",
// 而不是几十行模板内部实现 —— 这就是 concepts 最大的实用价值
// print_one(std::vector<int>{1, 2, 3});
return 0;
}Qt 6 本身仍以 C++17 为主,但了解 concepts 能帮你读懂现代 C++ 代码和编译错误,也让你在需要时能写出更友好的接口。本教程后续章节默认 C++17,凡涉及 concepts 都会像这里一样单独标注。
#小结
- C++ 模板是编译期实例化(每个类型生成独立代码),与 Java 的类型擦除、Python 的运行时鸭子类型都不同:零开销,但会增大二进制体积。
- 函数模板语法
template <typename T>,多数情况自动推导;推导冲突时用func<T>(...)显式指定。 - 类模板的成员定义必须放在头文件;成员函数只有被调用时才实例化,所以对某些类型不合法的操作只要不调用就不报错。
typename既声明类型参数,也用于消歧义嵌套类型名(typename T::value_type);非类型模板参数可以是编译期值,std::array<T, N>就是典型。- 全特化
template <>为具体类型定制;偏特化只对类模板有效,函数模板用重载 +if constexpr(C++17)代替。 auto返回类型会剥掉引用,需要保留引用时用decltype(auto);C++20 的 concepts 把约束写进签名,把冗长的模板错误变成可读的诊断。
#练习
- 写一个函数模板
template <typename T> void swap_values(T& a, T& b),分别用int、double、std::string调用,用typeid或调试器确认生成了三份不同的代码。 - 实现
template <typename T, std::size_t N> class CircularBuffer,支持push、pop、size,写满时覆盖最旧的数据。用std::array<T, N>做底层存储。 - 给
TypeName增加long、bool、std::vector<std::vector<int>>的特化,验证嵌套偏特化能正确递归展开。 - 用
if constexpr写一个template <typename T> std::string to_display(T value):整数转"123",浮点保留两位小数,字符串原样返回,其他类型返回"<不支持>"。再改写成decltype(auto)返回版本,对比修改返回值时是否影响原容器。最后(C++20)定义concept Hashable = requires(T a) { { std::hash<T>{}(a) } -> std::convertible_to<std::size_t>; };,写一个只接受 Hashable 类型的函数,观察错误信息有多友好。