In C ++ 11 hai due nuove opzioni, come afferma la pagina di riferimento delle funzioni Variadic nella sezione Alternative :
- I modelli variabili possono anche essere utilizzati per creare funzioni che accettano un numero variabile di argomenti. Spesso sono la scelta migliore perché non impongono restrizioni sui tipi di argomenti, non svolgono promozioni integrali e in virgola mobile e sono sicure per i tipi. (dal C ++ 11)
- Se tutti gli argomenti variabili condividono un tipo comune, un elenco std :: initializer_list fornisce un comodo meccanismo (sebbene con una sintassi diversa) per accedere agli argomenti variabili.
Di seguito è riportato un esempio che mostra entrambe le alternative ( vederlo dal 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 stai utilizzando gcco clangpossiamo usare la variabile magica PRETTY_FUNCTION per visualizzare la firma del tipo della funzione che può essere utile per capire cosa sta succedendo. Ad esempio utilizzando:
std::cout << __PRETTY_FUNCTION__ << ": " << t <<std::endl ;
risulterebbe int seguente per le funzioni variadiche nell'esempio ( vederlo dal 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
In Visual Studio è possibile utilizzare FUNCSIG .
Aggiorna Pre C ++ 11
Pre C ++ 11 l'alternativa per std :: initializer_list sarebbe std :: vector o uno degli altri contenitori standard :
#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 l'alternativa per i modelli variadici sarebbero le funzioni variadiche anche se non sono sicure per i tipi e in genere soggette a errori e possono essere non sicure da usare, ma l'unica alternativa potenziale sarebbe usare argomenti predefiniti , sebbene ciò abbia un uso limitato. L'esempio seguente è una versione modificata del codice di esempio nel riferimento collegato:
#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 ;
}
L'uso delle funzioni variadiche comporta anche delle restrizioni negli argomenti che è possibile passare, che è dettagliato nella bozza dello standard C ++ nella sezione 5.2.2 Funzione chiamata paragrafo 7 :
Quando non esiste alcun parametro per un determinato argomento, l'argomento viene passato in modo tale che la funzione di ricezione possa ottenere il valore dell'argomento invocando va_arg (18.7). Le conversioni standard lvalue-to-rvalue (4.1), array-to-pointer (4.2) e function-to-pointer (4.3) vengono eseguite sull'espressione argomento. Dopo queste conversioni, se l'argomento non ha aritmetica, enumerazione, puntatore, puntatore al membro o tipo di classe, il programma non è corretto. Se l'argomento ha un tipo di classe non POD (clausola 9), il comportamento non è definito. [...]