programación - Una función con un número variable de argumentos con tipos conocidos, la forma c++ 11

manual de programacion en c

Question

Ya conozco la forma stdarg.h de tener una función con argumentos variables en c ++ como se explica here por ejemplo. También sé que el estándar c ++ 11 tiene varias plantillas, como se explica here .

Pero en ambos esquemas mencionados no sabemos (y no podemos forzar) los tipos de argumentos en tiempo de compilación. Lo que estoy buscando es pasar argumentos variables de tipos conocidos a una función. Creo que esto se puede hacer porque lo leí here :

Las plantillas Variadic, que también se pueden usar para crear funciones que toman un número variable de argumentos, son a menudo la mejor opción porque no imponen restricciones en los tipos de los argumentos, no realizan promociones integrales y de punto flotante, y son de tipo seguro .

¿Es posible? Si es así, ¿cómo puedo hacer esto?

Answer 1

Es sencillo escribir una función con varias plantillas, que aceptan un número arbitrario de argumentos. La única diferencia con el patrón general es que un tipo concreto se usa como primer argumento (encabezado), en lugar de un parámetro de plantilla. El siguiente ejemplo muestra una función foobar , que acepta un número arbitrario de cadenas.

// used for end of recursion - and for the empty arguments list
void foobar() { }

template <typename ...Tail>
void foobar(const std::string& head, Tail&&... tail)
{
    // do something with head
    std::cout << head << ''/n'';
    // call foobar recursively with remaining arguments
    foobar(std::forward<Tail>(tail)...);
}

foobar("Hello", "World", "...");

Personalmente, prefiero usar std::initializer_list lugar de las plantillas variadic. Porque las plantillas variad son más complejas y requieren experiencia adicional. Con std::initializer_list , podría verse así:

void foobar(std::initializer_list<std::string> values)
{
    for (auto& value : values) {
        // do something with value
        std::cout << value << ''/n'';
    }
}

foobar({ "Hello", "World", "...", });

Desafortunadamente, las llaves adicionales son necesarias cuando se usa std::initializer_list con funciones regulares. No son necesarios para los constructores, si se utiliza la nueva sintaxis del inicializador.

Editar: reescriba la respuesta de acuerdo a los comentarios. En particular, he cambiado el orden de las dos soluciones / ejemplos.

Answer 2

Si los parámetros variables son todos de un tipo, puede cambiar la firma de la función para tomar una matriz de esos tipos en lugar de usar el ''...''.