rekursywny szablon variadic do wydrukowania zawartości pakietu parametrów

Question

Jak można utworzyć rekursywny szablon variadic do wydrukowania zawartości pakietu paramater? Staram się z tym, ale nie udaje mu się skompilować:

template <typename First, typename ...Args> 
std::string type_name() { 
    return std::string(typeid(First).name()) + " " + type_name<Args...>(); 
} 
std::string type_name() { 
    return ""; 
} 

Jak mam zakończyć rekursji?

Answer 1

Musisz użyć częściowej specjalizacji, aby zakończyć rekursję, ale ponieważ nie możesz częściowo specjalizować bezpłatnych funkcji w C++, musisz utworzyć klasę implementacji z funkcją statycznego elementu.

template <typename... Args> 
struct Impl; 

template <typename First, typename... Args> 
struct Impl<First, Args...> 
{ 
    static std::string name() 
    { 
    return std::string(typeid(First).name()) + " " + Impl<Args...>::name(); 
    } 
}; 

template <> 
struct Impl<> 
{ 
    static std::string name() 
    { 
    return ""; 
    } 
}; 

template <typename... Args> 
std::string type_name() 
{ 
    return Impl<Args...>::name(); 
} 

int main() 
{ 
    std::cout << type_name<int, bool, char, double>() << std::endl; // "i b c d" 
    return 0; 
} 

To pierwsza deklaracja Impl tylko a workaround for a shortcoming in g++ 4.6 (i poniżej). Nie będzie to konieczne po prawidłowym wdrożeniu szablonów variadycznych.

Check it out in action at ideone.com

Answer 2

Jako alternatywę dla nieistniejącego częściowej specjalizacji dla funkcji, można użyć przeciążenie w klasie typifier:

#include <string> 
#include <iostream> 
#include <typeinfo> 

template <unsigned int N> struct NumberToType { }; 

template <typename T> 
std::string my_type_name(NumberToType<0> = NumberToType<0>()) 
{ 
    return std::string(typeid(T).name()); 
} 

template <typename T, typename ...Args> 
std::string my_type_name(NumberToType<sizeof...(Args)> = NumberToType<sizeof...(Args)>()) 
{ 
    return std::string(typeid(T).name()) + " " + my_type_name<Args...>(NumberToType<sizeof...(Args)-1>()); 
} 

int main() 
{ 
    std::cout << my_type_name<int, double, char>() << std::endl; 
} 

Answer 3

Jest rzeczywiście bardzo elegancki sposób na zakończenie rekurencji:

template <typename Last> 
std::string type_name() { 
    return std::string(typeid(Last).name()); 
} 

template <typename First, typename Second, typename ...Rest> 
std::string type_name() { 
    return std::string(typeid(First).name()) + " " + type_name<Second, Rest...>(); 
} 

Początkowo wypróbowałem template <typename Last> i template <typename First, typename ...Rest>, ale uznano to za niejednoznaczne (można odpocząć zero elementów). To pytanie następnie pokazał mi ostateczne rozwiązanie: Compilation Error on Recursive Variadic Template Function

---

Uwaga, aby uniknąć kawałek kodu powielania, można również zrobić:

template <typename Last> 
std::string type_name() { 
    return std::string(typeid(Last).name()); 
} 

template <typename First, typename Second, typename ...Rest> 
std::string type_name() { 
    return type_name<First>() + " " + type_name<Second, Rest...>(); 
} 

Answer 4

Jako alternatywę można rozpakować pakiet parametru w -place jak w poniższym przykładzie:

#include<string> 
#include<iostream> 
#include<typeinfo> 

template <typename T, typename ...Args> 
std::string type_name() { 
    std::string str = typeid(T).name(); 
    int arr[] = { 0, (str += std::string{" "} + typeid(Args).name(), 0)... }; 
    (void)arr; 
    return str; 
} 

int main() { 
    auto str = type_name<int, double, char>(); 
    std::cout << str << std::endl; 
} 

Rekursja nie jest wymagana do tego.