En C ++ 11 tiene dos nuevas opciones, como dice la página de referencia de funciones Variadic en la sección Alternativas :
- Las plantillas variables también se pueden usar para crear funciones que toman un número variable de argumentos. A menudo son la mejor opción porque no imponen restricciones sobre los tipos de argumentos, no realizan promociones integrales y de coma flotante, y son de tipo seguro. (desde C ++ 11)
- Si todos los argumentos variables comparten un tipo común, std :: initializer_list proporciona un mecanismo conveniente (aunque con una sintaxis diferente) para acceder a los argumentos variables.
A continuación se muestra un ejemplo que muestra ambas alternativas ( verlo en vivo ):
#include <iostream>
#include <string>
#include <initializer_list>
template <typename T>
void func(T t)
{
std::cout << t << std::endl ;
}
template<typename T, typename... Args>
void func(T t, Args... args) // recursive variadic function
{
std::cout << t <<std::endl ;
func(args...) ;
}
template <class T>
void func2( std::initializer_list<T> list )
{
for( auto elem : list )
{
std::cout << elem << std::endl ;
}
}
int main()
{
std::string
str1( "Hello" ),
str2( "world" );
func(1,2.5,'a',str1);
func2( {10, 20, 30, 40 }) ;
func2( {str1, str2 } ) ;
}
Si está utilizando gcco clangpodemos utilizar la variable mágica PRETTY_FUNCTION para mostrar la firma de tipo de la función que puede ser útil para comprender lo que está sucediendo. Por ejemplo usando:
std::cout << __PRETTY_FUNCTION__ << ": " << t <<std::endl ;
daría como resultado int following para funciones variadas en el ejemplo ( verlo en vivo ):
void func(T, Args...) [T = int, Args = <double, char, std::basic_string<char>>]: 1
void func(T, Args...) [T = double, Args = <char, std::basic_string<char>>]: 2.5
void func(T, Args...) [T = char, Args = <std::basic_string<char>>]: a
void func(T) [T = std::basic_string<char>]: Hello
En Visual Studio puedes usar FUNCSIG .
Actualizar Pre C ++ 11
Pre C ++ 11 la alternativa para std :: initializer_list sería std :: vector o uno de los otros contenedores estándar :
#include <iostream>
#include <string>
#include <vector>
template <class T>
void func1( std::vector<T> vec )
{
for( typename std::vector<T>::iterator iter = vec.begin(); iter != vec.end(); ++iter )
{
std::cout << *iter << std::endl ;
}
}
int main()
{
int arr1[] = {10, 20, 30, 40} ;
std::string arr2[] = { "hello", "world" } ;
std::vector<int> v1( arr1, arr1+4 ) ;
std::vector<std::string> v2( arr2, arr2+2 ) ;
func1( v1 ) ;
func1( v2 ) ;
}
y la alternativa para plantillas variadas serían funciones variadas, aunque no son de tipo seguro y en general propensas a errores y pueden ser inseguras de usar, pero la única otra alternativa potencial sería usar argumentos predeterminados , aunque eso tiene un uso limitado. El siguiente ejemplo es una versión modificada del código de muestra en la referencia vinculada:
#include <iostream>
#include <string>
#include <cstdarg>
void simple_printf(const char *fmt, ...)
{
va_list args;
va_start(args, fmt);
while (*fmt != '\0') {
if (*fmt == 'd') {
int i = va_arg(args, int);
std::cout << i << '\n';
} else if (*fmt == 's') {
char * s = va_arg(args, char*);
std::cout << s << '\n';
}
++fmt;
}
va_end(args);
}
int main()
{
std::string
str1( "Hello" ),
str2( "world" );
simple_printf("dddd", 10, 20, 30, 40 );
simple_printf("ss", str1.c_str(), str2.c_str() );
return 0 ;
}
El uso de funciones variadas también viene con restricciones en los argumentos que puede pasar, que se detalla en el borrador del estándar C ++ en la sección 5.2.2 Llamada de función, párrafo 7 :
Cuando no hay ningún parámetro para un argumento dado, el argumento se pasa de tal manera que la función receptora puede obtener el valor del argumento invocando va_arg (18.7). Las conversiones estándar lvalue-to-rvalue (4.1), array-to-pointer (4.2) y function-to-pointer (4.3) se realizan en la expresión de argumento. Después de estas conversiones, si el argumento no tiene aritmética, enumeración, puntero, puntero a miembro o tipo de clase, el programa está mal formado. Si el argumento tiene un tipo de clase que no es POD (cláusula 9), el comportamiento es indefinido. [...]