C++中的Template Argument Deduction（模板参数推导）规则：非类型模板参数与约束匹配 - 智猿学院-前后端，数据库，人工智能，云计算等领域前沿技术讲座

C++ 模板参数推导：非类型模板参数与约束匹配

大家好，今天我们来深入探讨 C++ 模板参数推导中的一个关键方面：非类型模板参数以及它们与约束的匹配。模板元编程是 C++ 中一种强大的技术，它允许我们在编译时执行计算和代码生成。理解模板参数推导规则对于编写高效且正确的模板代码至关重要。

什么是模板参数推导？

模板参数推导是编译器自动确定模板参数类型的过程。当调用一个函数模板或者使用一个类模板时，我们通常不需要显式地指定所有模板参数。编译器会尝试根据函数调用参数的类型或者类模板的使用方式来推导出模板参数。

例如：

template <typename T>
T max(T a, T b) {
  return (a > b) ? a : b;
}

int main() {
  int x = 5, y = 10;
  auto result = max(x, y); // 编译器推导出 T 为 int
  return 0;
}

在这个例子中，我们没有显式地指定 max 函数模板的 T 类型。编译器根据 x 和 y 的类型（都是 int）成功地推导出 T 为 int。

非类型模板参数简介

除了类型模板参数（typename T 或者 class T）之外，C++ 还支持非类型模板参数。非类型模板参数允许我们在模板中使用常量值作为参数。这些常量值可以是整数、枚举、指针、引用或者其他特定的字面量类型。

例如：

template <int N>
class MyArray {
private:
  int data[N];
public:
  MyArray() {
    for (int i = 0; i < N; ++i) {
      data[i] = 0;
    }
  }
  int& operator[](size_t index) {
    return data[index];
  }

  int operator[](size_t index) const {
    return data[index];
  }
};

int main() {
  MyArray<10> arr; // N 被指定为 10
  arr[0] = 5;
  return 0;
}

在这个例子中，N 是一个非类型模板参数，它指定了 MyArray 类的大小。N 的值在编译时就必须已知。

非类型模板参数的类型限制

非类型模板参数的类型有严格的限制。允许的类型包括：

整数类型： int, short, long, long long, unsigned int 等。
枚举类型： enum。
指针类型： 指向对象或函数的指针。
引用类型： 指向对象或函数的左值引用。
std::nullptr_t: nullptr 的类型。
浮点数类型 (C++20 起): float, double, long double （需要编译器支持）。
字面量类型的对象 (C++20 起): 实现了 operator== 的字面量类型的对象。

需要注意的是，浮点数和字面量对象作为非类型模板参数是 C++20 引入的，之前的标准并不支持。

非类型模板参数的推导

非类型模板参数的推导不像类型模板参数那样直接。通常，我们需要显式地指定非类型模板参数的值。但是，在某些情况下，编译器也可以推导出非类型模板参数。

考虑以下例子：

template <int N>
void printArray(int (&arr)[N]) {
  for (int i = 0; i < N; ++i) {
    std::cout << arr[i] << " ";
  }
  std::cout << std::endl;
}

int main() {
  int myArray[5] = {1, 2, 3, 4, 5};
  printArray(myArray); // 编译器推导出 N 为 5
  return 0;
}

在这个例子中，printArray 函数模板接受一个大小为 N 的整型数组的引用。当我们调用 printArray(myArray) 时，编译器能够根据 myArray 的大小推导出 N 的值为 5。这是因为数组的大小是类型的一部分。

模板约束 (Concepts) 简介

C++20 引入了 Concepts，这是一种强大的特性，允许我们对模板参数施加约束。Concepts 允许我们指定模板参数必须满足的条件，从而提高代码的可读性和安全性。

例如：

template <typename T>
concept Integral = std::is_integral_v<T>;

template <Integral T>
T add(T a, T b) {
  return a + b;
}

int main() {
  int x = 5, y = 10;
  auto result = add(x, y); // 正确：int 满足 Integral concept
  //double a = 3.14, b = 2.71;
  //auto result2 = add(a, b); // 错误：double 不满足 Integral concept
  return 0;
}

在这个例子中，我们定义了一个名为 Integral 的 Concept，它要求类型 T 必须是整型。然后，我们使用 Integral Concept 对 add 函数模板的 T 类型参数进行了约束。如果传递给 add 函数的参数类型不满足 Integral Concept，编译器将会报错。

非类型模板参数与约束的匹配

现在，我们来讨论非类型模板参数与约束的匹配。我们可以使用 Concepts 来约束非类型模板参数，确保它们满足特定的条件。

例如：

template <typename T, T Value>
concept LessThan10 = (Value < 10);

template <typename T, LessThan10<T, Value> T Value>
class MyClass {
public:
  MyClass() {
    std::cout << "Value: " << Value << std::endl;
  }
};

int main() {
  MyClass<int, 5> obj1; // 正确：5 < 10
  //MyClass<int, 15> obj2; // 错误：15 不满足 LessThan10 concept
  return 0;
}

在这个例子中，我们定义了一个名为 LessThan10 的 Concept，它要求非类型模板参数 Value 必须小于 10。然后，我们使用 LessThan10 Concept 对 MyClass 类模板的 Value 非类型模板参数进行了约束。如果传递给 MyClass 类的 Value 值不满足 LessThan10 Concept，编译器将会报错。

