模板基础与 SFINAE

模板基础与 SFINAE

1. 函数模板与类模板的区别

面试题：函数模板和类模板在使用上有什么关键区别？

函数模板支持模板参数推导——调用时不需要指定模板参数，编译器根据实参类型自动推导：

#include<iostream>#include<type_traits>template<typenameT>Tmax(T a,T b){returna>b?a:b;}// 调用：max(1, 3) → T 推导为 int// 调用：max(3.14, 2.71) → T 推导为 double

类模板在 C++17 之前必须显式指定模板参数：

template<typenameT>structBox{T value;explicitBox(T v):value(v){}};Box<int>b(42);// 必须写 <int>// Box b2(42); // C++17 前错误

C++17 CTAD（类模板参数推导）允许从构造函数推导：

Boxb2(42);// C++17 起合法，推导为 Box<int>Boxb3(3.14);// Box<double>

CTAD 依赖推导指引（deduction guide），用户也可自定义：

template<typenameT>structVec{T x,y;Vec(T a,T b):x(a),y(b){}};// 隐式推导指引已足够Vecv(1,2);// Vec<int>

2. 模板特化与偏特化

面试题：模板特化和偏特化分别解决什么问题？

全特化：为某个具体类型提供完整实现，用template<>开头：

#include<iostream>#include<cstring>template<typenameT>structComparator{staticboolequals(constT&a,constT&b){returna==b;}};// 全特化：const char* 用 strcmp 比较template<>structComparator<constchar*>{staticboolequals(constchar*a,constchar*b){returnstd::strcmp(a,b)==0;}};

偏特化：仅部分约束模板参数。只有类模板支持偏特化，函数模板不支持：

#include<iostream>// 主模板template<typenameT,typenameU>structPair{};// 偏特化：两个类型相同时template<typenameT>structPair<T,T>{};// 偏特化：第二个参数为 int 时template<typenameT>structPair<T,int>{};// 偏特化：指针类型template<typenameT>structPair<T*,T*>{};// 偏特化：模板模板参数template<template<typename>classContainer,typenameT>structWrapper{};template<typenameT>structWrapper<std::vector,T>{};

函数模板无法偏特化，但可以用重载达到类似效果：

template<typenameT>voidprocess(T v);// 主模板template<typenameT>voidprocess(T*v);// 重载（指针版本），而非偏特化template<>voidprocess<int>(intv);// 全特化（函数模板可以）

要点：函数模板用"重载"代替偏特化。如果你需要写template <typename T> void foo<T*>()，改为写template <typename T> void foo(T*)即可。

3. SFINAE 原则与 enable_if

面试题：什么是 SFINAE？用 enable_if 实现过什么？

SFINAE（Substitution Failure Is Not An Error）是 C++ 模板实例化时的核心原则：当模板参数替换产生非法类型或表达式时，不报错，只是将该候选从重载集中移除。

#include<iostream>#include<type_traits>// 当 T 是整数类型时启用template<typenameT>typenamestd::enable_if<std::is_integral<T>::value,void>::typecheck(T v){std::cout<<"整数: "<<v<<"\n";}// 当 T 是浮点类型时启用template<typenameT>typenamestd::enable_if<std::is_floating_point<T>::value,void>::typecheck(T v){std::cout<<"浮点数: "<<v<<"\n";}intmain(){check(42);// 整数check(3.14);// 浮点数// check("hello"); // 编译错误：没有匹配的重载}

等价写法（C++14 起可用std::enable_if_t）：

template<typenameT>std::enable_if_t<std::is_integral<T>::value,void>check(T v);

void_t 检测惯用法（C++17）：

#include<iostream>#include<type_traits>#include<utility>template<typename,typename=void>structhas_member_foo:std::false_type{};// 偏特化：如果 T::foo 存在且类型合法，匹配此版本template<typenameT>structhas_member_foo<T,std::void_t<decltype(std::declval<T>().foo())>>:std::true_type{};structA{voidfoo(){}};structB{};static_assert(has_member_foo<A>::value,"A 有 foo()");static_assert(!has_member_foo<B>::value,"B 没有 foo()");

