Deklarowanie funkcji z typów argumentów zaczerpniętych z pakietem parametrów zagranicznych

Question

Załóżmy, że mam jakieś listy typów

template<typename... Types> struct TypeList {}; 

Teraz w innej klasie mogę wygenerować taki TypeList w różny sposób.

template<class T> struct MyClass { 
    using MyList = TypeList<T, typename Something<T>::type, SomethingElse>; 
    // ... 
}; 

Jak mogę zadeklarować metodę z typami argumentów wyodrębnionych z listy tego typu? Na przykład, jeśli ustawię wartość MyList = TypeList<int, float, const char*>, chcę zadeklarować deklarację metody.

Answer 1

Można czerpać z klasy bazowej, która implementuje metodę:

template <typename> struct MethodProvider; 

template <typename ...Args> 
struct MethodProvider<TypeList<Args...>> 
{ 
    void my_method(Args ...args); 
}; 

template <typename T> 
struct MyClassAux 
{ 
    using MyList = TypeList<T, typename Something<T>::type, SomethingElse>; 
}; 

template <typename T> 
struct MyClass 
    : private MyClassAux<T> 
    , private MethodProvider<typename MyClassAux<T>::MyList> 
{ 
    using typename MyClassAux<T>::MyList; 
    using MethodProvider<typename MyClassAux<T>::MyList>::my_method; 

    // ... 
}; 

Answer 2

Można użyć static_assert i std::is_same do przymusu argumenty my_method

#include <iostream> 
#include <string> 
#include <vector> 
#include <type_traits> 

template<typename... Types> struct TypeList {}; 

template<class T> struct MyClass { 
    using MyList = TypeList<int, T>; 

    template<typename ...Args> 
    void my_method(Args ...args) { 
     static_assert(std::is_same<MyList, TypeList<Args...>>::value, "invalid arguments"); 
     auto dummy = {(std::cout << args << "\n", 0)...}; 
     (void)(dummy); // avoid variable warning 
    } 
}; 

int main() 
{ 
    MyClass<float> c; 
    c.my_method(1, 2.3f); 
// c.my_method(1, ""); // unmatched arguments won't compile 
// c.my_method(1); 
} 

Online Demo