您可以利用重载解析。可能有比这更短的实现

template<size_t I, typename T>
struct tester
{
    static T type(T);
    static std::integral_constant<size_t, I> index(T);
};

template<typename...>
struct overloader;

template<size_t... Is, typename... Ts>
struct overloader<std::index_sequence<Is...>, Ts...>
    : tester<Is, Ts>...
{
    using tester<Is, Ts>::type...;
    using tester<Is, Ts>::index...;
};

template<typename T, typename... Ts>
struct best_match
{
    using overloader = overloader<std::index_sequence_for<Ts...>, Ts...>;
    using value_type = decltype(overloader::type(std::declval<T>()));
    static constexpr auto index
        = decltype(overloader::index(std::declval<T>()))::value;
};

如何使用C++20

#include <type_traits>
#include <tuple>

template<typename TypeToConvert, typename... ListOfAvailableTypes>
struct best_match
{
    static_assert(sizeof...(ListOfAvailableTypes) > 0, "ListOfAvailableTypes must not be empty");

    static constexpr auto find_best_match() noexcept
    {
        constexpr auto update_best_match = [](auto best) constexpr noexcept {
            return [i = 0, &best](auto&& candidate) mutable constexpr -> decltype(auto) 
            {
                if constexpr (std::is_convertible_v<decltype(candidate), TypeToConvert> &&
                    (!std::is_same_v<TypeToConvert, decltype(candidate)>) &&
                    (!std::is_same_v<decltype(best), void> || 
                        !std::is_convertible_v<decltype(candidate), void>)) 
                {
                    if constexpr (std::is_same_v<decltype(best), void> ||
                        std::is_convertible_v<decltype(candidate), decltype(best)>)
                    {
                        return decltype(candidate){std::forward<decltype(candidate)>(candidate), i};
                    }
                }
                return std::move(best);
            };
        };

        return std::apply([&](auto&&... args) constexpr noexcept 
            {
            return (update_best_match(void{})(
                decltype(args){std::forward<decltype(args)>(args), 0}), ...);
            }
        , std::tuple_cat(std::tuple<ListOfAvailableTypes...>{}, std::tuple<>{}));
    }

    using value_type = typename decltype(find_best_match())::value_type;
    static constexpr int index = decltype(find_best_match())::index;
};