Expansión del paquete de plantillas variables

Estoy tratando de aprender plantillas y funciones variadas. No puedo entender por qué este código no se comstack:

template static void bar(T t) {} template static void foo2(Args... args) { (bar(args)...); } int main() { foo2(1, 2, 3, "3"); return 0; } 

Cuando compilo falla con el error:

Error C3520: ‘args’: el paquete de parámetros debe expandirse en este contexto

(en la función foo2 ).

Uno de los lugares donde puede producirse la expansión de un paquete está dentro de una lista inicial arrinconada . Puede aprovechar esto colocando la expansión dentro de la lista de inicialización de una matriz ficticia:

 template static void foo2(Args &&... args) { int dummy[] = { 0, ( (void) bar(std::forward(args)), 0) ... }; } 

Para explicar el contenido del inicializador con más detalle:

 { 0, ( (void) bar(std::forward(args)), 0) ... }; | | | | | | | | | --- pack expand the whole thing | | | | | | --perfect forwarding --- comma operator | | | -- cast to void to ensure that regardless of bar()'s return type | the built-in comma operator is used rather than an overloaded one | ---ensure that the array has at least one element so that we don't try to make an illegal 0-length array when args is empty 

Demo

Una ventaja importante de la expansión en {} es que garantiza la evaluación de izquierda a derecha.


Con las expresiones C ++ 1z fold , puedes escribir

 ((void) bar(std::forward(args)), ...); 

Los paquetes de parámetros solo se pueden expandir en una lista de contextos estrictamente definida, y el operador , no es uno de ellos. En otras palabras, no es posible usar la expansión del paquete para generar una expresión que consiste en una serie de subexpresiones delimitadas por el operador,.

La regla de oro es “Expansión puede generar una lista de patrones separados, donde , es un delimitador de lista “. Operador , no construye una lista en el sentido gtwigtical.

Para llamar a una función para cada argumento, puede usar recursión (que es la herramienta principal en el cuadro del progtwigdor de plantillas variadic):

 template  void bar(T t) {} void foo2() {} template  void foo2(Car car, Cdr... cdr) { bar(car); foo2(cdr...); } int main() { foo2 (1, 2, 3, "3"); } 

Ejemplo en vivo

SHAMELESS COPY [aprobado por su fuente]

Los paquetes de parámetros solo se pueden expandir en una lista de contextos estrictamente definida, y el operador , no es uno de ellos. En otras palabras, no es posible usar la expansión del paquete para generar una expresión que consiste en una serie de subexpresiones delimitadas por el operador,.

La regla de oro es “Expansión puede generar una lista de patrones separados, donde , es un delimitador de lista”. Operador , no construye una lista en el sentido gtwigtical.

Para llamar a una función para cada argumento, puede usar recursión (que es la herramienta principal en el cuadro del progtwigdor de plantillas variadic):

 #include  template void foo(T &&t){} template void foo(Arg0 &&arg0, Arg1 &&arg1, Args &&... args){ foo(std::forward(arg0)); foo(std::forward(arg1), std::forward(args)...); } auto main() -> int{ foo(1, 2, 3, "3"); } 

INFORMACIÓN ÚTIL NO COPIADA

Otra cosa que probablemente no haya visto en esta respuesta es el uso del especificador && y std::forward . En C ++, el especificador && puede significar una de dos cosas: referencias-rvalue, o referencias universales.

No entraré en referencias rvalue, sino a alguien que trabaje con plantillas variadas; las referencias universales son un envío de Dios.

Reenvío perfecto

Uno de los usos de las referencias std::forward y universal es el reenvío perfecto de tipos a otras funciones.

En su ejemplo, si pasamos un int& a foo2 , se degradará automáticamente a int debido a la firma de la función foo2 generada después de la deducción de la plantilla y si usted desea entonces reenviar este arg a otra función que lo modificaría a su referencia, usted obtendrá resultados no deseados (la variable no se cambiará) porque foo2 pasará una referencia al temporal creado pasandole un int . Para evitar esto, especificamos una función de reenvío para tomar cualquier tipo de referencia a una variable (rvalue o lvalue). Luego, para estar seguros de que pasamos el tipo exacto pasado en la función de reenvío, usamos std::forward , entonces y solo entonces permitimos la degradación de los tipos; porque ahora estamos en el punto donde más importa.

Si es necesario, lea más sobre referencias universales y reenvío perfecto ; scott meyers es bastante bueno como recurso.

Puede usar make_tuple para la expansión del paquete ya que introduce un contexto donde la secuencia producida por una expansión es válida

 make_tuple( (bar(std::forward(args)), 0)... ); 

Ahora, sospecho que la tupla de ceros no utilizada / sin nombre / temporal que se produce es detectable por el comstackdor y optimizada

Manifestación

¡La orden de ejecución no está garantizada para esto!

 make_tuple( (bar(std::forward(args)), 0)... ); 

En este ejemplo, los parámetros se imprimirán en orden inverso al menos con GCC.

 foo2(1, 2, 3, "3"); calling bar for 3 calling bar for 3 calling bar for 2 calling bar for 1