ตรวจสอบให้แน่ใจว่าเทมเพลต variadic ไม่มีรายการที่ซ้ำกัน

สิ่งนี้สามารถเขียนได้โดยใช้เมตาฟังก์ชันสองตัว

ขั้นแรก IsContained ตรวจสอบว่าประเภทปรากฏในรายการประเภทหรือไม่

template <typename T, typename... List>
struct IsContained;

template <typename T, typename Head, typename... Tail>
struct IsContained<T, Head, Tail...>
{
    enum { value = std::is_same<T, Head>::value || IsContained<T, Tail...>::value };
};

template <typename T>
struct IsContained<T>
{
    enum { value = false };
};

ประการที่สอง IsUnique ตรวจสอบว่ารายการประเภทไม่มีรายการซ้ำหรือไม่ ใช้ IsContained เพื่อตรวจสอบการรวมองค์ประกอบทั้งหมด

template <typename... List>
struct IsUnique;

template <typename Head, typename... Tail>
struct IsUnique<Head, Tail...>
{
    enum { value = !IsContained<Head, Tail...>::value && IsUnique<Tail...>::value };
};

template <>
struct IsUnique<>
{
    enum { value = true };
};

ด้วยเครื่องมือเหล่านี้ การยืนยันแบบคงที่จึงง่ายมาก:

template <typename... Ts>
struct NoDuplicates
{
    static_assert(IsUnique<Ts...>::value, "No duplicate types allowed");
};

หากคุณมีสิทธิ์เข้าถึงนิพจน์การพับ C++1z คุณสามารถทำให้คำตอบของ @TheOperator ง่ายขึ้นได้โดยทำสิ่งต่อไปนี้สำหรับ IsContained:

template <typename T, typename... List>
struct IsContained;

template <typename T, typename Head, typename... Tail>
struct IsContained<T, Head, Tail...>
{
    enum { value = std::is_same<T, Head>::value || (IsContained<T, Tail>::value && ... && true) };
};

template <typename T>
struct IsContained<T>
{
    enum { value = false };
};

ข้อแตกต่างก็คือด้วยนิพจน์การพับมีโอกาสมากขึ้นที่จะนำคลาสอินสแตนซ์กลับมาใช้ใหม่ หากคุณใช้พารามิเตอร์จำนวนมากหรือมีการเปรียบเทียบซ้ำหลายครั้ง อาจ นี้จะมีเวลาในการคอมไพล์ที่เร็วขึ้น เช่นเคย ให้ทดสอบด้วยตัวเอง

ด้วย c++17 มันค่อนข้างง่าย

#include <type_traits>

template <typename T, typename... Ts>
struct are_distinct: std::conjunction<
    std::negation<std::is_same<T, Ts>>...,
    are_distinct<Ts...>
>{};

template <typename T>
struct are_distinct<T>: std::true_type{};

อัลกอริทึมเหมือนกับที่แสดงโดย Jkor และ ผู้ดำเนินการ แต่แสดงได้กระชับกว่ามาก

จากนั้น เมื่อมาถึงคำถามเฉพาะของคุณ คุณจะใช้มันในลักษณะนี้:

template<typename ...Types> 
struct MyVariadicTemplate {
    static_assert(are_distinct<Types...>::value, "Types must be distinct");

    /* rest of the code */
};

อย่างไรก็ตาม เนื่องจากนี่คือ O(n²) ฉันสงสัยว่ามีวิธีทำให้อัลกอริทึมซับซ้อนน้อยลงหรือไม่ เอกลักษณ์ของ Boost::mpl ‹› คือ O( n) แต่ฉันไม่สามารถเข้าใจอัลโกที่ใช้ได้