Deducing address of template class's overloaded method results in "error: expected primary-expression before ‘decltype’"

Question

I was experimenting with finding a type & then assigning the method, such as:

decltype(std::addressof(&std::vector<int>::push_back<int&&>)) x =
&std::vector<int>::push_back;

I was stuck at following error:

error: expected primary-expression before ‘decltype’

Above code is only as a minimal example. In reality, the address of the method will be passed to a template class along with its type. i.e. it can be &std::set<T>::insert<T&&> as well. Hence auto may NOT be an option.
See the pseudo code:

template<typename Type, // <-- int, float
         template<typename...> class Container, // <-- std::vector, std::set
         typename Method_t,  // <-- decltype(push_back(T&&), insert(T&&))
         Method_t Method>  // <-- push_back(T&&), insert(T&&)
struct Wrap { ... };

#define WRAP(TYPE, CONTAINER, METHOD) \
  Wrap<TYPE, CONTAINER, decltype(&CONTAINER<TYPE>::METHOD<TYPE&&>), &CONTAINER<TYPE>::METHOD>

Usage:

WRAP(int, std::vector, push_back); // uses `push_back(int&&)`
WRAP(float, std::set, insert);  // uses `insert(float&&)`

What is the correct way to deduce the address of a template class's overloaded member method?

In my case, Method_t is supposed to be any among the push_back, insert, push_front, push with the T&& overload versions only.
This Qn didn't help: Address of templated member function

Answer 1

As of today, it's not possible to automatically deduce the overloaded functions per se. One needs to specify its complete signature in the left side for the compiler to be able to deduce the appropriate type.
Example: for following 2 functions:

void C::foo (int);
void C::foo (double);

One must mention the complete prototype on the LHS,

void (C::*method)(int) = &C::foo;  // OK

But unfortunately we can't do something like,

auto method = &C::foo(int);  // not allowed

Hence, whatever is asked in the Qn is Not possible to achieve in its current form.

---

But if the requirement is little tweaked, then one can deduce the return type and still achieve the final desired results.
Here is a little changed syntax for struct Wrap:

template<typename Type,
         template<typename...> class Container,
         typename Return,  // <--- changed
         Return (Container<Type>::*Method)(Type&&)>  // <--- full definition
struct Wrap { ... }

With above changed code, instead of deducing the type of whole method, we just need to deduce the "return type". The argument is already known to be Type&& as already specified in the Qn. Now the WRAP macro looks like this:

#define WRAP(TYPE, CONTAINER, METHOD) \
  Wrap<TYPE, CONTAINER, decltype(((CONTAINER<TYPE>*)nullptr)->METHOD(TYPE())), &CONTAINER<TYPE>::METHOD>

Usage:

WRAP(int, std::vector, push_back) wrap;

Application Demo.

Answer 2

First off, std::addressof takes the address of objects, not of members (in the sense of pointers-to-member).

Second, std::vector<int>::push_back is not a template.

Third, to control overload resolution when taking the address of a function, use the cast notation:

static_cast<void (std::vector<int>::*)(int&&)>(&std::vector<int>::push_back)
//          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^
//          overload                            name of overload set