Question

考虑以下功能：

template <typename A, typename B>
auto Min(A&& a, B&& b)
        -> decltype(a < b ? std::forward<A>(a) : std::forward<B>(b))
{
    return a < b ? std::forward<A>(a) : std::forward<B>(b);
}

片段Min(0, 1)使模板实例化为Min<int, int>。奇怪的是，Min的带有g ++和clang的错误名称为_Z3MinIiiEDTqultfp_fp0_cl7forwardIT_Efp_Ecl7forwardIT0_Efp0_EEOS0_OS1_ （又名：decltype (({parm#1}<{parm#2})?((forward<int>)({parm#1})) : ((forward<int>)({parm#2}))) Min<int, int>(int&&, int&&)）。换句话说，用于推断返回类型的表达式是错位名称的一部分。就个人而言，我期望在_Z3MinIiiET_OS0_OT0_（又名：int Min<int, int>(int&&, int&&)）的方面稍微有点理智。 为什么不是这样？

似乎g ++只将decltype表达式置于实际需要的情况下，因为这些表单都是_Z3Maxii：

auto Max(int x, int y) -> int
auto Max(int x, int y) -> decltype(0)

Answer 1

gcc正在使用"Italium C++ ABI" for mangling，它指定了

如果decltype的操作数表达式不是实例化依赖，则直接对结果类型进行编码。例如：

      int x;
      template<class T> auto f(T p)->decltype(x);
        // The return type in the mangling of the template signature
        // is encoded as "i".
      template<class T> auto f(T p)->decltype(p);
        // The return type in the mangling of the template signature
        // is encoded as "Dtfp_E".
      void g(int);
      template<class T> auto f(T p)->decltype(g(p));
        // The return type in the mangling of the template signature
        // is encoded as "DTcl1gfp_E".

第三个例子是OP的简化版本，它也直接编码整个表达式，因为它依赖于实例化。 Instantiation-dependent is defined as：

表达式是实例化依赖，如果它是依赖于类型或依赖于值的，或者它具有依赖于类型或依赖于值的子表达式。例如，如果p是依赖于类型的标识符，则表达式sizeof(sizeof(p))既不依赖于类型，也不依赖于值，但它依赖于实例化（如果之后可能会变为无效）替换模板参数p的结果是不完整的类型）。类似地，如果源表单包含实例化依赖表达式，则源代码中表示的类型依赖于实例化。例如，类型形式double[sizeof(sizeof(p))]（p类型相关标识符）是实例化依赖。

关键点在于，依赖于实例化的表达式“在替换后可能会变得无效”，这可能是他们在修改中留在未评估形式的原因。

Answer 2

如果重载函数模板，这些函数模板生成的函数（称为函数模板特化）需要不同。因此，C ++标准规定了函数模板特化的签名包括生成特化的函数模板的签名。

否则，如果两个模板都将实例化具有相同功能类型的函数，则它们会发生冲突。

Answer 3

我对 https://stackoverflow.com/a/13296666/53974 感到困惑，所以我做了一些实验，结果证实了答案。

只要两个模板不同，它们的特化就可以共存即使重载决议无法在它们之间进行选择；所以这个错位的名字包括模板签名。

由于无法选择重载决议，范围内的最新相关声明似乎掩盖了较早的声明。在下面的示例中，这两次可见 — notfun1 和 notfun 具有相同的来源但调用不同的专业化，而 template void fun<long>(long); 指的是两个实例中的不同模板。（我已经通过检查此来源的反汇编及其变体来确认两者）。

template<typename T> T var = {};
template long var<long>;
// long var; // Error

void fun(long) {}

template<typename T> void fun(T) {}
template void fun<long>(long); // void fun<long>(long)

void notfun1() {
  fun(1L);
  fun<long>(2); // Calls void fun<long>(long)
}

template<typename T> struct identity { using type = T; };
template<typename T> void fun(typename identity<T>::type);
template void fun<long>(long); // Generates void fun<long>(identity<long>::type)
//template void fun<long>(typename identity<long>::type); //Ditto, can't write both

void notfun() {
  fun(1L);
  fun<long>(2); // Calls void fun<long>(identity<long>::type)

}

template<typename T> void fun(typename identity<T>::type) {}

int main() {}

下面，为方便起见，在Mac x86_64上进行反汇编；如果你仔细观察，你会想要专注于 callq 目标。

$ c++filt __Z3funIlEvN8identityIT_E4typeE
void fun<long>(identity<long>::type)

$ c++filt __Z3funIlEvT_
void fun<long>(long)

$ g++ -fvisibility=hidden -std=c++17 spec.cpp -o spec; objdump -C --disassemble spec

spec:   file format Mach-O 64-bit x86-64


Disassembly of section __TEXT,__text:

0000000100003f40 fun(long):
100003f40: 55                           pushq   %rbp
100003f41: 48 89 e5                     movq    %rsp, %rbp
100003f44: 48 89 7d f8                  movq    %rdi, -8(%rbp)
100003f48: 5d                           popq    %rbp
100003f49: c3                           retq
100003f4a: 66 0f 1f 44 00 00            nopw    (%rax,%rax)

0000000100003f50 void fun<long>(long):
100003f50: 55                           pushq   %rbp
100003f51: 48 89 e5                     movq    %rsp, %rbp
100003f54: 48 89 7d f8                  movq    %rdi, -8(%rbp)
100003f58: 5d                           popq    %rbp
100003f59: c3                           retq
100003f5a: 66 0f 1f 44 00 00            nopw    (%rax,%rax)

0000000100003f60 notfun1():
100003f60: 55                           pushq   %rbp
100003f61: 48 89 e5                     movq    %rsp, %rbp
100003f64: bf 01 00 00 00               movl    $1, %edi
100003f69: e8 d2 ff ff ff               callq   -46 <__Z3funl>
100003f6e: bf 02 00 00 00               movl    $2, %edi
100003f73: e8 d8 ff ff ff               callq   -40 <__Z3funIlEvT_>
100003f78: 5d                           popq    %rbp
100003f79: c3                           retq
100003f7a: 66 0f 1f 44 00 00            nopw    (%rax,%rax)

0000000100003f80 notfun():
100003f80: 55                           pushq   %rbp
100003f81: 48 89 e5                     movq    %rsp, %rbp
100003f84: bf 01 00 00 00               movl    $1, %edi
100003f89: e8 b2 ff ff ff               callq   -78 <__Z3funl>
100003f8e: bf 02 00 00 00               movl    $2, %edi
100003f93: e8 08 00 00 00               callq   8 <__Z3funIlEvN8identityIT_E4typeE>
100003f98: 5d                           popq    %rbp
100003f99: c3                           retq
100003f9a: 66 0f 1f 44 00 00            nopw    (%rax,%rax)

0000000100003fa0 void fun<long>(identity<long>::type):
100003fa0: 55                           pushq   %rbp
100003fa1: 48 89 e5                     movq    %rsp, %rbp
100003fa4: 48 89 7d f8                  movq    %rdi, -8(%rbp)
100003fa8: 5d                           popq    %rbp
100003fa9: c3                           retq
100003faa: 66 0f 1f 44 00 00            nopw    (%rax,%rax)

0000000100003fb0 _main:
100003fb0: 55                           pushq   %rbp
100003fb1: 48 89 e5                     movq    %rsp, %rbp
100003fb4: 31 c0                        xorl    %eax, %eax
100003fb6: 5d                           popq    %rbp
100003fb7: c3                           retq

ABI错位名称中依赖于C ++模板参数的decltype

3 个答案: