modello variadic ricorsivo per stampare il contenuto di un pacchetto di parametri

Question

Come è possibile creare un modello variadic ricorsivo per stampare il contenuto di un pacchetto di parametri? sto cercando con questo, ma non riesce a compilare:

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

Come devo terminare la ricorsione?

Answer 1

È necessario utilizzare la specializzazione parziale per terminare la ricorsione, ma poiché non è possibile specializzare parzialmente le funzioni libere in C++, è necessario creare una classe di implementazione con una funzione membro statica.

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; 
} 

Quella prima dichiarazione di Impl è solo a workaround for a shortcoming in g++ 4.6 (e sotto). Non sarà necessario una volta implementato correttamente i modelli variadici.

Check it out in action at ideone.com

Answer 2

In alternativa alla specializzazione parziale inesistente per le funzioni, è possibile utilizzare un sovraccarico su una classe 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

In realtà c'è un modo molto elegante per terminare la ricorsione:

Inizialmente ho provato template <typename Last> e template <typename First, typename ...Rest> ma quello era considerato ambiguo (Il resto può essere zero elementi). Questa domanda poi mi ha mostrato la soluzione definitiva: Compilation Error on Recursive Variadic Template Function

---

nota, al fine di evitare un po 'di duplicazione del codice, si potrebbe anche fare:

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

In alternativa, è possibile decomprimere il parametro pacchetto in -place come nell'esempio seguente:

#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; 
} 

La ricorsione non è richiesta per farlo.