C++模板教程：变参模板、折叠表达式与SFINAE

1
// 参数包：typename... Args
2
template <typename... Args>
3
void print(Args... args);

1
#include <iostream>
2
using namespace std;
3

4
// 递归终止条件：空参数版本
5
void printAll() {
6
    cout << endl;
7
}
8

9
// 递归展开：取出第一个参数，剩余继续递归
10
template <typename T, typename... Rest>
11
void printAll(T first, Rest... rest) {
12
    cout << first << " ";
13
    printAll(rest...);    // 递归调用剩余参数
14
}
15

16
int main() {
17
    printAll(1, 2.5, "hello", 'a');   // 1 2.5 hello a
18
    printAll(10);                     // 10
19
    return 0;
20
}

1
#include <iostream>
2
using namespace std;
3

4
template <typename... Args>
5
void countArgs(Args... args) {
6
    cout << "参数个数: " << sizeof...(Args) << endl;
7
    cout << "参数个数: " << sizeof...(args) << endl;   // 等价
8
}
9

10
int main() {
11
    countArgs();                  // 0
12
    countArgs(1);                 // 1
13
    countArgs(1, 2.5, "three");   // 3
14
    return 0;
15
}

1
#include <iostream>
2
using namespace std;
3

4
// C++17 折叠：一行实现任意个数求和
5
template <typename... Args>
6
auto sum(Args... args) {
7
    return (args + ... + 0);   // 右折叠，初始值 0
8
}
9

10
// 左折叠
11
template <typename... Args>
12
auto sumLeft(Args... args) {
13
    return (0 + ... + args);
14
}
15

16
int main() {
17
    cout << sum(1, 2, 3, 4, 5) << end
18
l;       // 15
19
    cout << sum(1.5, 2.5, 3.0) << endl;       // 7
20
    cout << sum() << endl;                    // 0
21
    cout << sumLeft(1, 2, 3) << endl;         // 6
22
    return 0;
23
}

1
#include <iostream>
2
using namespace std;
3

4
// 用逗号运算符折叠打印
5
template <typename... Args>
6
void printFold(Args... args) {
7
    // (cout << ... << args)：左折叠
8
    // 逐个输出
9
    ((cout << args << " "), ...);   // 逗号折叠
10
    cout << endl;
11
}
12

13
// 更实用的版本：带分隔符
14
template <typename... Args>
15
void printWithSep(const char *sep, Args... args) {
16
    // 第一个直接输出，其余带分隔符
17
    ((cout << args), ...);   // 简化版
18
    cout << endl;
19
}
20

21
int main() {
22
    printFold(1, 2.5, "hi", 'x');    // 1 2.5 hi x
23
    printWithSep(", ", 1, 2, 3);
24
    return 0;
25
}

1
#include <iostream>
2
using namespace std;
3

4
// 全部满足条件（&& 折叠）
5
template <typename... Args>
6
bool allPositive(Args... args) {
7
    return ((args > 0) && ...);
8
}
9

10
// 任一满足条件（|| 折叠）
11
template <typename... Args>
12
bool anyZero(Args... args) {
13
    return ((args == 0) || ...);
14
}
15

16
int main() {
17
    cout << allPositive(1, 2, 3) << endl;     // 1
18
    cout << allPositive(1, -2, 3) << endl;    // 0
19
    cout << anyZero(1, 2, 0, 4) << endl;      // 1
20
    cout << anyZero(1, 2, 3) << endl;         // 0
21
    return 0;
22
}

1
#include <iostream>
2
#include <type_traits>
3
using namespace std;
4

5
// 通用版本：不支持 operator<< 的类型走这里
6
template <typename T>
7
void printValue(const T &value, ...) {
8
    cout << "不支持输出: (未知类型)" << endl;
9
}
10

11
// 精确版本：支持 operator<< 的类型走这里
12
template <typename T, typename = decltype(cout << declval<const T &>())>
13
void printValue(const T &value, int) {
14
    cout << "值: " << value << endl;
15
}
16

17
int main() {
18
    printValue(42, 0);            // 值: 42
19
    printValue(3.14, 0);          // 值: 3.14
20
    printValue("hello", 0);       // 值: hello
21
    return 0;
22
}

1
#include <iostream>
2
#include <type_traits>
3
using namespace std;
4

5
// 仅当 T 是整数时启用
6
template <typename T>
7
typename enable_if<is_integral<T>::value>::type
8
process(T value) {
9
    cout << "整数处理: " << value << endl;
10
}
11

12
// 仅当 T 是浮点时启用
13
template <typename T>
14
typename enable_if<is_floating_point<T>::value>::type
15
process(T value) {
16
    cout << "浮点处理: " << value << endl;
17
}
18

19
int main() {
20
    process(42);         // 整数处理: 42
21
    process(3.14);       // 浮点处理: 3.14
22
    // process("hi");    // 错误！string 不满足任何版本
23
    return 0;
24
}

1
#include <iostream>
2
#include <type_traits>
3
using namespace std;
4

5
// 写法一：返回类型中启用
6
template <typename T>
7
typename enable_if<is_integral<T>::value, T>::type
8
square(T x) {
9
    return x * x;
10
}
11

12
// 写法二：模板参数中启用（C++11 更通用）
13
template <typename T,
14
          typename = typename enable_if<is_floating_point<T>::value>::type>
15
double squareDouble(T x) {
16
    return x * x;
17
}
18

19
int main() {
20
    cout << square(5) << endl;         // 25（int 版本）
21
    cout << squareDouble(2.5) << endl; // 6.25（double 版本）
22
    return 0;
23
}

