W C ++ 11 masz dwie nowe opcje, ponieważ strona referencyjna funkcji Variadic w sekcji Alternatywy mówi:
- Szablony variadic mogą być również używane do tworzenia funkcji, które przyjmują zmienną liczbę argumentów. Często są lepszym wyborem, ponieważ nie nakładają ograniczeń na typy argumentów, nie przeprowadzają promocji integralnych i zmiennoprzecinkowych oraz są bezpieczne dla typu. (od C ++ 11)
- Jeśli wszystkie zmienne argumenty mają wspólny typ, lista std :: initializer_list zapewnia wygodny mechanizm (choć z inną składnią) dostępu do argumentów zmiennych.
Poniżej znajduje się przykład pokazujący obie alternatywy ( zobacz na żywo ):
#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 } ) ;
}
Jeśli używasz gcclub clangmożemy użyć magicznej zmiennej PRETTY_FUNCTION, aby wyświetlić podpis typu funkcji, który może być pomocny w zrozumieniu, co się dzieje. Na przykład za pomocą:
std::cout << __PRETTY_FUNCTION__ << ": " << t <<std::endl ;
w poniższym przykładzie wyniki dla funkcji variadic ( zobacz na żywo ):
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
W Visual Studio możesz użyć FUNCSIG .
Zaktualizuj wersję C ++ 11
Przed wersją C ++ 11 alternatywą dla std :: initializer_list byłby std :: vector lub jeden z innych standardowych kontenerów :
#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 ) ;
}
a alternatywą dla szablonów variadic byłyby funkcje variadic, chociaż nie są one bezpieczne pod względem typu i generalnie podatne na błędy i mogą być niebezpieczne w użyciu, ale jedyną potencjalną alternatywą byłoby użycie domyślnych argumentów , chociaż ma to ograniczone zastosowanie. Poniższy przykład to zmodyfikowana wersja przykładowego kodu w powiązanym odnośniku:
#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 ;
}
Korzystanie z funkcji variadic wiąże się również z ograniczeniami w argumentach, które można przekazać, co jest szczegółowo opisane w projekcie standardu C ++ w sekcji 5.2.2 Wywołanie funkcji w paragrafie 7 :
Gdy nie ma parametru dla danego argumentu, argument jest przekazywany w taki sposób, że funkcja odbierająca może uzyskać wartość argumentu przez wywołanie va_arg (18.7). Standardowe konwersje lvalue-to-rvalue (4.1), array-to-pointer (4.2) i function-to-pointer (4.3) są wykonywane na wyrażeniu argumentu. Po tych konwersjach, jeśli argument nie ma arytmetyki, wyliczenia, wskaźnika, wskaźnika do elementu lub typu klasy, program jest źle sformułowany. Jeśli argument ma typ klasy innej niż POD (klauzula 9), zachowanie jest niezdefiniowane. [...]