参数包后的字符串参数

Question

I want to write a function write that can take multiple arguments of any type, and print them to stdout . But I also want to pass in a delimiter as the last argument as well.

template <typename... T>
void write(T &&...args, string delimiter) { // compilation error
    ((cout << args << delimiter),...);
}

Usage:

write(1, ""); // single element with empty delimeter
write(1, "one", " "); // space as delimeter
write(1, "one", ","); // comma as delimeter 

Right now, automatic type deduction fails since C++ expects parameter packs to be the last argument.

How can I achieve this?

Answer 1

There's a nice technique in this blog article which you can use.

Modify write to only accept a parameter pack

template <typename... Ts>
void write(Ts && ...args) 
{ 
    write_indirect(std::forward_as_tuple(args...),
                   std::make_index_sequence<sizeof...(args) - 1>{});
}

Now write_indirect simply takes the parameter pack as a tuple, along with the indices of the arguments as template parameters. Then it extracts the last parameter using get , and passes that as the first parameter to write_impl . The remaining parameters are unpacked from the tuple, and passed as the second argument

template<typename... Ts, size_t... Is>
void write_indirect(std::tuple<Ts...> args, std::index_sequence<Is...>)
{
    auto constexpr Last = sizeof...(Ts) - 1;
    write_impl(std::get<Last>(args), std::get<Is>(args)...);
}  

Now write_impl is just your original write function but it takes the delimiter as the first argument

template <typename... Ts>
void write_impl(std::string delimiter, Ts && ...args) 
{   
    ((std::cout << args << delimiter),...);
}

Here's a demo