में सी ++ 11 आप के रूप में दो नये विकल्प है, variadic कार्यों में संदर्भ पेज वैकल्पिक खंड कहता है:
- वेरिएडिक टेम्प्लेट का उपयोग उन कार्यों को बनाने के लिए भी किया जा सकता है जो चर संख्या में तर्क लेते हैं। वे अक्सर बेहतर विकल्प होते हैं क्योंकि वे तर्कों के प्रकारों पर प्रतिबंध नहीं लगाते हैं, अभिन्न और फ्लोटिंग-पॉइंट प्रमोशन नहीं करते हैं, और सुरक्षित हैं। (C ++ 11 के बाद से)
- यदि सभी चर तर्क एक सामान्य प्रकार साझा करते हैं, तो एक चर :: initializer_list चर तर्कों तक पहुँचने के लिए एक सुविधाजनक तंत्र (एक अलग वाक्यविन्यास के साथ) प्रदान करता है।
नीचे एक उदाहरण है जो दोनों विकल्प दिखा रहा है ( इसे लाइव देखें ):
#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 } ) ;
}
यदि आप उपयोग कर रहे हैं gccया clangहम फ़ंक्शन के प्रकार हस्ताक्षर को प्रदर्शित करने के लिए PRETTY_FUNCTION जादू चर का उपयोग कर सकते हैं जो समझने में मददगार हो सकता है कि क्या हो रहा है। उदाहरण के लिए:
std::cout << __PRETTY_FUNCTION__ << ": " << t <<std::endl ;
उदाहरण में चर कार्यों के लिए निम्नलिखित परिणाम प्राप्त होंगे ( इसे लाइव देखें ):
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 में आप FUNCSIG का उपयोग कर सकते हैं ।
अद्यतन पूर्व C ++ 11
प्री सी ++ 11 एसटीडी के लिए विकल्प :: initializer_list एसटीडी होगा :: वेक्टर या अन्य मानक कंटेनरों में से एक :
#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 ) ;
}
और के लिए वैकल्पिक variadic टेम्पलेट्स होगा variadic कार्यों हालांकि वे नहीं कर रहे हैं टाइप-सुरक्षित और सामान्य रूप में त्रुटियों की संभावना और उपयोग करने के लिए असुरक्षित हो सकता है , लेकिन केवल अन्य संभावित विकल्प का उपयोग किया जाएगा डिफ़ॉल्ट तर्क है, हालांकि यह है कि सीमित उपयोग है। नीचे दिए गए उदाहरण से जुड़े संदर्भ में नमूना कोड का एक संशोधित संस्करण है:
#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 ;
}
वैरेडिक फ़ंक्शंस का उपयोग करने से उन तर्कों पर भी प्रतिबंध लग जाता है, जिन्हें आप पास कर सकते हैं, जो ड्राफ्ट C ++ मानक में विस्तृत है। 5.2.2 फंक्शन कॉल पैराग्राफ 7 :
जब किसी दिए गए तर्क के लिए कोई पैरामीटर नहीं होता है, तो तर्क को इस तरह से पारित किया जाता है कि प्राप्त फ़ंक्शन va_arg (18.7) को लागू करके तर्क का मूल्य प्राप्त कर सकता है। लॉवल्यू-टू-रिवल्यू (4.1), एरे-टू-पॉइंटर (4.2), और फ़ंक्शन-टू-पॉइंटर (4.3) मानक रूपांतरण तर्क अभिव्यक्ति पर किए जाते हैं। इन रूपांतरणों के बाद, यदि तर्क में अंकगणित, गणना, सूचक, सदस्य के लिए सूचक या कक्षा प्रकार नहीं है, तो कार्यक्रम बीमार है। यदि तर्क में गैर-POD वर्ग प्रकार (खंड 9) है, तो व्यवहार अपरिभाषित है। [...]