Eu queria saber se eu poderia ter pacotes de parâmetro consistindo de um único tipo explicitamente especificado. Por exemplo, algo como isto:

#include <iostream>

using namespace std;

void show() { }

template<typename First, typename... Rest>
void show(First f, Rest... rest)
{
    cout << f << endl;
    show(rest...);
}

void foo(int f, int... args) // error
{
    show(f, args...);
}

int main()
{
    foo(1, 2, 3);
}

O problema que estou tendo é com a definição defoo(). Com OS X clang ++ versão 5 (llvm 3.3svn) recebo o erroerror: type 'int' of function parameter pack does not contain any unexpanded parameter packs.

Claro, eu posso conseguir compilar mudando parafoo() em um modelo de função:

template<typename... Args>
void foo(int f, Args... args)
{
    show(f, args...);
}

No entanto agorafoo() vai aceitarint para o primeiro parâmetro e qualquer saída gerada para o resto. Por exemplo:

struct x { };
ostream& operator<<(ostream& o, x)
{
    o << "x";
    return o;
}

int main()
{
    foo(1, 2, x(), 3); // compiles :(
}

Agora eu via solução aceita aqui que sugere o uso de características de tipo estd::enable_if, mas isso é complicado. Eles também sugeriram usarstd::array mas acho que um simplesstd::initializer_list funciona muito bem e parece mais limpo, assim:

void foo_impl(initializer_list<int> ints)
{
    for(int i: ints)
        cout << i << endl;
}

template<typename... Args>
void foo(int f, Args... args)
{
    foo_impl({f, args...});
}

struct x { };
ostream& operator<<(ostream& o, x)
{
    o << "x";
    return o;
}

int main()
{
    foo(1, 2, 3);
    foo(1, 2, x(), 3); // no longer compiles
                       // we also get an error saying no known conversion from 'x' to 'int' :)
}

Então isso é legal. Mas a questão permanece, isso é necessário? Existe realmente não uma maneira de definir uma função não-modelo que aceita um pacote de parâmetros de tipo específico? Como isso:

void foo(int... args) { }