C++ `template ` (C++17)：非类型模板参数的更灵活用法 - 智猿学院-前后端，数据库，人工智能，云计算等领域前沿技术讲座

哈喽，各位好！

今天我们来聊聊C++17引入的一个非常酷炫的特性：template <auto>，也就是非类型模板参数的更灵活的用法。这玩意儿让模板编程一下子变得更强大、更方便，也更…嗯…更符合直觉了。

从前的日子：硬编码的痛苦

在C++17之前，我们定义非类型模板参数的时候，那叫一个痛苦。必须明确指定参数的类型，比如：

template <int N>
struct MyArray {
  int data[N];
};

int main() {
  MyArray<10> arr; // 必须明确指定大小
  return 0;
}

看起来好像也没什么大不了的，但问题来了：

类型限制： 只能是整型、枚举、指针等少数几种类型。想用double做大小？对不起，不行。
必须明确指定： 每次使用模板都得手动写死参数值，稍微改一下数值，整个代码都得跟着改。想想都头疼。

这就像让你买衣服，只能买固定尺码，颜色也只能选黑白灰，稍微想要点个性化，就直接被扼杀在摇篮里了。

template <auto>：解放生产力！

C++17引入的template <auto>就像一把钥匙，打开了非类型模板参数的新世界大门。现在，我们可以这样写：

template <auto N>
struct MyArray {
  int data[N];
};

int main() {
  MyArray<10> arr1;      // N推导为int
  MyArray<10u> arr2;     // N推导为unsigned int
  //MyArray<10.0> arr3;   // error: 浮点数不能作为非类型模板参数 (C++20允许)
  return 0;
}

看到了吗？类型和值都由编译器自动推导！是不是感觉一下子轻松多了？

template <auto>的类型推导规则

虽然编译器会自动推导类型，但也不是随便乱来的。它遵循一定的规则：

基本类型： 对于整型、枚举类型，会推导成对应的类型（int、unsigned int、enum class MyEnum等等）。
指针类型： 可以推导成指针类型，但必须是指向具有外部链接的变量或函数的指针。
引用类型： 可以推导成引用类型，同样必须是对具有外部链接的变量的引用。
字面值类型： 可以推导成字面值类型，例如const char* (字符串字面量)。

用表格总结一下：

类型	推导结果
整型字面量	`int`, `unsigned int`, `long`, `unsigned long` 等 (取决于字面量的大小和后缀)
枚举类型	`enum class MyEnum`
指针	指向具有外部链接的变量或函数的指针
引用	对具有外部链接的变量的引用
字符串字面量	`const char*`

template <auto>的应用场景

template <auto>的应用场景非常广泛，可以大大简化我们的代码，提高代码的可读性和可维护性。

静态数组大小： 就像上面的例子，可以方便地定义静态数组的大小，而不用手动指定类型。

编译期计算： 可以利用模板参数进行编译期计算，生成不同的代码。

template <auto N>
constexpr auto factorial() {
  if constexpr (N <= 1) {
    return 1;
  } else {
    return N * factorial<N - 1>();
  }
}

int main() {
  constexpr auto result = factorial<5>(); // 编译期计算5的阶乘
  static_assert(result == 120, "Factorial calculation failed!");
  return 0;
}

字符串字面量处理： 可以方便地处理字符串字面量，例如计算字符串长度、生成哈希值等。

template <auto str>
constexpr size_t string_length() {
  size_t len = 0;
  while (str[len] != '') {
    ++len;
  }
  return len;
}

int main() {
  constexpr auto len = string_length<"Hello, world!">();
  static_assert(len == 13, "String length calculation failed!");
  return 0;
}

维度信息传递： 在处理多维数组或矩阵时，可以将维度信息作为模板参数传递，避免运行时开销。

template <auto Rows, auto Cols>
struct Matrix {
  double data[Rows * Cols];

