Llamada a función con parámetros variables en C++

Question

Tengo una duda sobre como llamar a una función con parámetros variables dentro de otra.

Suena un poco complicado así que pongo un ejemplo:

void MyClass::function1(int ult, ...)
{
    va_list args;
    va_start(args, ult);
    int a = va_arg(args, int); 
    // operaciones con a, un argumento de tipo entero, por poner un ejemplo
    va_end(args);
}

void MyClass::function2(int ult, ...)
{
    //¿como pasar los parámetro (...) a function1?
    function1(ult);
}

Justo en function2 quiero llamar a function1 pasándole los argumentos variables que me pasen en function2.

Answer 1

Puedes usar variadic templates

#include <iostream>
#include <type_traits> // std::is_same

struct MyClass2 {
  // Declaración genérica de la plantilla. Esta versión no tiene implementación
  template<class ... Args>
  void function1(Args...);

  template<class T, class ... Args>
  void function1(T t, Args ... args) {
    if( std::is_same<T,int>::value )
      std::cout << "entero: " << t << '\n';
    else if( std::is_same<T,double>::value )
      std::cout << "double: " << t << '\n';
    else
      std::cout << t << '\n';

    if( sizeof...(Args) > 0 )
      function1(args...);
  }

  template<class ... Args>
  void function2(Args ... args ) {
    function1(args...);
  }
};

int main( ) {
  MyClass mc;

  mc.function2( 5, 6, 7 );
  mc.function2( 55.66 );

  return 0;
}

La ventaja de esta solución es que el tipado siempre será fuerte. Además ya no hay que indicar cuántos parámetros vas a pasar lo cual es una ventaja ya que ese valor es totalmente redundante y propenso a errores.

Answer 2

Tal y como te indican en los comentarios, es simple: basta con declarar otra función

MyClass::functionX( int, va_list args );

y llamarla desde tu código:

#include <cstdarg>
#include <iostream>

struct MyClass {
  void function1( int ult, va_list args ) {
    if( !ult ) {
      double db = va_arg( args, double );
      std::cout << "double: " << db << '\n';
    } else {
      for( int idx = 0; idx < ult; ++idx ) {
        int a = va_arg( args, int ); 
        std::cout << "entero: " << a << '\n';
      }
    }
  }

  void function2( int ult, ... ) {
    va_list args;
    va_start( args, ult );
    function1( ult, args );
    va_end( args );
  }
};

int main( ) {
  MyClass mc;

  mc.function2( 3, 5, 6, 7 );
  mc.function2( 0, 55.66 );

  return 0;
}

_{Basado en esta respuesta de SO}

Observa que no es necesario llamar a va_start( ) ni a va_end( ) desde tu función anidada; la pila se limpia correctamente en la llamada a va_end( ) desde la función de 1er nivel.

_{Nota: para mi sorpresa, funciona bien en funciones-miembro de clases. Creí que this daría algún problema ... pero no ha sido así, funciona perfecto :-O}

Answer 3

La elipsis (...) es el mecanismo de C++ para redactar funciones con argumentos variádicos , existen dos formas (muy diferentes) de trabajar con la elipsis:

C++ tradicional (previo al estándar C++11).

No voy a entrar en detalles de esta manera de trabajar con la elipsis porque sus desventajas:

• Sintaxis confusa ¡apoyada en macros!.
• Propenso a errores: si las macros no se escriben en el orden y de la manera adecuada, el código falla en tiempo de ejecución de maneras impredecibles.
• Vulnerable: un código que use mal la elipsis tradicional puede facilitar el hackeo del sistema.
• Sin seguridad de tipos: los tipos pasados en la elipsis se transforman a otros tipos, no conservan su tipado original (y no se les puede pasar objetos de manera natural).
• Dependiente de C y sus cabeceras.

Superan con creces a sus ventajas:

• Es la manera más conocida.

C++ moderno (C++11 en adelante).

El estándar C++11 incorporó las plantillas variádicas, estas plantillas permiten crear funciones y objetos (y a partir de C++20 también lambdas) que reciban una cantidad arbitraria de argumentos de tipos arbitrarios, sus ventajas:

• Tipado fuerte.
• Trabaja con objetos de manera natural.
• Los errores se detectan en tiempo de compilación.

Superan con creces a sus desventajas:

• Sintaxis confusa.
• Los errores de compilación son muy confusos.
• Aumenta el tiempo de compilación.

---

Una función con parámetros variádicos tiene este aspecto:

template <typename ... VALORES>
/*                 ^^^ <--- La elipsis indica que tendremos un paquete de valores
                            el nombre del paquete de valores es VALORES. */
void function1(VALORES ... valores)
/*             ^^^^^^^ <--- Usamos el paquete de valores, 'VALORES ...' es el tipo
                            mientras que 'valores' son los argumentos. */
{
}

Si tuviéramos otra función con parámetros variádicos y quisiéramos pasar el paquete de parámetros a funcion1 lo haríamos así:

template <typename ... VALORES>
void function2(int ult, VALORES ... valores)
{
    function1(valores ...);
    //        ^^^^^^^ <--- Usamos los valores como argumento para function1
}

Observa que cada vez que tratamos con argumentos variádicos, la parte variádica (ya sean los tipos o los valores) va acompañada de la elipsis.

La elipsis obtiene automáticamente los tipos y valores facilitados, así que si se llamase a function2 con 2 parámetros:

function2(0, 100l);

El 0 iría a parar al argumento ult y el 100l iría la paquete de parámetros, que tendría un solo elemento de valor 100 y de tipo long; llamada con 6 parámetros:

function2(1, "patata", std::string{"frita"}, 'a', 100l, nullptr, 1 + 2 + 0.f);

El 1 iría a parar al argumento ult y el paquete de parámetros tendría como tipos const char *, std::string, char, long, nullptr_t y float con los valores que hemos visto antes; llamada con 1 parámetro:

function2(2);

El 2 iría a parar al argumento ult y el paquete de parámetros estaría vacío, lo que equivaldría a llamar a function1 vacía:

function1();