No C ++ 11, você tem duas novas opções, conforme a página de referência das funções Variadic na seção Alternativas :
- Modelos variáveis também podem ser usados para criar funções que recebem número variável de argumentos. Geralmente, eles são a melhor escolha, porque não impõem restrições aos tipos de argumentos, não realizam promoções integrais e de ponto flutuante e são seguros para o tipo. (desde C ++ 11)
- Se todos os argumentos de variáveis compartilham um tipo comum, um std :: initializer_list fornece um mecanismo conveniente (embora com uma sintaxe diferente) para acessar argumentos de variáveis.
Abaixo está um exemplo mostrando as duas alternativas ( veja ao 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 } ) ;
}
Se você estiver usando gccou clangpodemos usar a variável mágica PRETTY_FUNCTION para exibir a assinatura de tipo da função que pode ser útil para entender o que está acontecendo. Por exemplo, usando:
std::cout << __PRETTY_FUNCTION__ << ": " << t <<std::endl ;
seria o resultado int a seguir para funções variadas no exemplo ( veja ao 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
No Visual Studio, você pode usar o FUNCSIG .
Atualizar pré C ++ 11
Antes do C ++ 11, a alternativa para std :: initializer_list seria std :: vector ou um dos outros contêineres padrão :
#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 ) ;
}
e a alternativa para modelos variados seriam funções variadas, embora não sejam de tipo seguro e, em geral, propensas a erros e possam ser inseguras de usar, mas a única outra alternativa em potencial seria usar argumentos padrão , embora isso tenha uso limitado. O exemplo abaixo é uma versão modificada do código de exemplo na referência 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 ;
}
O uso de funções variadas também vem com restrições nos argumentos que você pode passar, detalhadas no rascunho do padrão C ++ na seção 5.2.2 Chamada de função, parágrafo 7 :
Quando não há parâmetro para um dado argumento, o argumento é passado de maneira que a função receptora possa obter o valor do argumento invocando va_arg (18.7). As conversões padrão lvalue para rvalue (4.1), matriz para ponteiro (4.2) e função para ponteiro (4.3) são executadas na expressão de argumento. Após essas conversões, se o argumento não tiver aritmética, enumeração, ponteiro, ponteiro para membro ou tipo de classe, o programa ficará mal formado. Se o argumento tiver um tipo de classe não POD (cláusula 9), o comportamento será indefinido. [...]