为什么 C++ 函数模板实例化的返回类型包含在损坏的函数名称中？

Question

Itanium ABI specifies，除了一些无趣的例外，返回类型包含在模板实例的错位名称中，但不包含在非模板中。

这是为什么？在什么情况下你可以有两个函数模板实例，链接器需要区分它们，因为它并不表示违反单一定义规则或类似情况？

作为我的意思的一个例子：

class ReturnType {};
class ParamType {};

template <typename T>
ReturnType foo(T p)  {
    return ReturnType();
};
template ReturnType foo<ParamType>(ParamType);

ReturnType bar(ParamType p) {
    return ReturnType();
}

然后生成的目标文件有修改：

ReturnType foo<ParamType>(ParamType)
   => _Z3fooI9ParamTypeE10ReturnTypeT_
                        ^^^^^^^^^^^^

ReturnType bar(ParamType)
   => _Z3bar9ParamType

为什么foo 需要ReturnType 而bar 不需要？

（我假设这是有原因的，这不仅仅是一个随意的选择。）

Answer 1

也许是因为，与普通函数相反，函数模板签名包含返回类型？ §1.3：

1.3.17 签名 <function> 名称、参数类型列表 (8.3.5) 和封闭命名空间（如果有）
[ 注意: 签名用作 名称修改和链接的基础。 — 尾注 ]

---

1.3.18 签名 <function template> 名称，参数类型列表（8.3.5），封闭命名空间（如果有），返回 类型和模板参数列表

假设我们可以有两个完全不同的函数模板重载，它们的返回类型不同，如果这样写的话：

template <int>
char foo();

template <int>
int foo();

如果名称修改不考虑返回类型，那么链接这些模板将很困难，因为foo<0> 没有唯一地命名一个专业化。不过，可以使用重载解析（不带参数）来解决一种专门化问题：

int (*funptr)() = foo<0>;   

另一方面，普通函数不需要包含返回类型，因为它们不能在其返回类型上重载 - 即它们的签名不包含返回类型。

Answer 2

与常规函数不同，模板函数可能仅通过返回类型重载。

template <typename T> int f() { return 1; }
template <typename T> long f() { return 2; }

int main() {
  int (&f1) () = f<void>;
  long (&f2) () = f<void>;
  return f1() == f2();
}

这里，假设一个非优化编译器，生成的程序集将包含两个函数f<void>()，但它们不能共享相同的错位名称，否则main 的生成程序集将无法指定它指的是哪个实例化。

通常，如果您有一个重载的模板函数，则只有一个定义将用于特定的模板参数，所以这并不常见，但在 Columbo 的回答中，dyp 提出了如何实现这一点的基本想法可能实际上很有用。在Can addressof() be implemented as constexpr function?，我想出了

template <bool>
struct addressof_impl;

template <>
struct addressof_impl<false> {
  template <typename T>
  static constexpr T *impl(T &t) {
    return &t;
  }
};

template <>
struct addressof_impl<true> {
  template <typename T>
  static /* not constexpr */ T *impl(T &t) {
    return reinterpret_cast<T *>(&const_cast<char &>(reinterpret_cast<const volatile char &>(t)));
  }
};

template <typename T>
constexpr T *addressof(T &t)
{
  return addressof_impl<has_overloaded_addressof_operator<T>::value>::template impl<T>(t);
}

但是，如果在多个翻译单元中使用相同的实例化 addressof<X>，这实际上是违反 ODR 的，有些 X 不完整，有些 X 完整并且具有重载的 & 运算符。这可以通过使用常规重载函数直接执行addressof 内部的逻辑来重新处理。

template <typename T>
std::enable_if_t<has_overloaded_addressof_operator<T>::value, T *>
addressof(T &t)
{
  return reinterpret_cast<T *>(&const_cast<char &>(reinterpret_cast<const volatile char &>(t)));
}

template <typename T>
constexpr
std::enable_if_t<!has_overloaded_addressof_operator<T>::value, T *>
addressof(T &t)
{
  return &t;
}

（出于同样的原因，has_overloaded_addressof_operator 也需要内联。）

这样就避免了问题：当X 不完整时，addressof<X> 所指的函数与X 完整时不同。