是否可以获得函数模板的隐式实例化的地址？

Question

我想知道是否有任何方法可以获取由一组特定参数生成的函数模板的实例化地址。

#include <iostream>

template <typename T>
class A {}; 

template <typename T, typename T2>
int hello(A<T> a, A<T2> b, int c)
{
    return 69; 
}

int main()
{
    A<int> a;
    A<float> b;
    std::cout << (&hello)(a, b, 3) << "\n";                                                                                                                                                           

    return 0;
}

此代码打印函数调用返回的值。如何打印为 a 和 b 参数实例化的“hello”版本的地址？我希望编译器能够推断出类型。

Answer 1

根据参数确定要调用的函数的过程称为重载解析，标准列出了在哪些情况下使用它：

13.3 重载分辨率 [over.match]

2 重载解析选择要在语言内的七个不同上下文中调用的函数：

(2.1) -- 调用以函数调用语法命名的函数（13.3.1.1.1）；

(2.2) -- 在类对象上调用函数调用运算符、指针到函数的转换函数、引用到指针到函数的转换函数或引用到函数的转换函数命名为 在函数调用语法中（13.3.1.1.2）；

(2.3) -- 调用表达式中引用的运算符 (13.3.1.2);

(2.4) -- 为类对象 (13.3.1.3) 的直接初始化 (8.5) 调用构造函数；

(2.5) -- 为类对象 (13.3.1.4) 的复制初始化 (8.5) 调用用户定义的转换；

(2.6) -- 调用转换函数以从类类型的表达式中初始化非类类型的对象 (13.3.1.5)；和

(2.7) -- 调用转换函数以转换为引用 (8.5.3) 将直接绑定到的泛左值或类纯右值 (13.3.1.6)。

其中，唯一适用于常规函数的是 2.1，它需要一个 f(args) 上下文，它只告诉调用者结果。

因此，您所要求的无法完成。无论如何，不​​完全是。

现在，根据您想要完成的任务，有些事情是可能的：

如果你知道 exact 签名，则可以获得指向函数的指针：给定template <typename T> int hello(A<T> a, A<T> b)，你可以使用它来获取地址：static_cast<int(*)(A<int>,A<int>)>(hello)。但是，要使其正常工作，您需要知道返回类型（您可以使用 decltype 获得），并且您需要知道参数类型（可能与参数类型不同，并且您是'不能可靠地获得）。

还可以获得一个指向函数的指针，该函数在调用时会产生与hello 相同的效果：

auto callable = +[](A<int> a, A<int> b) { return hello(a, b); };

[](A<int> a, A<int> b) { return hello(a, b); } 创建一个没有任何捕获的 lambda，并且没有任何捕获的 lambda 可以隐式转换为匹配类型的函数指针。 + 强制使用该转换，而不需要拼写出类型。

但是，这与hello 的地址不同，因此可能不适合后续比较。

这是你能得到的最好的。

Answer 2

我在Ideone中试过这个：

// A and hello defined as OP
int main()
{
    A<int> a;
    A<float> b;

    decltype(hello(a,b,3)) (*pf)(decltype(a), decltype(b), decltype(3))=hello;
    std::cout << (void*)pf << "\n";                                                                                                                                                           

    return 0;
}

好像输出了一个内存地址。

Answer 3

@hvd：AFAIK，你不能在不知道你想要包装的函数的签名的情况下声明一个 lambda（lambdas 不能被模板化）。但是您可以使用带有静态方法的中间类：

#include <functional>
#include <iostream>

template<class A>
void func(A a, int b)
{
    std::cout << "a=" << a << " b=" << b << "\n";
}

template<class... A>
class proxy_func
{
public:
    static auto call(A... args) -> decltype(func(args...))
        {
            return func(args...);
        }
};

template<template<class...> class P, class... User>
void* addr(User... user)
{
    return (void*)&P<User...>::call;
}

template<template<class...> class P, class... User>
auto call(User... user) -> decltype(P<User...>::call(user...))
{
    return P<User...>::call(user...);
}

template<class T>
void test()
{
    T value = 1;
    printf("func > %p\n", &func<T>);
    printf("func > ");
    func(value, 1);
    printf("proxy> %p\n", &proxy_func<T, int>::call);
    printf("proxy> ");
    proxy_func<T, int>::call(value, 1);
    printf("auto > %p\n", addr<proxy_func>(value, 1));
    printf("auto > ");
    call<proxy_func>(value, 1);
}

int main(int argc, char **argv)
{
    printf("==int==\n");
    test<int>();
    printf("==long==\n");
    test<long>();
}

结果是这样的：

g++ -std=c++11 -o /tmp/test /tmp/test.cpp && /tmp/test
==int==
func > 0x400a8d
func > a=1 b=1
proxy> 0x400ae6
proxy> a=1 b=1
auto > 0x400ae6
auto > a=1 b=1
==long==
func > 0x400b35
func > a=1 b=1
proxy> 0x400b91
proxy> a=1 b=1
auto > 0x400b91
auto > a=1 b=1

当然，这需要声明一个知道目标函数的 name 的通用代理（仅此而已），这可能无法作为@JavierCabezasRodríguez 的解决方案接受。

PS：抱歉，我没有将它作为评论发布，但我没有足够的声誉。

编辑

使用代理类而不是 lambda 无需知道参数的数量，因此您可以使用 hackishly 宏方法来包装任何目标函数：

#define proxy(f)                                \
    template<class... A>                        \
    class proxy_ ## f                           \
    {                                           \
    public:                                                     \
        static auto call(A... args) -> decltype(f(args...))     \
        {                                                       \
            return f(args...);                                  \
        }                                                       \
    }

proxy(func);