Variadische Template-Funktion mit dem gleichen Argumente Typ

Question

Ich mag würde, wie so eine Template-Funktion schreiben:

template <typename T> 
void f(const T & ...args) // <-- This doesn't work, unfortunately. 
{ 
    std::array<T> arr = { args... }; 
    // and so forth. 
} 

Offenbar C++ erlaubt es nicht, dass, weil es ein Template-Parameter Pack auf dem linken sein muss Seite von ...args für das zu arbeiten. Was ich will, ist eine Template-Funktion, bei der alle Argumenttypen gleich sind. Gibt es einen einfachen Weg, das zu tun?

Answer 1

template <typename ... T> 
    void f(const T & ... args) 
    { 
     std::array<typename std::common_type<T...>::type, 
        sizeof...(T)> arr = {args...}; 
    } 

oder von std::experimental

template <typename ... T> 
    void f(const T & ... args) 
    { 
     auto arr = std::experimental::make_array<void>(args...); 
    } 

Die Leere macht der Rückgabetyp der common_type der Eingangsparameter sein, sonst können Sie angeben, welche Art Sie ausdrücklich wollen, wenn Sie es wissen.

Answer 2

Ich würde eine weitere Lösung zu den bereits vorgeschlagenen hinzufügen.
Sie können dazu auch eine initializer_list verwenden.
Es folgt ein Arbeitsbeispiel:

#include<initializer_list> 
#include<vector> 
#include<string> 

template<class T> 
void fn(std::initializer_list<T> l) { 
    std::vector<T> v(l); 
    // so on 
} 

int main() { 
    fn<std::string>({ "foo", " bar" }); 
    return 0; 
} 

Answer 3

#include <tuple> 
#include <type_traits> 

template <typename T, typename... Ts> 
auto f(const T& t, const Ts&... ts) 
    -> typename std::enable_if<std::is_same<std::tuple<T, Ts...> 
              , std::tuple<Ts..., T> 
           >::value>::type 
{ 
} 

DEMO