检查可变参数模板参数的唯一性

传递指向base_all<U...>的指针只需要存在 base_all<U...> 声明。如果不尝试访问定义，编译器将不会检测到类型实际上定义不明确。缓解这个问题的一种方法是使用需要定义base_all<U...>的参数，例如：

template< class ...T> struct base_all
   : id<T> ...
{
    typedef int type;
};
// ...
template< class ... U>
static constexpr bool test(typename base_all<U...>::type) noexcept
{
    return true;
}

尽管上述回答了这个问题，但它无法编译：创建的多重继承不在适合考虑 SFINAE 的上下文中。我认为你不能利用不允许从两次继承的相同碱基的规则。但是，相关测试可以以不同的方式实现：

#include <type_traits>
template <typename...>
struct is_one_of;
template <typename F>
struct is_one_of<F>
{
    static constexpr bool value = false;
};
template <typename F, typename S, typename... T>
struct is_one_of<F, S, T...>
{
    static constexpr bool value = std::is_same<F, S>::value
        || is_one_of<F, T...>::value;
};
template <typename...>
struct is_unique;
template <>
struct is_unique<> {
    static constexpr bool value = true;
};
template<typename F, typename... T>
struct is_unique<F, T...>
{
    static constexpr bool value = is_unique<T...>::value
        && !is_one_of<F, T...>::value;
};
int main()
{
    constexpr bool b = is_unique<int, float, double>::value;
    constexpr bool c = is_unique< int, char, int>::value;
    static_assert( b == true && c == false , "!");
}

如果你有一个 C++17 编译器并且你的类型列表不是太大，那么使用折叠表达式只需 4 行代码即可完成。不过，算法本身具有二次复杂性。

template<typename T, typename... Types>
constexpr bool are_types_unique_v = (!std::is_same_v<T, Types> && ...) && are_types_unique_v<Types...>;
template<typename T>
constexpr bool are_types_unique_v<T> = true;

使用 C++17，您可以使用折叠表达式。特别是对于大量模板参数，此版本可能比此处介绍的其他解决方案快几个数量级（并且占用的内存更少）：

#include <type_traits>
template <typename T> 
struct Base{};
template <typename... Ts>
struct TypeSet : Base<Ts>...
{     
   template<typename T>
   constexpr auto operator+(Base<T>)
   {
      if constexpr (std::is_base_of_v<Base<T>, TypeSet>)
        return TypeSet{};
      else
        return TypeSet<Ts..., T>{};
   }
   constexpr auto size() const -> std::size_t
   {
      return sizeof...(Ts);
   }
};
template<typename... Ts>
constexpr auto are_unique() -> bool
{ 
   constexpr auto set = (TypeSet<>{} + ... + Base<Ts>{});
   return set.size() == sizeof...(Ts);
}
int main()
{
   static_assert(are_unique<int, float, char, char*>());
   static_assert(not are_unique<int, float, char, char>());
}

见 https://godbolt.org/z/_ELpyJ

另一个O（logN）实例化深度解决方案。它仍然需要进行重大清理、注释、命名空间、重命名和减少代码重复。

再次向Xeo致敬，其O（logN）实例化深度版本gen_seq这（再次）依赖于。

#include <cstddef>
    // using aliases for cleaner syntax
    template<class T> using Invoke = typename T::type;
    template<std::size_t...> struct seq{ using type = seq; };
    template<class S1, class S2> struct concat;
    template<std::size_t... I1, std::size_t... I2>
    struct concat<seq<I1...>, seq<I2...>>
      : seq<I1..., (sizeof...(I1)+I2)...>{};
    template<class S1, class S2>
    using Concat = Invoke<concat<S1, S2>>;
    template<std::size_t N> struct gen_seq;
    template<std::size_t N> using GenSeq = Invoke<gen_seq<N>>;
    template<std::size_t N>
    struct gen_seq : Concat<GenSeq<N/2>, GenSeq<N - N/2>>{};
    template<> struct gen_seq<0> : seq<>{};
    template<> struct gen_seq<1> : seq<0>{};

除了索引序列生成之外，此解决方案甚至应该具有 O（1） 实例化深度。它不是多重继承，而是使用std::array<std::false_type, size>通过 SFINAE 执行 O（1） 实例化深度 OR。

实施is_one_of .请注意，"是其中之一"是"唯一"的相反概念。

#include <array>
// check if `T` is in `Us...`
template<class T, class... Us>
struct is_one_of
{
    template<class T1>
    static constexpr auto SFINAE(int)
    -> decltype( std::array<std::false_type, sizeof...(Us)>
                 {{std::is_same<T1, Us>{}...}} )
    {  return {}; /* only to suppress warning */  }
    template<class...>
    static constexpr int SFINAE(...) { return 42; }
    template<class T1>
    static constexpr bool test()
    {
        return std::is_same<decltype(SFINAE<T1>(0)), int>{};
    }
    static constexpr bool value = test<T>();
    constexpr operator bool() const { return value; }
};

