具有相等参数类型的可变参数模板函数

Question

I would like to write a template function like so:

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

Apparently, C++ does not allow that, because there needs to be a template parameter pack on the left-hand side of ...args for this to work. What I want is a template function where all argument types are the same. Is there an easy way to do that?

Answer 1

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

or from std::experimental

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

The void makes the return type be the common_type of the input parameters, else you can specify what type you want explicitly if you know it.

Answer 2

#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

Answer 3

I'd add one more solution to the ones already proposed.
You can also use an initializer_list to do that.
It follows a working example:

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