void_t将任何类型映射为void。如果decltype(...)非法（即成员不存在），替换失败，退回到std::false_type。

4. 变参模板与折叠表达式（C++17）

面试题：变参模板怎么展开？折叠表达式有几种形式？

递归展开（C++11 经典方式）：

#include<iostream>// 递归终止函数voidprint_all(){}template<typenameT,typename...Args>voidprint_all(T first,Args...rest){std::cout<<first<<" ";print_all(rest...);// 递归展开}intmain(){print_all(1,3.14,"hello",'!');// 输出: 1 3.14 hello !}

折叠表达式（C++17，更简洁，零递归开销）：

#include<iostream>template<typename...Args>autosum(Args...args){return(...+args);// 一元左折叠：((a + b) + c) + d}template<typename...Args>voidprint_all(Args...args){((std::cout<<args<<" "),...);// 逗号折叠}template<typename...Args>boolall_true(Args...args){return(...&&args);// 逻辑与折叠}intmain(){std::cout<<sum(1,2,3,4)<<"\n";// 10print_all(1,3.14,"hello");// 1 3.14 hellostd::cout<<std::boolalpha<<all_true(true,true,false);// false}

三种折叠形式：

整数加法左折叠和右折叠结果相同（加法可结合），但减法不同——优先用左折叠，更符合直觉。

5. Concepts 如何替代 SFINAE（C++20）

面试题：C++20 的 concepts 相比 enable_if 好在哪里？

Concepts 让模板约束变成可命名的"类型谓词"，可读性远超 SFINAE 写法，且错误信息会直接指出违反的 concept 名称而非一长串模板实例化栈。

基本用法：

#include<iostream>#include<concepts>// 定义 concepttemplate<typenameT>conceptIntegral=std::is_integral_v<T>;template<typenameT>conceptFloatingPoint=std::is_floating_point_v<T>;// 方式一：requires 子句template<typenameT>requiresIntegral<T>Thalf(T v){returnv/2;}// 方式二：受约束模板参数template<FloatingPoint T>Thalf(T v){returnv/2.0;}// 方式三：auto 缩写（更简洁）voidprint(Integralautov){std::cout<<"整数: "<<v<<"\n";}

复杂约束与 requires 表达式：

#include<iostream>#include<concepts>#include<vector>// 检查类型是否可调用（函数式编程风格）template<typenameF,typenameT>conceptCallableWith=requires(F f,T v){{f(v)}->std::same_as<T>;// 返回类型必须为 T};// 检查容器是否可迭代template<typenameC>conceptIterable=requires(C c){{std::begin(c)}->std::input_or_output_iterator;{std::end(c)}->std::input_or_output_iterator;};template<Iterable C>voidforeach(constC&container){for(constauto&v:container)std::cout<<v<<" ";}

SFINAE vs Concepts 对比：

#include<iostream>#include<type_traits>#include<concepts>// SFINAE 写法（C++11/17）template<typenameT>std::enable_if_t<std::is_arithmetic_v<T>,T>sfinae_func(T v){returnv*2;}// Concepts 写法（C++20）template<typenameT>requiresstd::is_arithmetic_v<T>Tconcept_func(T v){returnv*2;}// 错误信息对比：// sfinae_func("bad"); // 几十行模板实例化栈// concept_func("bad"); // 直接报：未满足 is_arithmetic_v

Concepts 支持更精确的重载：

#include<iostream>#include<concepts>template<typenameT>requiresstd::integral<T>voiddispatch(T){std::cout<<"整数\n";}template<typenameT>requiresstd::floating_point<T>voiddispatch(T){std::cout<<"浮点数\n";}// concepts 的偏序规则比 SFINAE 更清晰// 带 concept 的模板比不带约束的模板更特化

总结对照表