实施are_unique：

namespace detail
{
    // `Any` type with a generic no-constraint ctor
    // to discard a number of arguments for a function template
    template<std::size_t>
    struct Any
    {
        template<class T>
        constexpr Any(T&&) {}
    };
    // `wrapper` is used as a substitute for `declval`,
    // and can keep track if `T` is a reference
    template<class T>
    struct wrapper { using type = T; };
    template<std::size_t I, class T, class... Us>
    struct is_one_of_pack
    {
        template<std::size_t... I1s>
        struct helper
        {
            template<class... Remaining>
            static constexpr bool deduce_remaining(Any<I1s>..., Remaining...)
            {
                // unique <-> is one of
                return not is_one_of<T, typename Remaining::type...>{};
            }
        };
        template<std::size_t... I1s>
        static constexpr bool deduce_seq(seq<I1s...>)
        {
            return helper<I1s...>::template deduce_remaining(wrapper<Us>()...);
        }
        static constexpr bool create_seq()
        {
            return deduce_seq(gen_seq<I+1>{});
        }
        using type = std::integral_constant<bool, create_seq()>;
    };
    template<class... Packs>
    constexpr auto SFINAE(int)
    -> decltype( std::array<std::true_type, sizeof...(Packs)>
                 {{typename Packs::type{}...}} )
    {  return {}; /* only to suppress warning */  }
    template<class...>
    static constexpr int SFINAE(...) { return 42; }
    template<class... Packs>
    constexpr bool test()
    {
        return std::is_same<decltype(SFINAE<Packs...>(0)), int>{};
    }
    template<class... Ts, std::size_t... Is>
    constexpr bool deduce_seq(seq<Is...>)
    {
        return test< is_one_of_pack<Is, Ts, Ts...>... >();
    }
}
template<class... Ts>
struct are_unique
: std::integral_constant<bool,
                         detail::deduce_seq<Ts...>(gen_seq<sizeof...(Ts)>{})>
{};

使用示例：

#include <iostream>
#include <iomanip>
int main()
{
    bool a = are_unique<bool, char, int>();
    bool b = are_unique<bool, char, int, bool>();
    bool c = are_unique<bool, char, bool, int>();
    std::cout << std::boolalpha;
    std::cout << a << std::endl;
    std::cout << b << std::endl;
    std::cout << c << std::endl;
}

template<typename ... _Types>
class unique_types;
template<typename _T1, typename _T2, typename ... _Tail>
class unique_types<_T1,_T2,_Tail...> :
    virtual public unique_types<_T1, _T2>
    , virtual public unique_types<_T1, _Tail ...>
    , virtual public unique_types<_T2, _Tail ...>
{
protected:
    using check_current = unique_types<_T1, _T2>;
    using check_first = unique_types<_T1, _Tail ...>;
    using check_second = unique_types<_T2, _Tail ...>;
public:
    constexpr static const bool value = check_current::value && check_first::value && check_second::value;
};
template<typename _T1, typename _T2>
class unique_types<_T1, _T2, _T2>
{
public:
    constexpr static const bool value = false;
};
template<typename _T1, typename ... _Tail>
class unique_types<_T1, _T1, _Tail ...>
{
public:
    constexpr static const bool value = false;
};
template<typename _T1, typename _T2>
class unique_types<_T1, _T2, _T1>
{
public:
    constexpr static const bool value = false;
};
template<typename _T1, typename _T2>
class unique_types<_T1,_T2>
{
public:
    constexpr static const bool value = true;
};
template<typename _T1>
class unique_types<_T1,_T1>
{
public:
    constexpr static const bool value = false;
};
template<typename _T1>
class unique_types<_T1>
{
public:
    constexpr static const bool value = true;
};
class A
{
public:
    A() = default;
};

inline void test()
{
    const bool unique = unique_types<int, short, float, A>::value;
    assert(unique == true);
    const bool unique2 = unique_types<int, A, short, float, A>::value;
    assert(unique2 == false);
    const bool unique3 = unique_types<A, int, short, float, A>::value;
    assert(unique3 == false);
    const bool unique4 = unique_types<int, short, A, float, A>::value;
    assert(unique4 == false);
    const bool unique5 = unique_types<int, short, float, A, A>::value;
    assert(unique5 == false);
    const bool unique6 = unique_types<int>::value;
    assert(unique6 == true);
    const bool unique7 = unique_types<int, int>::value;
    assert(unique7 == false);
    const bool unique8 = unique_types<int, int, char>::value;
    assert(unique8 == false);
    const bool unique9 = unique_types<int, char, int>::value;
    assert(unique9 == false);
    const bool unique10 = unique_types<char, int, int>::value;
    assert(unique10 == false);
    const bool unique11 = unique_types<int, int, A, char>::value;
    assert(unique11 == false);
    const bool unique12 = unique_types<int, A, char, int>::value;
    assert(unique12 == false);
    const bool unique13 = unique_types<A, char, int, int>::value;
    assert(unique13 == false);
}