15

考虑以下函数：

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)
4

3 回答 3

6

gcc 正在使用“Italium C++ ABI”进行 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 的简化版本，它也直接对整个表达式进行编码，因为它依赖于实例化。与实例化相关的定义为：

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

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

于 2012-11-08T19:12:08.413 回答
4

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

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

于 2012-11-08T19:51:54.813 回答
1

我被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
于 2021-07-22T10:09:04.510 回答