使用“void_t”检测多重继承类型重复错误

Question

我想实现一个 has_no_duplicates<...> 类型特征，如果传递的可变类型列表没有重复类型，它的计算结果为 std::true_type。

static_assert(has_no_duplicates<int, float>{}, "");
static_assert(!has_no_duplicates<float, float>{}, "");

让我们假设，对于这个问题的范围，我想使用多重继承来做到这一点。

当一个class从同一类型继承不止一次时，就会发生错误。

template<class T> 
struct type { };

template<class... Ts>
struct dup_helper : type<Ts>... { };

// No errors, compiles properly.
dup_helper<int, float> ok{};

// Compile-time error: 
// base class 'type<float>' specified more than once as a direct base class
dup_helper<float, float> error{};

我以为我可以使用 void_t 来 "detect" 这个错误，但我无法实施有效的解决方案 following the code samples from cppreference.

这是我试过的：

template<class, class = void>
struct is_valid 
    : std::false_type { };

// First try:
template<class T>
struct is_valid<T, std::void_t<decltype(T{})>> 
    : std::true_type { };

// Second try:
template<class T>
struct is_valid<T, std::void_t<T>> 
    : std::true_type { };

第三次尝试，我尝试使用包装器 class 延迟 dup_helper<...> 的扩展，该包装器将 dup_helper 作为模板模板参数，如 wrapper<dup_helper, ...> 并扩展它在 void_t.

里面

不幸的是，我的所有尝试都导致上述错误始终阻止编译。

我认为这种类型的错误无法检测为 "substitution failure"，但我想确认一下。

使用void_t真的无法检测到这种错误吗？（会不会一直编译失败？）

有没有办法在不导致编译失败的情况下进行检测？（或者仍然使用 "multiple inheritance trick" 的非 void_t 解决方法）？

Answer 1

正如@Canoninos 指出的那样，问题在于：

it isn't the declaration of dup_helper<T, T> which causes an error but its definition [...].

或者，在标准语中，错误发生在替换的 "immediate context" ([temp.deduct]) 之外：

8 - [...] Only invalid types and expressions in the immediate context of the function type and its template parameter types can result in a deduction failure. [ Note: The evaluation of the substituted types and expressions can result in side effects such as the instantiation of class template specializations and/or function template specializations, the generation of implicitly-defined functions, etc. Such side effects are not in the “immediate context” and can result in the program being ill-formed. — end note ]

此处发生错误 while instantiating dup_helper<float, float> 所以不在 "immediate context".

一个与您非常接近的多重继承技巧涉及通过索引多个碱基来添加额外的继承层：

helper<<0, 1>, <float, float>>        
             +            
        +----+----+       
        v         v       
 ix<0, float>  ix<1, float>
        +         +       
        v         v       
     t<float>  t<float>

这为我们提供了一个具有有效定义的助手 class，它可以被实例化但不能转换为它的最终基础 classes，因为歧义：

static_cast<t<float>>(helper<...>{});  // Error, SFINAE-usable

Example.

Answer 2

这是我使用元编程和类型列表惯用法的解决方案。我将此代码用作我的 C++ 反射库的一部分。我认为根本不需要 void_t 或继承来解决这个任务。

template <typename ...Args>
struct type_list
{};

using empty_list = type_list<>;

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

// is_typelist
template<typename T>
struct is_typelist: std::false_type
{};

template<typename ...Args>
struct is_typelist<type_list<Args...>>: std::true_type
{};

template<typename T>
struct check_typelist
{
    using type = void;
    static constexpr void *value = nullptr;
    static_assert(is_typelist<T>::value, "T is not a type_list!");
};

// indexof
namespace internal {

template<typename T, typename V, std::int64_t index>
struct typelist_indexof_helper: check_typelist<T>
{};

template<typename H, typename ...T, typename V, std::int64_t index>
struct typelist_indexof_helper<type_list<H, T...>, V, index>:
        std::conditional<std::is_same<H, V>::value,
            std::integral_constant<std::int64_t, index>,
            typelist_indexof_helper<type_list<T...>, V, index + 1>
        >::type
{};

template<typename V, std::int64_t index>
struct typelist_indexof_helper<empty_list, V, index>: std::integral_constant<std::int64_t, -1>
{};

}

template<typename T, typename V>
using typelist_indexof = ::internal::typelist_indexof_helper<T, V, 0>;

template<typename T, typename V>
struct typelist_exists: std::integral_constant<bool, typelist_indexof<T, V>::value >= 0>
{};

// remove_duplicates
namespace internal {

template<typename P, typename T>
struct typelist_remove_duplicates_helper: check_typelist<T>
{};

template<typename ...P, typename H, typename ...T>
struct typelist_remove_duplicates_helper<type_list<P...>, type_list<H, T...>>:
        std::conditional<typelist_exists<type_list<T...>, H>::value,
            typelist_remove_duplicates_helper<type_list<P...>, type_list<T...>>,
            typelist_remove_duplicates_helper<type_list<P..., H>, type_list<T...>>
        >::type
{};

template<typename ...P>
struct typelist_remove_duplicates_helper<type_list<P...>, empty_list>: identity<type_list<P...>>
{};

}

template<typename T>
using typelist_remove_duplicates = ::internal::typelist_remove_duplicates_helper<empty_list, T>;


template<typename ...Args>
struct has_no_duplicates: std::integral_constant<bool, std::is_same<type_list<Args...>,
                                                                    typename typelist_remove_duplicates<type_list<Args...>>::type>::value>
{};

DEMO

使用“void_t”检测多重继承类型重复错误

Using `void_t` to detect multiple inheritance type repetition errors

c++

templates

variadic-functions

sfinae

c++17