C++模板编译递归实例化超限：为何U被推导为Point2<double>？

使用clang-16编译器，以-std=c++17选项编译以下代码时出现递归模板实例化超限错误：

#include <type_traits>

template <typename T>
struct Point2 {
  Point2() = default;
  Point2(const T& x, const T& y) : x(x), y(y) {}

  template <typename U>
  Point2(const U& other) : x(other.x), y(other.y) {}
  
  template<typename U>
  friend Point2<decltype(T() * U())> operator*(const Point2<T>& vec, U scale) {
    return {vec.x * scale, vec.y * scale};
  }
  
  template<typename U>
  friend Point2<decltype(T() * U())> operator*(U scale, const Point2<T>& vec) {
    return {vec.x * scale, vec.y * scale};
  }

  T x;
  T y;
};

int main() {
  Point2<double> a;
  double b;
  auto c = a * b;
}

编译错误信息 #

ce.cpp:4:8: warning: stack nearly exhausted; compilation time may suffer, and crashes due to stack overflow are likely [-Wstack-exhausted]
struct Point2 {
       ^
ce.cpp:12:30: note: while substituting deduced template arguments into function template 'operator*' [with U = Point2<double>]
  friend Point2<decltype(T() * U())> operator*(const Point2<T>& vec, U scale) {
                             ^
ce.cpp:12:30: note: while substituting deduced template arguments into function template 'operator*' [with U = Point2<double>]
ce.cpp:12:30: note: while substituting deduced template arguments into function template 'operator*' [with U = Point2<double>]
ce.cpp:12:30: note: while substituting deduced template arguments into function template 'operator*' [with U = Point2<double>]
ce.cpp:12:30: note: while substituting deduced template arguments into function template 'operator*' [with U = Point2<double>]
ce.cpp:12:30: note: (skipping 472 contexts in backtrace; use -ftemplate-backtrace-limit=0 to see all)
ce.cpp:12:30: note: while substituting deduced template arguments into function template 'operator*' [with U = Point2<double>]
ce.cpp:12:30: note: while substituting deduced template arguments into function template 'operator*' [with U = Point2<double>]
ce.cpp:12:30: note: while substituting deduced template arguments into function template 'operator*' [with U = Point2<double>]
ce.cpp:17:30: note: while substituting deduced template arguments into function template 'operator*' [with U = Point2<double>]
  friend Point2<decltype(T() * U())> operator*(U scale, const Point2<T>& vec) {
                             ^
ce.cpp:28:14: note: while substituting deduced template arguments into function template 'operator*' [with U = Point2<double>]
  auto c = a * b;
             ^
ce.cpp:12:26: fatal error: recursive template instantiation exceeded maximum depth of 1024
  friend Point2<decltype(T() * U())> operator*(const Point2<T>& vec, U scale) {
                         ^
ce.cpp:12:30: note: while substituting deduced template arguments into function template 'operator*' [with U = Point2<double>]
  friend Point2<decltype(T() * U())> operator*(const Point2<T>& vec, U scale) {
                             ^
ce.cpp:12:30: note: while substituting deduced template arguments into function template 'operator*' [with U = Point2<double>]
ce.cpp:12:30: note: while substituting deduced template arguments into function template 'operator*' [with U = Point2<double>]
ce.cpp:12:30: note: while substituting deduced template arguments into function template 'operator*' [with U = Point2<double>]
ce.cpp:12:30: note: while substituting deduced template arguments into function template 'operator*' [with U = Point2<double>]
ce.cpp:12:30: note: (skipping 1015 contexts in backtrace; use -ftemplate-backtrace-limit=0 to see all)
ce.cpp:12:30: note: while substituting deduced template arguments into function template 'operator*' [with U = Point2<double>]
ce.cpp:12:30: note: while substituting deduced template arguments into function template 'operator*' [with U = Point2<double>]
ce.cpp:12:30: note: while substituting deduced template arguments into function template 'operator*' [with U = Point2<double>]
ce.cpp:17:30: note: while substituting deduced template arguments into function template 'operator*' [with U = Point2<double>]
  friend Point2<decltype(T() * U())> operator*(U scale, const Point2<T>& vec) {
                             ^
ce.cpp:28:14: note: while substituting deduced template arguments into function template 'operator*' [with U = Point2<double>]
  auto c = a * b;
             ^
1 warning and 1 error generated.

可行修复方案 #

方案1：注释掉模板构造函数 #

...
  // template <typename U>
  // Point2(const U& other) : x(other.x), y(other.y) {}
  ...

方案2：改用auto推导operator*的返回类型 #

修改第一个operator*：

...
  template<typename U>
  friend auto operator*(const Point2<T>& vec, U scale) {
    return Point2{vec.x * scale, vec.y * scale};
  }
  ...

或者修改第二个operator*：

...
  template<typename U>
  friend auto operator*(U scale, const Point2<T>& vec) {
    return Point2{vec.x * scale, vec.y * scale};
  }
  ...

问题根源分析 #

为什么U会被推导为Point2<double>？ #

问题出在模板构造函数和decltype(T() * U())的组合逻辑上：

1. 编译器处理a * b时，初始尝试匹配operator*(const Point2<double>&, U)，此时U的候选类型是double。
2. 但推导返回类型Point2<decltype(T() * U())>时，模板构造函数允许任何类型U隐式转换为Point2<T>——编译器会同时考虑两种路径：直接计算double * double，或者将U()（即double()）转换为Point2<double>后调用operator*(Point2<double>, Point2<double>)。
3. 一旦触发第二种路径，就会实例化U=Point2<double>的operator*，而该实例化又需要计算decltype(double() * Point2<double>())，进而再次触发转换与实例化，形成无限递归，最终超出模板实例化深度限制。

修复方案的原理 #

• 方案1：移除模板构造函数后，编译器无法将double隐式转换为Point2<double>，只会选择直接计算double * double的路径，避免递归。
• 方案2：用auto推导返回类型时，编译器会先确定函数参数类型（U=double），再根据返回语句推导返回类型，不会在参数推导阶段触发对T() * U()的复杂解析，从而规避递归实例化。

内容的提问来源于stack exchange，提问作者kaixin liu