En C ++ 11, vous disposez de deux nouvelles options, comme l' indique la page de référence des fonctions Variadic dans la section Alternatives :
- Les modèles variadiques peuvent également être utilisés pour créer des fonctions qui prennent un nombre variable d'arguments. Ils sont souvent le meilleur choix car ils n'imposent pas de restrictions sur les types d'arguments, n'effectuent pas de promotions intégrales et à virgule flottante et sont sûrs pour les types. (depuis C ++ 11)
- Si tous les arguments variables partagent un type commun, une liste std :: initializer_list fournit un mécanisme pratique (mais avec une syntaxe différente) pour accéder aux arguments variables.
Voici un exemple montrant les deux alternatives ( voir en direct ):
#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 vous utilisez gccou clangnous pouvons utiliser la variable magique PRETTY_FUNCTION pour afficher la signature de type de la fonction qui peut être utile pour comprendre ce qui se passe. Par exemple en utilisant:
std::cout << __PRETTY_FUNCTION__ << ": " << t <<std::endl ;
donnerait les résultats suivants pour les fonctions variadiques dans l'exemple ( voir en direct ):
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
Dans Visual Studio, vous pouvez utiliser FUNCSIG .
Mettre à jour Pre C ++ 11
Avant C ++ 11, l'alternative pour std :: initializer_list serait std :: vector ou l'un des autres conteneurs 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 ) ;
}
et l'alternative pour les modèles variadic serait des fonctions variadic bien qu'elles ne soient pas sécuritaires pour le type et en général sujettes aux erreurs et puissent être dangereuses à utiliser, mais la seule autre alternative potentielle serait d'utiliser des arguments par défaut , bien que cela ait une utilisation limitée. L'exemple ci-dessous est une version modifiée de l'exemple de code dans la référence liée:
#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'utilisation de fonctions variadiques s'accompagne également de restrictions dans les arguments que vous pouvez transmettre, qui sont détaillés dans le projet de norme C ++ dans la section 5.2.2 Appel de fonction paragraphe 7 :
Lorsqu'il n'y a pas de paramètre pour un argument donné, l'argument est passé de telle manière que la fonction de réception puisse obtenir la valeur de l'argument en appelant va_arg (18.7). Les conversions standard lvalue à rvalue (4.1), tableau à pointeur (4.2) et fonction à pointeur (4.3) sont effectuées sur l'expression d'argument. Après ces conversions, si l'argument n'a pas d'arithmétique, d'énumération, de pointeur, de pointeur sur un membre ou un type de classe, le programme est mal formé. Si l'argument a un type de classe non POD (article 9), le comportement n'est pas défini. [...]