C++ template pass method name, deduce all overload

I have simple class

template <typename T>
using ConversionFunction = T(*)(T val);

static int Foo1(int x)
{
	return x * x;
}

static double Foo1(double x)
{
	return x * x + 1;
}


struct Foo
{
	ConversionFunction<double> d;
	ConversionFunction<int> i;
	ConversionFunction<float> f;
	
	template <typename T>
	void assign(){
		//??
	}
};

Is it possible to write something like this:

Foo f;
f.assign<Foo1>();

and assign method will automatically obtain pointers to all existing methods with the Foo1 name? Something like this:

template <typename T>
void assign(){    		
  d = if exist(T for double) ? &(T for double) : nullptr;
  i = if exist(T for int) ? &(T for int) : nullptr;
  f = if exist(T for float) ? &(T for float) : nullptr;
}

You can't just use name to pass overload set.

Alternative is to wrap it inside a class/lambda:

template <typename T>
struct to_function_pointer
{
    template <typename U>
    operator ConversionFunction<U> () const { return [](U x){ return T{}(x); }; }
};

const auto foo_caller = to_function_pointer<decltype([](auto x)-> decltype(Foo1(x)){ return Foo1(x); })>();

Demo

Names cannot be passed around in the C++ type system. It's a major source of pain in many problems, but it's just the way it is. You can pass values around, or in the case of templates: types and other templates as well. But names must be resolved to a value or type before they are "passed on" in any context.

The only (sort of) exception to that is the pre-processor, since it operates on tokens, you can leverage it to generate new values and type from names. If that is not something that turns your stomach, you could create this plumbing in C++20 and onward

#include <type_traits>
#include <cassert>

#define LIFT_ADDRESS(name)                       \
[]<typename T>(std::type_identity<T>) -> T(*)(T) \
requires requires(T(*ptr)(T)) { ptr = name; } {  \
    return name;                                 \
}

template <typename T>
using ConversionFunction = T(*)(T);

static int Foo1(int x)
{
    return x * x;
}

static double Foo1(double x)
{
    return x * x + 1;
}


struct Foo
{
    ConversionFunction<double> d{};
    ConversionFunction<int> i{};
    ConversionFunction<float> f{};
    
    template <class Lifted>
    void assign(Lifted l) {
        if constexpr(requires { l(std::type_identity<double>{}); })
            d = l(std::type_identity<double>{});
        if constexpr(requires { l(std::type_identity<int>{}); })
            i = l(std::type_identity<int>{});
        if constexpr(requires { l(std::type_identity<float>{}); })
            f = l(std::type_identity<float>{});
    }
};

int main() {
    Foo f;
    f.assign(LIFT_ADDRESS(Foo1));

    assert(f.d);
    assert(f.i);
    assert(!f.f);
}

The macro is really just a means to turning the names of overload sets into new function object (hence the "LIFT" nomenclature). Once you have that, you can pass it around into functions (and function templates), as well as examining it for its properties in a requires expression (assuming it's sfiane-friendly).

The generic lambda simply accepts a tag that conveys a type, adds a requirement that a function pointer of said type can be assigned to from "name" (so the return is valid too) to be sfinae-friendly, and that's it. The body of assign simply uses a bunch of requires-expressions to check if this sifnae-friendly functor can be invoked, and if it does, it invokes it.

Much of the above can be emulated in earlier standards down to C++14 (the generic lambda is the bare minimum I believe), though the implementations become increasingly less pleasant.