Me preguntaba si podría tener paquetes de parámetros que consistan en un solo tipo explícitamente especificado. Por ejemplo, algo como esto:

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

El problema que tengo es con la definición defoo(). Con OS X clang ++ versión 5 (llvm 3.3svn) me sale el errorerror: type 'int' of function parameter pack does not contain any unexpanded parameter packs.

Por supuesto, puedo hacerlo compilar cambiando afoo() en una plantilla de función:

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

Sin embargo ahorafoo() Va a aceptarint para el primer parámetro, y todo lo que se pueda transmitir por el resto. Por ejemplo:

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

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

Ahora he vistola solucion aceptada aqui lo que sugiere el uso de rasgos de tipo ystd::enable_if, pero eso es engorroso. También sugirieron usarstd::array pero creo que una simplestd::initializer_list Funciona bien y se ve más limpio, así:

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' :)
}

Así que eso es genial. Pero la pregunta sigue siendo, ¿es esto necesario? ¿Realmente no hay una manera de definir una función sin plantilla que acepte un paquete de parámetros de un tipo específico? Me gusta esto:

void foo(int... args) { }