In C ++ 11 haben Sie zwei neue Optionen, wie auf der Referenzseite für Variadic-Funktionen im Abschnitt Alternativen angegeben :
- Variadische Vorlagen können auch verwendet werden, um Funktionen zu erstellen, die eine variable Anzahl von Argumenten annehmen. Sie sind häufig die bessere Wahl, da sie die Arten der Argumente nicht einschränken, keine Integral- und Gleitkomma-Promotions durchführen und typsicher sind. (seit C ++ 11)
- Wenn alle Variablenargumente einen gemeinsamen Typ haben, bietet eine std :: initializer_list einen praktischen Mechanismus (wenn auch mit einer anderen Syntax) für den Zugriff auf Variablenargumente.
Unten sehen Sie ein Beispiel, das beide Alternativen zeigt ( live sehen ):
#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 } ) ;
}
Wenn Sie die magische Variable PRETTY_FUNCTION verwenden gccoder clangwir sie verwenden können, um die Typensignatur der Funktion anzuzeigen, kann dies hilfreich sein, um zu verstehen, was vor sich geht. Zum Beispiel mit:
std::cout << __PRETTY_FUNCTION__ << ": " << t <<std::endl ;
Die folgenden Ergebnisse würden für verschiedene Funktionen im Beispiel folgen ( siehe live ):
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 können Sie FUNCSIG verwenden .
Aktualisieren Sie Pre C ++ 11
Pre C ++ 11 die Alternative für std :: initializer_list wäre std :: vector oder einer der anderen Standardcontainer :
#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 ) ;
}
und die Alternative für variadische Vorlagen wären variadische Funktionen, obwohl sie nicht typsicher und im Allgemeinen fehleranfällig sind und unsicher zu verwenden sind, aber die einzige andere mögliche Alternative wäre die Verwendung von Standardargumenten , obwohl dies nur eine begrenzte Verwendung hat. Das folgende Beispiel ist eine modifizierte Version des Beispielcodes in der verknüpften Referenz:
#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 ;
}
Die Verwendung variabler Funktionen unterliegt auch Einschränkungen bei den Argumenten, die Sie übergeben können. Dies wird im Entwurf des C ++ - Standards im Abschnitt 5.2.2 Funktionsaufruf Absatz 7 beschrieben :
Wenn für ein bestimmtes Argument kein Parameter vorhanden ist, wird das Argument so übergeben, dass die empfangende Funktion den Wert des Arguments durch Aufrufen von va_arg (18.7) ermitteln kann. Die Standardkonvertierungen lvalue-to-rvalue (4.1), array-to-pointer (4.2) und function-to-pointer (4.3) werden für den Argumentausdruck ausgeführt. Wenn das Argument nach diesen Konvertierungen keine Arithmetik, Aufzählung, keinen Zeiger, keinen Zeiger auf ein Mitglied oder keinen Klassentyp enthält, ist das Programm fehlerhaft. Wenn das Argument einen Nicht-POD-Klassentyp hat (Klausel 9), ist das Verhalten undefiniert. [...]