Я пытаюсь предоставить оболочку вокруг std::invoke, чтобы выполнять работу по выводу типа функции, даже когда функция перегружена.
(я спросил связанный вопрос вчера для версии с переменным числом аргументов и указателем метода).

Когда функция имеет один аргумент, этот код (C++17) работает, как и ожидалось, при нормальных условиях перегрузки:

#include <functional>

template <typename ReturnType, typename ... Args>
using FunctionType = ReturnType (*)(Args...);

template <typename S, typename T>
auto Invoke (FunctionType<S, T> func, T arg)
{   
    return std::invoke(func, arg);
}

template <typename S, typename T>
auto Invoke (FunctionType<S, T&> func, T & arg)
{   
    return std::invoke(func, arg);
}

template <typename S, typename T>
auto Invoke (FunctionType<S, const T&> func, const T & arg)
{
    return std::invoke(func, arg);
}

template <typename S, typename T>
auto Invoke (FunctionType<S, T&&> func, T && arg)
{   
    return std::invoke(func, std::move(arg));
}

Уменьшение раздувания кода, очевидно, необходимо для большего количества входных аргументов, но это отдельная проблема.

Если у пользователя есть перегрузки, отличающиеся только const/references, например:

#include <iostream>

void Foo (int &)
{
    std::cout << "(int &)" << std::endl;
}

void Foo (const int &)
{
    std::cout << "(const int &)" << std::endl;
}

void Foo (int &&)
{
    std::cout << "(int &&)" << std::endl;
}

int main()
{
    int num;
    Foo(num);
    Invoke(&Foo, num);

    std::cout << std::endl;

    Foo(0);
    Invoke(&Foo, 0);
}

Затем Invoke неправильно выводит функцию с выводом g++:

(целое &)
(константное целое &)

(целое &&)
(константное целое &)

И клан++:

(целое &)
(константное целое &)

(целое &&)
(целое &&)

(Спасибо geza за указание на то, что выходы clang были другими).

Итак, Invoke имеет неопределенное поведение.

Я подозреваю, что метапрограммирование было бы подходом к решению этой проблемы. Независимо от этого, возможно ли правильно обрабатывать вывод типа на сайте Invoke?