  double& at(size_t row, size_t col) {
    return data[row * Cols + col];
  }
};

int main() {
  Matrix<3, 4> matrix; // 3行4列的矩阵
  matrix.at(1, 2) = 3.14;
  return 0;
}

编译期状态机： 可以构建编译期状态机，根据不同的状态生成不同的代码。这在一些嵌入式系统或者对性能要求极高的场景下非常有用。

enum class State {
  Idle,
  Running,
  Finished
};

template <State S>
struct StateMachine {
  void process() {
    if constexpr (S == State::Idle) {
      // Idle状态下的处理逻辑
      std::cout << "Idle State" << std::endl;
    } else if constexpr (S == State::Running) {
      // Running状态下的处理逻辑
      std::cout << "Running State" << std::endl;
    } else {
      // Finished状态下的处理逻辑
      std::cout << "Finished State" << std::endl;
    }
  }
};

int main() {
  StateMachine<State::Running> sm;
  sm.process(); // 输出 "Running State"
  return 0;
}

进阶用法：配合if constexpr

template <auto>和if constexpr简直是天作之合！if constexpr允许我们在编译期进行条件判断，根据不同的模板参数生成不同的代码。这使得我们可以编写更加灵活、更加高效的模板。

template <auto N>
struct MyStruct {
  void print() {
    if constexpr (std::is_same_v<decltype(N), int>) {
      std::cout << "N is an integer: " << N << std::endl;
    } else if constexpr (std::is_same_v<decltype(N), const char*>) {
      std::cout << "N is a string: " << N << std::endl;
    } else {
      std::cout << "N is of unknown type." << std::endl;
    }
  }
};

int main() {
  MyStruct<123> s1;
  s1.print(); // 输出 "N is an integer: 123"

  MyStruct<"Hello"> s2;
  s2.print(); // 输出 "N is a string: Hello"

  return 0;
}

在这个例子中，我们根据N的类型，分别输出了不同的信息。

C++20的增强：浮点数和类类型

C++20进一步增强了template <auto>的功能，允许使用浮点数和某些类类型作为非类型模板参数。这使得template <auto>的应用场景更加广泛。

template <auto Value>
struct MyFloatStruct {
    static constexpr double value = Value;
};

int main() {
    MyFloatStruct<3.14> float_struct;
    std::cout << float_struct.value << std::endl; // 输出 3.14
    return 0;
}

C++20对于类类型做了一些限制，只有满足特定条件的类才能作为非类型模板参数。这些条件包括：

该类必须具有 literal type 特性。
具有 equality comparison 能力。

需要注意的地方

虽然template <auto>很强大，但也有一些需要注意的地方：

代码膨胀： 滥用模板可能会导致代码膨胀，因为编译器会为每个不同的模板参数生成一份代码。所以要权衡利弊，避免过度使用。
编译时间： 复杂的模板可能会增加编译时间。
类型推导失败： 如果编译器无法推导出类型，或者推导出的类型不符合预期，就会导致编译错误。

最佳实践

明确类型： 虽然template <auto>可以自动推导类型，但在某些情况下，为了提高代码的可读性和可维护性，最好还是明确指定类型。例如，template <auto N>可以写成template <int N>。
使用static_assert： 可以使用static_assert在编译期检查模板参数是否满足预期。
避免过度使用： 模板是一种强大的工具，但也要避免过度使用，以免导致代码膨胀和编译时间增加。

总结

template <auto>是C++17引入的一个非常实用的特性，它简化了非类型模板参数的使用，提高了代码的可读性和可维护性。C++20又进一步增强了template <auto>的功能，允许使用浮点数和类类型作为非类型模板参数。掌握template <auto>，可以让我们编写更加灵活、更加高效的C++代码。

希望这次讲解对大家有所帮助！记住，编程就像人生，充满了各种可能性，而template <auto>就是一种让你的代码人生更加精彩的可能性！

发表回复 取消回复

发表回复取消回复