更复杂的例子:

#include <iostream>
#include <type_traits>

template <typename T, T v>
concept ValidSize = requires {
    { v } -> std::convertible_to<size_t>; // v 可以转换为 size_t
    (v >= 0); // v 必须是非负的
};

template <ValidSize<int, N> int N>
class StaticBuffer {
private:
    int data[N];
public:
    StaticBuffer() {
        std::cout << "StaticBuffer of size " << N << " created." << std::endl;
    }
};

int main() {
    StaticBuffer<5> buffer1; // OK: 5 is a valid size
    //StaticBuffer<-1> buffer2; // Error: -1 is not a valid size (N >= 0)
    //StaticBuffer<2.5> buffer3; // Error: 2.5 is not an integer

    return 0;
}

在这个例子中，ValidSize concept 检查非类型模板参数 v 是否可以转换为 size_t 且是非负的。这可以防止使用负数或非整数作为数组大小，从而避免编译错误或运行时问题。requires 表达式是 concept 定义的关键，它定义了类型或值的有效条件。

约束推导指南 (Constraint Deduction Guides)

在某些情况下，我们可能需要提供约束推导指南来帮助编译器推导出非类型模板参数的值。约束推导指南允许我们指定在特定条件下如何推导模板参数。

考虑以下例子：

template <typename T, int N>
class MyContainer {
public:
  MyContainer(T (&arr)[N]) {
    // ...
  }
};

template <typename T, int N>
MyContainer(T (&)[N]) -> MyContainer<T, N>; // 约束推导指南

int main() {
  int myArray[5] = {1, 2, 3, 4, 5};
  MyContainer container(myArray); // 编译器使用约束推导指南推导出 T 和 N
  return 0;
}

在这个例子中，我们定义了一个 MyContainer 类模板，它接受一个类型 T 和一个非类型模板参数 N。我们还提供了一个约束推导指南，告诉编译器如何从数组 arr 中推导出 T 和 N。当我们使用 MyContainer container(myArray) 创建 MyContainer 对象时，编译器会使用约束推导指南推导出 T 为 int，N 为 5。

表格总结：非类型模板参数推导和约束

特性	描述	示例
非类型模板参数	模板参数可以是常量值，例如整数、枚举、指针或引用。	`template <int N> class MyArray { ... };`
类型限制	非类型模板参数的类型有严格的限制。	允许的类型包括：整数类型、枚举类型、指针类型、引用类型、`std::nullptr_t` (C++11) 和浮点数类型 (C++20)。
推导	通常需要显式指定。但在某些情况下，例如传递数组引用时，编译器可以推导出非类型模板参数的值。	`template <int N> void printArray(int (&arr)[N]); int myArray[5]; printArray(myArray); // N 推导为 5`
Concepts (C++20)	允许对模板参数施加约束，提高代码的可读性和安全性。	`template <typename T, T Value> concept LessThan10 = (Value < 10); template <typename T, LessThan10<T, Value> T Value> class MyClass { ... };`
约束推导指南	允许指定在特定条件下如何推导模板参数。	`template <typename T, int N> MyContainer(T (&)[N]) -> MyContainer<T, N>;`
`requires` 表达式	Concept 定义的关键，定义了类型或值的有效条件。	`template <typename T, T v> concept ValidSize = requires { { v } -> std::convertible_to<size_t>; (v >= 0); };`
字面量类型的对象(C++20)	自 C++20 起，字面量类型的对象也可以作为非类型模板参数，但要求类型实现了 `operator==`。	`struct Literal { int x; constexpr bool operator==(const Literal& other) const { return x == other.x; } }; template <Literal obj> struct MyTemplate { }; MyTemplate<Literal{5}> instance;`
指针/引用类型(C++11)	可以指向对象或函数。函数指针和成员指针都可以用作非类型模板参数。但是，字符串字面量不能直接用作非类型模板参数，因为其地址不是编译时常量。	`template <int* ptr> struct MyTemplate { }; int global_var = 10; MyTemplate<&global_var> instance;`

注意事项和最佳实践

尽可能使用 Concepts： 使用 Concepts 可以提高代码的可读性和安全性，并提供更好的编译时错误信息。
明确指定非类型模板参数： 尽量避免依赖非类型模板参数的推导，除非非常明显。显式地指定非类型模板参数可以提高代码的可读性。
了解类型限制： 确保非类型模板参数的类型是允许的。
考虑使用 constexpr： 如果可能，使用 constexpr 来定义非类型模板参数的值，以便在编译时进行计算。
使用推导指南简化代码： 当类的构造函数需要复杂参数时，使用推导指南可以简化代码并使类型推导更加方便。

总结

今天，我们深入探讨了 C++ 模板参数推导中非类型模板参数与约束匹配的关键方面。理解这些规则对于编写健壮、高效且可维护的模板代码至关重要。通过使用 Concepts 和约束推导指南，我们可以更好地控制模板参数的类型和值，从而提高代码的质量。掌握这些技巧是 C++ 模板元编程中不可或缺的一部分。

更多IT精英技术系列讲座，到智猿学院