1
#include <iostream>
2
#include <type_traits>
3
using namespace std;
4

5
// void_t：任何类型都映射为 void（C++17 标准库提供）
6
template <typename...>
7
using void_t = void;
8

9
// 检测 T 是否有成员函数 size()
10
template <typename T, typename = void>
11
struct HasSize : false_type {};
12

13
template <typename T>
14
struct HasSize<T, void_t<decltype(declval<T>().size())>> : true_type {};
15

16
// 检测 T 是否有成员 type
17
template <typename T, typename = void>
18
struct HasType : false_type {};
19

20
template <typename T>
21
struct HasType<T, void_t<typename T::type>> : true_type {};
22

23
int main() {
24
    cout << "string 有 size(): " << HasSize<string>::value << endl;  // 1
25
    cout << "int 有 size(): " << HasSize<int>::value << endl;        // 0
26

27
    struct WithType { using type = int; };
28
    cout << "WithType 有 type: " << HasType<WithType>::value << endl;  // 1
29
    cout << "int 有 type: " << HasType<int>::value << endl;            // 0
30
    return 0;
31
}

1
#include <iostream>
2
#include <type_traits>
3
using namespace std;
4

5
template <typename...>
6

7
using void_t = void;
8

9
// 检测 T 是否支持 operator<<
10
template <typename T, typename = void>
11
struct IsPrintable : false_type {};
12

13
template <typename T>
14
struct IsPrintable<T,
15
    void_t<decltype(cout << declval<const T &>())>> : true_type {};
16

17
struct MyStruct {};    // 不支持输出
18

19
int main() {
20
    cout << "int 可打印: " << IsPrintable<int>::value << endl;       // 1
21
    cout << "string 可打印: " << IsPrintable<string>::value << endl; // 1
22
    cout << "MyStruct 可打印: " << IsPrintable<MyStruct>::value << endl;  // 0
23
    return 0;
24
}

1
#include <iostream>
2
using namespace std;
3

4
// 基础版本：无参数
5
void myPrintf(const char *format) {
6
    cout << format << endl;
7
}
8

9
// 递归展开版本
10
template <typename T, typename... Args>
11
void myPrintf(const char *format, T value, Args... args) {
12
    while (*format) {
13
        if (*format == '%' && *(format + 1) == 'd') {
14
            cout << value;              // 输出参数
15
            format += 2;
16
            myPrintf(format, args...);  // 递归剩余
17
            return;
18
        }
19
        cout << *format++;
20
    }
21
}
22

23
int main() {
24
    myPrintf("数字: %d", 42);
25
    myPrintf("%d 加 %d 等于 %d", 1, 2, 3);
26
    return 0;
27
}

1
#include <iostream>
2
#include <vector>
3
using namespace std;
4

5
// 自定义容器：支持任意参数构造
6
template <typename T>
7
class MyContainer {
8
private:
9
    vector<T> data;
10

11
public:
12
    // 变参构造函数
13
    template <typename... Args>
14
    MyContainer(Args... args) {
15
        data.reserve(sizeof...(Args));
16
        (data.push_back(args), ...);   // C++17 逗号折叠
17
    }
18

19
    void show() const {
20
        for (const auto &item : data) cout << item << " ";
21
        cout << endl;
22
    }
23

24
    size_t size() const { return data.size(); }
25
};
26

27
int main() {
28
    MyContainer<int> c1(1, 2, 3, 4, 5);
29
    cout << "大小: " << c1.size() << endl;   // 5
30
    c1.show();                               // 1 2 3 4 5
31

32
    MyContainer<string> c2("C++", "Python");
33
    c2.show();   // C++ Python
34
    return 0;
35
}

1
#include <iostream>
2
#include <concepts>
3
using namespace std;
4

5
// 定义概念：必须是整数类型
6
template <typename T>
7
concept Integral = is_integral_v<T>;
8

9
// 用概念约束模板参数
10
template <Integral T>
11
T add(T a, T b) {
12
    return a + b;
13
}
14

15
// 简化写法
16
template <typename T>
17
requires Integral<T>
18
T multiply(T a, T b) {
19
    return a * b;
20
}
21

22
int main() {
23
    cout << add(3, 4) << endl;       // 7
24
    cout << multiply(5, 6) << endl;  // 30
25
    // add(3.5, 4.5);   // 错误！double 不满足 Integral
26
    return 0;
27
}

1
#include <iostream>
2
#include <type_traits>
3
using namespace std;
4

5
// 两个参数版本（递归终止）
6
template <typename T>
7
T myMax(T value) {
8
    return value;
9
}
10

11
// 变参版本：比较第一个和剩余的最大值
12
template <typename T, typename... Args>
13
auto myMax(T first, Args... rest) {
14
    auto restMax = myMax(rest...);   // 递归求剩余最大值
15
    return first > restMax ? first : restMax;
16
}
17

18
// 折叠表达式版本（C++17 更简洁）
19
template <typename... Args>
20
auto foldMax(Args... args) {
21
    return (args > ...);   // 不适用
22
}
23

24
// 正确折叠版
25
template <typename First, typename... Rest>
26
auto foldMax2(First first, Rest... rest) {
27
    auto result = first;
28
    ((result = (rest > result ? rest : result)), ...);
29
    return result;
30
}
31

32
int main() {
33
    cout << myMax(3, 7, 2) << endl;          // 7
34
    cout << myMax(1.5, 3.2, 2.8, 4.1) << endl;  // 4.1
35
    cout << foldMax2(10, 20, 5, 15) << endl; // 20
36
    cout << foldMax2(3.5, 2.5) << endl;      // 3.5
37
    return 0;
38
}