c ++函数模板专业化

Question

I'm trying to write a function that accepts a variable number of arguments of variable types. The types will always be POD except for one case where there will be a List of POD. I have acheived this with paramter pack expansion and recursive template function calls.

The function is currently working for all overrides of POD with template specialization, but I want to create a template specialization for the List but keep the list templated. I understand that this may be impossible as this is effectively partial specialization at the function level. I am wondering about workarounds for this kind of a scenario.

Here is what I'm doing.

template<typename T, typename ...TArgs> 
void Params2(T value, TArgs... args) {
        Params2(value);
        Params2(args...);
}
template<typename T>
inline void Params2(T c) { //invalid msg }

template <> inline void Params2<unsigned char>(unsigned char c) { //do something with char }
template <> inline void Params2<char>(char c) { //do something with uchar }
template <> inline void Params2<unsigned short>(unsigned short c) { //do something with short }
template <> inline void Params2<short>(short c) { //do something with ushort }

// more POD overrides 

If I do the following, it works because I have fully defined the type of the list:

template <>  
inline void Params2< libfc::List<int> >(libfc::List<int> l) 
{ 
    for (auto itt = l.Begin(); itt != l.End(); ++itt) 
    { 
        //do something with each int
    } 
}

what I want to be able to do is:

template <>
template <typename R>
inline void Params2<libfc::List<R> >(libfc::List<R>) { 
    //do something with for each element of type R
}

I'd prefer not to make an override for each type of List that the function can take, but I can accept that if there is no better option.

edit: The calling application would invoke this functionality along the lines of (not valid code, just example):

Params2(10, 25, "test", List<int> { 5, 10 }, List<double> { 3.14, 9.81 } );

Answer 1

Use overload instead of specialization

inline void Params2(unsigned char c) { //do something with char }
inline void Params2(char c) { //do something with uchar }
inline void Params2(unsigned short c) { //do something with short }
inline void Params2(short c) { //do something with ushort }

template<typename T> 
void Params2(const std::list<T>& value) {
// list
}


template<typename T, typename ...TArgs> 
void Params2(T value, TArgs... args) {
        Params2(value);
        Params2(args...);
}

or use generic method and class specialization

template<typename T> 
struct helper;

template<> 
struct helper<unsigned char> { void operator () (unsigned char c) { /**/}};
template<> 
struct helper<char> { void operator () (char c) { /**/}};
template<typename T> 
struct helper<std::list<T>> { void operator () (const std::list<T>& l) { /**/}};

template<typename T> 
void Params2(const T& t) {
    helper<T>{}(t);
}

Answer 2

Using std::enable_if() , you can make templates that will take a mix of primitive data and "lists" of primitive data. The trick here is that anything that has a const_iterator type and a begin() method that returns a type convertible to that type will be treated as a list, and everything else will be get routed to the appropriate overloads.

void foo(const int& t) { std::cout << "int: " << t << std::endl; }
void foo(const double& t) { std::cout << "double: " << t << std::endl; }

template<typename T,
         typename std::enable_if<
             std::is_convertible<
                 decltype(std::declval<const T&>().begin()),
                 typename T::const_iterator
             >::value
         >::type* = nullptr>
void foo(const T& t) {
    auto begin = t.begin();
    for(;begin != t.end(); ++begin) {
        foo(*begin);
    }
}

template<typename T,
         typename... TArgs>
void foo(const T& first, TArgs... args) {
    foo(first);
    foo(args...);
}

int main() {
    std::list<int> asdf{3, 4, 5};
    std::vector<double> vec{7, 8, 9};
    foo(1, 2.0, asdf, 6, vec);
}

Output:

int: 1
double: 2
int: 3
int: 4
int: 5
int: 6
double: 7
double: 8
double: 9