In C ++ 11 siz iki yeni seçenek var Değişkin fonksiyonları referans sayfası Alternatifler bölüm devletler:
- Değişken şablonları, değişken sayıda bağımsız değişken alan işlevler oluşturmak için de kullanılabilir. Genellikle daha iyi bir seçimdir, çünkü argüman türlerine kısıtlama getirmezler, integral ve kayan nokta promosyonları yapmazlar ve tip güvenlidirler. (C ++ 11'den beri)
- Tüm değişken bağımsız değişkenleri ortak bir türü paylaşıyorsa, std :: initializer_list, değişken bağımsız değişkenlerine erişmek için uygun bir mekanizma (farklı bir sözdizimi de olsa) sağlar.
Aşağıda her iki alternatifi de gösteren bir örnek bulunmaktadır ( bakınız canlı ):
#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 } ) ;
}
Eğer kullanıyorsanız gccveya clangkullanabileceğimiz PRETTY_FUNCTION sihirli değişken olan biteni anlamada yararlı olabilir fonksiyonun tipi imzasını görüntülemek için. Örneğin:
std::cout << __PRETTY_FUNCTION__ << ": " << t <<std::endl ;
örnekte varyasyon fonksiyonları için int ile sonuçlanır ( bakınız canlı ):
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
Visual Studio'da FUNCSIG kullanabilirsiniz .
Ön C ++ 11'i Güncelle
Ön C ++ 11 alternatif std :: initializer_list olacaktır Std :: vektör veya başka bir standart konteyner :
#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 ) ;
}
ve değişken tipli şablonların alternatifi, tip-güvenli ve genel olarak hataya eğilimli olmaları ve kullanımı güvensiz olmalarına rağmen değişken işlevler olacaktır , ancak diğer tek potansiyel alternatif , sınırlı kullanıma sahip olmasına rağmen varsayılan bağımsız değişkenleri kullanmak olacaktır. Aşağıdaki örnek, bağlantılı başvurudaki örnek kodun değiştirilmiş bir sürümüdür:
#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 ;
}
Variadic işlevlerin kullanılması , İşlev çağrısı paragraf 7 bölümündeki taslak C ++ standardında ayrıntılı olarak verilebilen bağımsız değişkenlerde kısıtlamalarla birlikte gelir :5.2.2
Belirli bir bağımsız değişken için parametre olmadığında, bağımsız değişken alma işlevi va_arg (18.7) öğesini çağırarak bağımsız değişkenin değerini alabilecek şekilde geçirilir. Lvalue-rvalue (4.1), dizi-işaretçi (4.2) ve işlev-işaretçi (4.3) standart dönüşümleri bağımsız değişken ifadesinde gerçekleştirilir. Bu dönüşümlerden sonra, bağımsız değişkenin aritmetik, numaralandırma, işaretçi, üyeye işaretçi veya sınıf türü yoksa, program kötü biçimlendirilir. Bağımsız değişken POD olmayan bir sınıf türüne sahipse (madde 9), davranış tanımsızdır. [...]