Is it possible to obtain the address of a implicit instantiation of a function template?

Question

I would like to know if there is any way to obtain the address of the instantiation of a function template produced by a specific set of arguments.

#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;
}

This code prints the value returned by the function call. How can I print the address of the version of "hello" instantiated for a and b parameters? I would like the types to be inferred by the compiler.

Answer 1

The process of determining the function to call based on the arguments is called overload resolution, and the standard lists in which cases it gets used:

13.3 Overload resolution [over.match]

2 Overload resolution selects the function to call in seven distinct contexts within the language:

(2.1) -- invocation of a function named in the function call syntax (13.3.1.1.1);

(2.2) -- invocation of a function call operator, a pointer-to-function conversion function, a reference-to-pointer-to-function conversion function, or a reference-to-function conversion function on a class object named in the function call syntax (13.3.1.1.2);

(2.3) -- invocation of the operator referenced in an expression (13.3.1.2);

(2.4) -- invocation of a constructor for direct-initialization (8.5) of a class object (13.3.1.3);

(2.5) -- invocation of a user-defined conversion for copy-initialization (8.5) of a class object (13.3.1.4);

(2.6) -- invocation of a conversion function for initialization of an object of a nonclass type from an expression of class type (13.3.1.5); and

(2.7) -- invocation of a conversion function for conversion to a glvalue or class prvalue to which a reference (8.5.3) will be directly bound (13.3.1.6).

Of these, the only one that applies to regular functions is 2.1, and that requires a f(args) context which only tells the caller the result.

So, what you ask for cannot be done. Not exactly, anyway.

Now, depending on what you want to accomplish, there are some things that are possible:

It is possible to get a pointer to the function if you know the exact signature: given template <typename T> int hello(A<T> a, A<T> b), you can obtain the address using that: static_cast<int(*)(A<int>,A<int>)>(hello). However, for this to work, you need to know the return type (which you might be able to obtain using decltype), and you need to know the parameter types (which may be different from the argument types, and which you aren't able to obtain reliably).

It is also possible to get a pointer to a function that, when called, will have the same effect as hello:

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

The [](A<int> a, A<int> b) { return hello(a, b); } creates a lambda without any captures, and lambdas without any captures can implicitly be converted to a function pointer of a matching type. The + forces the use of that conversion, without requiring the type to be spelled out.

However, this will not have the same address as hello, so might not be suitable for subsequent comparisons.

That's the best you can get.

Answer 2

I tried this in 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;
}

It seemed to output a memory address.

Answer 3

@hvd: AFAIK, you cannot declare a lambda without knowing the signature of the function you wanna wrap (lambdas cannot be templated). But you can use an intermediate class with a static method instead:

#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>();
}

The result is this:

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

Of course, this requires declaring a generic proxy that knows about the name of the target function (nothing else), and that might not be acceptable as a solution for @JavierCabezasRodríguez.

PS: Sorry I did not post it as a comment, but I do not have enough reputation for it.

Edit

Using a proxy class instead of a lambda forgoes the need to know the number of parameters, so that you can use a hackishly macro approach to wrap any target function:

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

proxy(func);