Variadic template expansion

Here are some other ways to solve this problem, although they are not the only ones:

template overload

By default the variadic version of the template will be called and the non- varidic version will only be called when there is only one element left to print.

The variadic version , being called whenever there are 2 or more elements, can safely assume that it must insert a separator after the first element.

template<typename T>
void print(T item)
{
  std::cout << item;
}

template<typename T, typename... Args>
void print(T item, Args... args)
{
  print(item);
  std::cout << ',';
  print(args...);
}

Using lambdas (v1)

A stateful lambda is ideal for controlling separator printing.

When exploiting the arguments, numerous calls to the lambda will be made, which will print a separator in each of them except the first.

template <typename... Args>
void print(Args... args)
{
    auto separador = [primero = true](auto param) mutable
    {
      if( !primero ) std::cout << ',';
      primero = false;
      return param;
    };

    ((std::cout << separador(args)), ...);
}

Using lambdas (v2)

Identical to the previous version, it only changes the declaration of the boolean variable, which becomes a property of the template to avoid a warning at compile time.

template <typename... Args>
void print(Args... args)
{
    bool primero = true;
    auto separador = [&](auto param)
    {
      if( !primero ) std::cout << ',';
      primero = false;
      return param;
    };

    ((std::cout << separador(args)), ...);
}

Using if constexpr

Since the compiler already knows the exact number of arguments that the function receives, we can make use of if constexprso that a recursive call is made only while there is more than one element to print. This code could be understood as an improvement of the first example.

template <typename Item, typename... Args>
void print(Item item, Args... args)
{
    std::cout << item;
    if constexpr( sizeof...(args) > 0 )
    {
      std::cout << ',';
      print(args...);
    }
}

I had an answer on point just before the edit where you make it clear that the expected output is 1,2,3,...,Nand not 1,2,3,...,N,as I originally thought. For the first case it can be valid simply:

#include <iostream>

template<typename... Args>
void print(Args... args)
{
    ((std::cout << args << ','), ...);
}

By not wanting the comma after the last element, things get complicated...

I don't know if it will be the best option, but it can be proposed in the following way, modifying my initial idea:

#include <iostream>

template<typename Arg, typename... Args>
void print(Arg first, Args... args)
{
    std::cout << first;
    if (sizeof...(args) != 0)
        ((std::cout << ',' << args), ...);
}

int main()
{
    print(1);
    std::cout << '\n';
    print(1,2,3,4,5);
    std::cout << '\n';
    print("ab","c",3,4,"de");
    return 0;
}

We print the first argument and then use a conditional to see if there is an argument argsto unpack into or not.

Departure:

1
1,2,3,4,5ab
,c,3,4,de

Test online at Ideone

I think you can expand the sequence that receives the template to another function to which you pass the args

#include <iostream>
using namespace std;

int print_test(int i)
{
    std::cout << ',' << i << '\n';
    return 0;
}

template <typename... Args>
void print(Args... args)
{

    using  expandir = int[]; 
    (void) expandir {0, ((void)print_test(args), 0)...};

    (std::cout << ... << args) << '\n'; // se deja para contrastar

}

int main() {
    // your code goes here
    print(1,2,3,4,5);
    return 0;
}

TestIdeone

The explanation of "Expansion Pack" packages, as I understand it, can only be expanded in contexts of expansion of the same "if perhaps it is a bit confusing, I am sorry I cannot explain myself better" to quote some Braced initialization or this one on which the initializations example is based of array.

info some info:

• http://en.cppreference.com/w/cpp/language/fold

but it shows how you are using it, I don't know if that part will be useful for you, but in the package definitions "pack" "init" maybe it will help you.

Update:

I think this works as you want.

template <typename... Args>
void print(Args... args)
{
    int chapuza = 0;
    const int n = sizeof...(args);

    using  expandir = int[]; 
    (void) expandir {0, ((void)print_test(args), chapuza++, chapuza == n ? std::cout << '\n' : std::cout << ','  << '\n', 0)...};

}

TestIdeone

After your update if it is without the line break use:

//..
(void) expandir {0, ((void)print_test(args), chapuza++, chapuza == n ? std::cout << '\n' : std::cout << ',', 0)...};
//..

changing std::cout << ',' << '\n'bystd::cout << ','

Continuing with the previous approach, it could be simplified as follows and dispensing with theprint_test

    using  expandir = int[]; 
    (void) expandir {0, (chapuza++, chapuza == n ? std::cout << args << '\n' : 
                                                   std::cout << args<< ',', 0)...};

TestIdeone

Note: maybe it's a botch and maybe there is a better way, but I was curious after your comment, and this is what came out, I hope it helps you.