使用C++20模板化lambda的答案：

template <typename Tuple, typename T>
constexpr std::size_t GetIndexOfType()
{
    return []<typename... Ts>(std::type_identity<std::tuple<Ts...>> t){
        std::size_t index = 0;
        (void)((++index, std::is_same_v<Ts, T>) || ...);
        return index - 1;
    }(std::type_identity<Tuple>{});
}

字符串
fold表达式是一种令人费解的方式，表示“当类型不相同时，递增索引”。
尽管更规范的方法是使用注解中建议的std::index_sequence。
演示：https://godbolt.org/z/5a4P5Phfa
通过编写自己的type_identity并将lambda转换为自由函数，它可以轻松地适应C++17。

template <typename T>
struct type_identity{
    using type = T;
};

template <typename T, typename... Ts>
constexpr std::size_t GetIndexOfTypeHelper(type_identity<std::tuple<Ts...>>){
    std::size_t index = 0;
    (void)((++index, std::is_same_v<Ts, T>) || ...);
    return index - 1;    
}

template <typename Tuple, typename T>
constexpr std::size_t GetIndexOfType()
{
    return GetIndexOfTypeHelper<T>(type_identity<Tuple_Type>{});
}

型
演示：https://godbolt.org/z/Yhrrxv5dq

首先，注意GetIndexOfType真的不应该是一个函数，因为你没有使用任何对象，你只是在使用类型进行元编程。在这种情况下，类模板通常更优雅：

// helper template finds index of a type in a pack
template <typename T, typename... Ts>
struct index_of_type {
    static inline constexpr int value = [] {
        int i = 0;
        bool found = ((++i, std::is_same_v<T, Ts>) || ...);
        return found ? i - 1 : -1;
    }();
};

// helper template to find the index of a type in a tuple-like type
template <typename T, typename Tuple, typename = void>
struct index_of_tuple_type_impl;

template <typename T, typename Tuple>
struct index_of_tuple_type_impl<T, Tuple, std::void_t<decltype(std::tuple_size_v<Tuple>)>> {
    template <std::size_t... Is>
    static constexpr auto get(std::index_sequence<Is...>) {
        return index_of_type<T, std::tuple_element_t<Is, Tuple>...>::value;
    }
    static inline constexpr auto value = get(std::make_index_sequence<std::tuple_size_v<Tuple>>{});
};

// clean interface
template <typename T, typename Tuple>
struct index_of_tuple_type : index_of_tuple_type_impl<T, Tuple> {};

template <typename T, typename Tuple>
inline constexpr int index_of_tuple_type_v = index_of_tuple_type<T, Tuple>::value;

测试

static_assert(index_of_tuple_type_v<int, std::tuple<float, double, int>> == 2);
static_assert(index_of_tuple_type_v<long, std::tuple<float, double, int>> == -1);
static_assert(index_of_tuple_type_v<int, std::array<int, 3>> == 0);

型

• 见live example at Compiler Explorer *

进一步说明

但是std::is_same_v似乎认为这两个是相同的类型。所以如果我想用std::is_same_v解决这个问题，这是一个问题。
这不是你能解决的;这是C++的一个基本问题。别名是弱的，即typedef和using不会创建一个不同的类型。std::is_same_v<int, alias_for_int>总是为真，无论你做什么。
另请参阅Strongly typed using and typedef了解变通方法。