C++算法
C++ 模板进阶：特化、萃取与可变参数模板
深入讲解了 C++ 模板进阶技术，涵盖模板特化、类型萃取与可变参数模板三大核心主题。内容详细阐述了如何处理指针、数组等复杂类型的特化，如何利用类型萃取在编译期获取类型信息，以及如何使用可变参数模板和折叠表达式处理任意数量参数。此外，文章还通过编译期斐波那契数列展示了模板的编译期优化能力，并总结了常见陷阱与解决方案，旨在帮助开发者提升泛型编程的实战能力。
深入讲解了 C++ 模板进阶技术，涵盖模板特化、类型萃取与可变参数模板三大核心主题。内容详细阐述了如何处理指针、数组等复杂类型的特化，如何利用类型萃取在编译期获取类型信息，以及如何使用可变参数模板和折叠表达式处理任意数量参数。此外，文章还通过编译期斐波那契数列展示了模板的编译期优化能力，并总结了常见陷阱与解决方案，旨在帮助开发者提升泛型编程的实战能力。
模板特化不只是针对单一类型的定制，还能处理指针、引用、数组等复杂类型，实现更精细的类型适配逻辑。
通用模板默认处理普通类型，我们可以为指针类型单独编写特化版本，实现指针专属的逻辑。
#include <iostream>
#include <string>
using namespace std;
// 通用模板：处理普通类型
template<typename T>
class TypeProcessor {
public:
static void process(T data) {
cout << "处理普通类型：" << data << endl;
}
};
// 特化版本 1：处理指针类型
template<typename T>
class TypeProcessor<T*> {
public:
static void process(T* data) {
if (data != nullptr) {
cout << "处理指针类型：" << *data << endl;
} else {
cout << "空指针，无法处理" << endl;
}
}
};
// 特化版本 2：处理 const 指针类型
template<typename T>
class TypeProcessor<const T*> {
public:
static void process(const T* data) {
if (data != nullptr) {
cout << "处理 const 指针类型：" << *data << endl;
} else {
cout << "const 空指针，无法处理" << endl;
}
}
};
int main() {
int num = 100;
const int cnum = 200;
// 普通类型
TypeProcessor<int>::process(num);
// 普通指针
TypeProcessor<int*>::process(&num);
// const 指针
TypeProcessor<const int*>::process(&cnum);
// 空指针
TypeProcessor<int*>::process(nullptr);
return 0;
}
处理普通类型：100
处理指针类型：100
处理 const 指针类型：200
空指针，无法处理
template <typename T> class 类名<T*>，T* 表示匹配任意类型的指针。T* 和 const T* 等不同指针类型，实现精准的逻辑控制。针对数组类型的特化可以解决数组退化为指针的问题，直接获取数组的大小和元素类型。
#include <iostream>
using namespace std;
// 通用模板：处理非数组类型
template<typename T>
class ArrayInfo {
public:
static const bool isArray = false;
static const size_t size = 0;
using ElementType = T;
};
// 特化版本：处理任意大小的数组
template<typename T, size_t N>
class ArrayInfo<T[N]> {
public:
static const bool isArray = true;
static const size_t size = N;
using ElementType = T;
};
int main() {
// 普通 int 类型
cout << "int 是否为数组：" << boolalpha << ArrayInfo<int>::isArray << endl;
cout << "int 元素数量：" << ArrayInfo<int>::size << endl;
// int[5] 数组类型
cout << "int[5] 是否为数组：" << boolalpha << ArrayInfo<int[5]>::isArray << endl;
cout << "int[5] 元素数量：" << ArrayInfo<int[5]>::size << endl;
cout << "int[5] 元素类型大小：" << sizeof(ArrayInfo<int[5]>::ElementType) << endl;
return 0;
}
int 是否为数组：false
int 元素数量：0
int[5] 是否为数组：true
int[5] 元素数量：5
int[5] 元素类型大小：4
⚠️ 注意事项：数组特化的模板参数必须包含元素类型 T 和数组大小 N，且 N 必须是编译期常量。
类型萃取（Type Traits）是模板编程的核心工具，用于在编译期获取类型的属性（如是否为指针、是否为常量、是否为类类型等），实现类型相关的条件逻辑。
类型萃取的本质是通过模板特化和静态常量/类型别名，将类型信息存储在编译期可访问的变量或类型中。我们先实现一个基础的类型萃取工具，判断类型是否为指针：
#include <iostream>
using namespace std;
// 通用模板：默认不是指针
template<typename T>
struct IsPointer {
static constexpr bool value = false;
};
// 特化模板：匹配指针类型
template<typename T>
struct IsPointer<T*> {
static constexpr bool value = true;
};
// 辅助变量模板（C++14 及以上）
template<typename T>
constexpr bool is_pointer_v = IsPointer<T>::value;
// 测试函数
template<typename T>
void checkType(T data) {
if constexpr (is_pointer_v<T>) {
cout << "该类型是指针" << endl;
} else {
cout << "该类型不是指针" << endl;
}
}
int main() {
int num = 10;
checkType(num); // 普通 int 类型
checkType(&num); // int* 指针类型
return 0;
}
该类型不是指针
该类型是指针
constexpr 关键字用于定义编译期常量，if constexpr 用于编译期条件判断，避免无效代码的生成。C++11 及以上标准库提供了丰富的类型萃取工具，定义在 <type_traits> 头文件中，常用工具如下：
| 萃取工具 | 功能 |
|---|---|
is_pointer<T> | 判断 T 是否为指针类型 |
is_const<T> | 判断 T 是否为 const 修饰的类型 |
is_reference<T> | 判断 T 是否为引用类型 |
is_arithmetic<T> | 判断 T 是否为算术类型（int、float 等） |
remove_const<T> | 移除 T 的 const 修饰符 |
remove_reference<T> | 移除 T 的引用修饰符 |
#include <iostream>
#include <type_traits>
using namespace std;
int main() {
using Type1 = const int;
using Type2 = remove_const<Type1>::type; // 移除 const，Type2 为 int
cout << boolalpha;
cout << "const int 是否为 const 类型：" << is_const<Type1>::value << endl;
cout << "Type2 是否为 const 类型：" << is_const<Type2>::value << endl;
using Type3 = int&;
using Type4 = remove_reference<Type3>::type; // 移除引用，Type4 为 int
cout << "int& 是否为引用类型：" << is_reference<Type3>::value << endl;
cout << "Type4 是否为引用类型：" << is_reference<Type4>::value << endl;
return 0;
}
const int 是否为 const 类型：true
Type2 是否为 const 类型：false
int& 是否为引用类型：true
Type4 是否为引用类型：false
可变参数模板（Variadic Template）是 C++11 引入的特性，允许模板接受任意数量、任意类型的参数，是实现泛型容器、函数包装器的核心技术。
可变参数模板的核心是参数包（Parameter Pack），用 ... 表示，分为模板参数包和函数参数包：
// 模板参数包：Args 表示任意数量的类型参数
template<typename... Args>
// 函数参数包：args 表示任意数量的函数参数
void print(Args... args) {
// 参数包展开逻辑
}
参数包不能直接使用，必须通过展开才能逐个访问其中的参数，常见的展开方式有递归展开和折叠表达式展开。
递归展开是传统的参数包展开方式，通过递归函数调用逐个处理参数：
#include <iostream>
using namespace std;
// 递归终止函数：无参数版本
void print() {
cout << endl;
}
// 可变参数函数：递归展开参数包
template<typename T, typename... Args>
void print(T first, Args... rest) {
cout << first << " ";
// 递归调用：处理剩余参数
print(rest...);
}
int main() {
print(10, 3.14, "Hello", 'A'); // 4 个不同类型的参数
print("C++", true, 200); // 3 个不同类型的参数
return 0;
}
10 3.14 Hello A
C++ true 200
C++17 引入了折叠表达式，可以用一行代码完成参数包的展开，无需递归函数，语法简洁高效。折叠表达式分为四种类型：左折叠、右折叠、二元折叠、一元折叠，常用的是二元左折叠。
#include <iostream>
using namespace std;
// 折叠表达式求和：支持任意数量的算术类型参数
template<typename... Args>
auto sum(Args... args) {
// 二元左折叠：(args + ...) 等价于 (((arg1 + arg2) + arg3) + ...)
return (args + ...);
}
// 折叠表达式打印：支持任意数量的参数
template<typename... Args>
void print(Args... args) {
// 二元左折叠：(cout << ... << args) 等价于 (((cout << arg1) << arg2) << ...)
(cout << ... << args) << endl;
}
int main() {
cout << "求和结果：" << sum(1, 2, 3, 4, 5) << endl;
print("Hello", " ", "C++", " ", 2024);
return 0;
}
求和结果：15
Hello C++ 2024
⚠️ 注意事项：折叠表达式需要编译器支持 C++17 及以上标准，编译时需添加 -std=c++17 参数。
需求：实现一个通用的函数包装器，支持包装任意函数和任意数量的参数，调用包装器时自动执行目标函数。
#include <iostream>
#include <functional>
using namespace std;
// 通用函数包装器
template<typename Func, typename... Args>
auto wrapper(Func func, Args... args) {
cout << "函数执行前：参数数量 = " << sizeof...(args) << endl;
// 调用目标函数并返回结果
auto result = func(args...);
cout << "函数执行后：结果 = " << result << endl;
return result;
}
// 测试函数 1：两个 int 参数求和
int add(int a, int b) {
return a + b;
}
// 测试函数 2：三个 double 参数求积
double multiply(double a, double b, double c) {
return a * b * c;
}
int main() {
// 包装 add 函数
wrapper(add, 10, 20);
// 包装 multiply 函数
wrapper(multiply, 1.5, 2.0, 3.0);
return 0;
}
函数执行前：参数数量 = 2
函数执行后：结果 = 30
函数执行前：参数数量 = 3
函数执行后：结果 = 9
std::function 还能支持 Lambda 表达式和成员函数。sizeof...(args) 用于获取参数包中参数的数量，是编译期常量。模板进阶技术的核心优势是编译期计算，可以将运行时的计算逻辑提前到编译期完成，提升程序运行效率。
利用模板特化和递归，在编译期计算斐波那契数列的值：
#include <iostream>
using namespace std;
// 通用模板：递归计算斐波那契数
template<int N>
struct Fibonacci {
static const int value = Fibonacci<N - 1>::value + Fibonacci<N - 2>::value;
};
// 特化模板：递归终止条件
template<>
struct Fibonacci<0> {
static const int value = 0;
};
template<>
struct Fibonacci<1> {
static const int value = 1;
};
int main() {
// 编译期计算 Fibonacci(10)
const int fib10 = Fibonacci<10>::value;
cout << "斐波那契数列第 10 项：" << fib10 << endl;
return 0;
}
斐波那契数列第 10 项：55
在折叠表达式出现之前，使用逗号表达式展开参数包时，容易忽略逗号表达式的返回值问题。
❌ 错误写法：
template<typename... Args>
void print(Args... args) {
// 错误：逗号表达式的返回值是最后一个参数的值，前面的 cout 会被忽略
(cout << args, ...);
}
✅ 正确写法（C++17 折叠表达式）：
template<typename... Args>
void print(Args... args) {
(cout << ... << args) << endl;
}
模板特化的匹配顺序是越具体的特化越优先，如果特化顺序不当，会导致预期的特化版本不被匹配。
✅ 解决方案：将更具体的特化版本写在前面，或者确保特化的模板参数更精准。
当可变参数模板与普通模板重载时，编译器可能会优先匹配普通模板，导致可变参数模板不被调用。
✅ 解决方案：使用 std::enable_if 等工具进行模板重载的优先级控制，或显式指定模板参数。
微信公众号「极客日志」，在微信中扫描左侧二维码关注。展示文案：极客日志 zeeklog
使用加密算法（如AES、TripleDES、Rabbit或RC4）加密和解密文本明文。 在线工具，加密/解密文本在线工具，online
将字符串编码和解码为其 Base64 格式表示形式即可。 在线工具，Base64 字符串编码/解码在线工具，online
将字符串、文件或图像转换为其 Base64 表示形式。 在线工具，Base64 文件转换器在线工具，online
将 Markdown（GFM）转为 HTML 片段，浏览器内 marked 解析；与 HTML 转 Markdown 互为补充。 在线工具，Markdown 转 HTML在线工具，online
将 HTML 片段转为 GitHub Flavored Markdown，支持标题、列表、链接、代码块与表格等；浏览器内处理，可链接预填。 在线工具，HTML 转 Markdown在线工具，online
通过删除不必要的空白来缩小和压缩JSON。 在线工具，JSON 压缩在线工具，online