सी ++: सहज पुरातत्व का एक सत्र और आपको सी की शैली में चर कार्यों का उपयोग क्यों नहीं करना चाहिए

मानक में ellipsis और va_list के बारे में क्या कहा गया है

• आप एक फ़ंक्शन की घोषणा कर सकते हैं जो मनमानी संख्या में तर्क लेता है। यानी एक फ़ंक्शन में मापदंडों से अधिक तर्क हो सकते हैं। ऐसा करने के लिए, इसके मापदंडों की सूची एक दीर्घवृत्त के साथ समाप्त होनी चाहिए, लेकिन कम से कम एक निश्चित पैरामीटर [C11 6.9.1 / 8] भी मौजूद होना चाहिए:
  
  

   void foo(int parm1, int parm2, ...); 

• दीर्घवृत्त से संबंधित तर्कों और संख्याओं के प्रकार के बारे में जानकारी फ़ंक्शन को ही नहीं दी जाती है। यानी अंतिम नामित पैरामीटर (उपरोक्त उदाहरण में parm2 ) के बाद [C11 6.7.6.3/9] ।
  
• इन तर्कों को एक्सेस करने के लिए, आपको <stdarg.h> हेडर और 4 (C11 मानक से पहले 3) मैक्रोज़: va_start , va_arg , va_end और va_copy (C11 के साथ शुरू) [C11 7.16] में घोषित va_list प्रकार का उपयोग करना होगा।
  
  
  उदाहरण के लिए

   int add(int count, ...) { int result = 0; va_list args; va_start(args, count); for (int i = 0; i < count; ++i) { result += va_arg(args, int); } va_end(args); return result; } 

  
  हां, फ़ंक्शन को पता नहीं है कि इसके कितने तर्क हैं। उसे किसी तरह इस नंबर को पास करने की जरूरत है। इस मामले में, एक एकल नामित तर्क के माध्यम से (दूसरा सामान्य विकल्प अंतिम तर्क के रूप में NULL को पास करना NULL , जैसा कि execl या 0 में है)।
• अंतिम नामित तर्क में register स्टोरेज क्लास नहीं हो सकता है, यह एक फ़ंक्शन या एक सरणी नहीं हो सकता है। अन्यथा, अपरिभाषित व्यवहार [C11 7.16.1.4/4] ।
• इसके अलावा, अंतिम नामित तर्क और सभी नामांकित लोगों के लिए, " डिफ़ॉल्ट तर्क पदोन्नति " लागू की जाती है ( डिफ़ॉल्ट तर्क पदोन्नति ; यदि रूसी में इस अवधारणा का एक अच्छा अनुवाद है, तो मैं ख़ुशी से इसका उपयोग करता हूं)। इसका मतलब यह है कि यदि तर्क में char , short (साथ या बिना चिह्न) या float , तो संबंधित मापदंडों को int , int (साइन के साथ या बिना) या double रूप में एक्सेस किया जाना चाहिए। अन्यथा, अपरिभाषित व्यवहार [C11 7.16.1.1/2] ।
• va_list के प्रकार के बारे में केवल यह कहा जाता है कि यह <stdarg.h> में घोषित किया गया है और पूर्ण है (अर्थात, इस प्रकार की किसी वस्तु का आकार ज्ञात है) [C11 7.16 / 3] ।

क्यों? लेकिन क्योंकि!

वैसे, मनमानी संख्या के तर्कों के पोर्टेबल फ़ंक्शन को लिखने का कोई स्वीकार्य तरीका नहीं है, क्योंकि कॉल करने के लिए यह कहने के लिए कोई फ़ंक्शन नहीं है कि इसके पास कितने तर्क हैं। ... printf , सबसे विशिष्ट सी भाषा फ़ंक्शन एक मनमानी संख्या के तर्कों की, ... पोर्टेबल नहीं है और प्रत्येक सिस्टम के लिए लागू किया जाना चाहिए।

 #ifndef _STADARG #define _STADARG #define _AUPBND 1 #define _ADNBND 1 typedef char* va_list #define va_arg(ap, T) \ (*(T*)(((ap) += _Bnd(T, _AUPBND)) - _Bnd(T, _ADNBND))) #define va_end(ap) \ (void)0 #define va_start(ap, A) \ (void)((ap) = (char*)&(A) + _Bnd(A, _AUPBND)) #define _Bnd(X, bnd) \ (sizeof(X) + (bnd) & ~(bnd)) #endif 

 typedef struct { unsigned int gp_offset; unsigned int fp_offset; void *overflow_arg_area; void *reg_save_area; } va_list[1]; 

C ++ में चर कार्य

• क्योंकि C ++, C के विपरीत, आपको चर का register पता प्राप्त करने की अनुमति देता है, फिर किसी चर फ़ंक्शन के अंतिम नामित तर्क में यह संग्रहण वर्ग हो सकता है।
  
• क्योंकि सी ++ में दिखाई देने वाले लिंक सी चर कार्यों के अलिखित नियम का उल्लंघन करते हैं - पैरामीटर का आकार इसके घोषित प्रकार के आकार से मेल खाना चाहिए - फिर अंतिम नामित तर्क एक लिंक नहीं हो सकता है। अन्यथा, अस्पष्ट व्यवहार।
  
• क्योंकि C ++ में " डिफ़ॉल्ट रूप से तर्क के प्रकार को बढ़ाने " की कोई अवधारणा नहीं है, फिर वाक्यांश
  

  यदि पैरामीटर parmN साथ घोषित किया जाता है ... एक प्रकार जो डिफ़ॉल्ट तर्क पदोन्नति के आवेदन के बाद परिणाम के साथ संगत नहीं है, तो व्यवहार अपरिभाषित है

  द्वारा प्रतिस्थापित किया जाना चाहिए

  यदि पैरामीटर parmN साथ घोषित किया जाता है ... एक प्रकार जो उस प्रकार के साथ संगत नहीं होता है जिसके परिणामस्वरूप एक ऐसा तर्क दिया जाता है जिसके लिए कोई पैरामीटर नहीं होता है, तो व्यवहार अपरिभाषित होता है

चर कार्यों को आसानी से और गलत तरीके से कैसे उपयोग करें

1. पदोन्नत प्रकार के साथ अंतिम नामित तर्क की घोषणा करना गलत है, अर्थात char , signed char , unsigned char , singed short , एक unsigned short या float । मानक के अनुसार परिणाम अपरिभाषित व्यवहार होगा।
   
   
   अमान्य कोड

    void foo(float n, ...) { va_list va; va_start(va, n); std::cout << va_arg(va, int) << std::endl; va_end(va); } 

   
   
   
   सभी संकलक जो मेरे हाथ में थे (gcc, clang, MSVC), केवल क्लैंग ने एक चेतावनी जारी की।
   
   
   दबंग चेतावनी

    ./test.cpp:7:18: warning: passing an object that undergoes default argument promotion to 'va_start' has undefined behavior [-Wvarargs] va_start(va, n); ^ 

   
   और यद्यपि सभी मामलों में संकलित कोड सही तरीके से व्यवहार किया गया है, आपको इस पर भरोसा नहीं करना चाहिए।
   
   
   यह सही होगा

    void foo(double n, ...) { va_list va; va_start(va, n); std::cout << va_arg(va, int) << std::endl; va_end(va); } 

   
   
2. अंतिम नामित तर्क को संदर्भ के रूप में घोषित करना गलत है। कोई लिंक। इस मामले में मानक भी अपरिभाषित व्यवहार का वादा करता है।
   
   
   अमान्य कोड

    void foo(int& n, ...) { va_list va; va_start(va, n); std::cout << va_arg(va, int) << std::endl; va_end(va); } 

   
   gcc 7.3.0 ने बिना किसी टिप्पणी के इस कोड को संकलित किया। lang 6.0.0 ने एक चेतावनी जारी की, लेकिन फिर भी इसे संकलित किया।
   
   
   दबंग चेतावनी

    ./test.cpp:7:18: warning: passing an object of reference type to 'va_start' has undefined behavior [-Wvarargs] va_start(va, n); ^ 

   
   दोनों मामलों में, कार्यक्रम ने सही ढंग से काम किया (भाग्यशाली, आप इस पर भरोसा नहीं कर सकते हैं)। लेकिन MSVC 19.15.26730 ने खुद को प्रतिष्ठित किया - इसने कोड को संकलित करने से इनकार कर दिया, क्योंकि va_start तर्क एक संदर्भ नहीं होना va_start ।
   
   
   MSVC से त्रुटि

    c:\program files (x86)\microsoft visual studio\2017\community\vc\tools\msvc\14.15.26726\include\vadefs.h(151): error C2338: va_start argument must not have reference type and must not be parenthesized 

   
   
   खैर, सही विकल्प दिखता है, उदाहरण के लिए, इस तरह

    void foo(int* n, ...) { va_list va; va_start(va, n); std::cout << va_arg(va, int) << std::endl; va_end(va); } 

   
   
3. टाइप va_arg लिए va_arg का अनुरोध करना गलत है - char , short या float ।
   
   
   अमान्य कोड

    #include <cstdarg> #include <iostream> void foo(int n, ...) { va_list va; va_start(va, n); std::cout << va_arg(va, int) << std::endl; std::cout << va_arg(va, float) << std::endl; std::cout << va_arg(va, int) << std::endl; va_end(va); } int main() { foo(0, 1, 2.0f, 3); return 0; } 

   
   यह यहाँ और अधिक दिलचस्प है। संकलन पर जीसीसी एक चेतावनी देता है कि float बजाय double का उपयोग करना आवश्यक है, और यदि यह कोड अभी भी निष्पादित किया जाता है, तो प्रोग्राम एक त्रुटि के साथ समाप्त हो जाएगा।
   
   
   जीसीसी चेतावनी

    ./test.cpp:9:15: warning: 'float' is promoted to 'double' when passed through '...' std::cout << va_arg(va, float) << std::endl; ^~~~~~ ./test.cpp:9:15: note: (so you should pass 'double' not 'float' to 'va_arg') ./test.cpp:9:15: note: if this code is reached, the program will abort 

   
   दरअसल, एक अवैध निर्देश के बारे में शिकायत के साथ प्रोग्राम क्रैश हो जाता है।
   एक डंप विश्लेषण से पता चलता है कि कार्यक्रम को एक संकेत प्राप्त हुआ। और यह va_list की संरचना को भी दर्शाता है। 32 बिट्स के लिए यह है
   
   

    va = 0xfffc6918 "" 

   
   यानी va_list सिर्फ char* । 64 बिट्स के लिए:
   
   

    va = {{gp_offset = 16, fp_offset = 48, overflow_arg_area = 0x7ffef147e7e0, reg_save_area = 0x7ffef147e720}} 

   
   यानी बिल्कुल वही जो SystemV ABI AMD64 में वर्णित है।
   
   संकलन में अव्यवस्था अपरिभाषित व्यवहार की चेतावनी देती है और double साथ float को बदलने का भी सुझाव देती है।
   
   
   दबंग चेतावनी

    ./test.cpp:9:26: warning: second argument to 'va_arg' is of promotable type 'float'; this va_arg has undefined behavior because arguments will be promoted to 'double' [-Wvarargs] std::cout << va_arg(va, float) << std::endl; ^~~~~ 

   
   लेकिन प्रोग्राम अब क्रैश नहीं होता है, 32-बिट संस्करण उत्पन्न करता है:
   
   

    1 0 1073741824 

   
   64 बिट:
   
   

    1 0 3 

   
   MSVC बिल्कुल वैसा ही परिणाम देता है, केवल चेतावनी के बिना /Wall ।
   
   यहां यह माना जा सकता है कि 32 और 64 बिट्स के बीच का अंतर इस तथ्य के कारण है कि पहले मामले में, एबीआई स्टैक के माध्यम से सभी फ़ंक्शन को तथाकथित फ़ंक्शन से गुजरता है, और दूसरे में, पहले चार (विंडोज) या छह (लिनक्स) प्रोसेसर रजिस्टरों के माध्यम से तर्क देता है, बाकी के माध्यम से ढेर [ विकी ]। लेकिन नहीं, अगर आप foo को 4 तर्कों के साथ नहीं, बल्कि 19 के साथ कहते हैं, और उन्हें उसी तरह से आउटपुट करते हैं, तो परिणाम समान होगा: 32-बिट संस्करण में पूर्ण गड़बड़ी, और 64-बिट एक में सभी float लिए शून्य। यानी एबीआई में बिंदु निश्चित रूप से है, लेकिन तर्कों को पारित करने के लिए रजिस्टरों के उपयोग में नहीं।
   
   
   बेशक, ऐसा करना सही है

    void foo(int n, ...) { va_list va; va_start(va, n); std::cout << va_arg(va, int) << std::endl; std::cout << va_arg(va, double) << std::endl; std::cout << va_arg(va, int) << std::endl; va_end(va); } 

   
   
4. अनाम तर्क के रूप में एक nontrivial निर्माता या विध्वंसक के साथ एक वर्ग के उदाहरण को पारित करना गलत है। जब तक, निश्चित रूप से, इस कोड का भाग्य आपको कम से कम "संकलन और यहां और अभी चलाने" से अधिक उत्तेजित करता है।
   
   
   अमान्य कोड

    #include <cstdarg> #include <iostream> struct Bar { Bar() { std::cout << "Bar default ctor" << std::endl; } Bar(const Bar&) { std::cout << "Bar copy ctor" << std::endl; } ~Bar() { std::cout << "Bar dtor" << std::endl; } }; struct Cafe { Cafe() { std::cout << "Cafe default ctor" << std::endl; } Cafe(const Cafe&) { std::cout << "Cafe copy ctor" << std::endl; } ~Cafe() { std::cout << "Cafe dtor" << std::endl; } }; void foo(int n, ...) { va_list va; va_start(va, n); std::cout << "Before va_arg" << std::endl; const auto b = va_arg(va, Bar); va_end(va); } int main() { Bar b; Cafe c; foo(1, b, c); return 0; } 

   
   क्लैंग सबसे गंभीर है वह केवल इस कोड को संकलित करने से इनकार करता है क्योंकि दूसरा तर्क, va_arg POD प्रकार नहीं है, और चेतावनी देता है कि कार्यक्रम स्टार्टअप पर va_arg हो जाएगा।
   
   
   दबंग चेतावनी

    ./test.cpp:23:31: error: second argument to 'va_arg' is of non-POD type 'Bar' [-Wnon-pod-varargs] const auto b = va_arg(va, Bar); ^~~ ./test.cpp:31:12: error: cannot pass object of non-trivial type 'Bar' through variadic function; call will abort at runtime [-Wnon-pod-varargs] foo(1, b, c); ^ 

   
   तो यह होगा, यदि आप अभी भी -Wno-non-pod-varargs ध्वज के साथ संकलन करते हैं।
   
   MSVC ने चेतावनी दी है कि इस मामले में गैर-तुच्छ कंस्ट्रक्टरों के साथ प्रकार का उपयोग पोर्टेबल नहीं है।
   
   
   MSVC से चेतावनी

    d:\my documents\visual studio 2017\projects\test\test\main.cpp(31): warning C4840:    "Bar"          

   
   लेकिन कोड संकलित करता है और सही ढंग से चलता है। निम्नलिखित कंसोल में प्राप्त किया गया है:
   
   
   लॉन्च परिणाम

    Bar default ctor Cafe default ctor Before va_arg Bar copy ctor Bar dtor Cafe dtor Bar dtor 

   
   यानी va_arg को कॉल करने के समय ही एक कॉपी बनाई va_arg , और तर्क, यह निकलता है, संदर्भ द्वारा पारित किया जाता है। यह किसी तरह स्पष्ट नहीं है, लेकिन मानक अनुमति देता है।
   
   जीसीसी 6.3.0 एक भी टिप्पणी के बिना संकलित करता है। आउटपुट समान है:
   
   
   लॉन्च परिणाम

    Bar default ctor Cafe default ctor Before va_arg Bar copy ctor Bar dtor Cafe dtor Bar dtor 

   
   7.3.0 gcc भी कुछ के बारे में चेतावनी नहीं देता है, लेकिन व्यवहार बदल रहा है:
   
   
   लॉन्च परिणाम

    Bar default ctor Cafe default ctor Cafe copy ctor Bar copy ctor Before va_arg Bar copy ctor Bar dtor Bar dtor Cafe dtor Cafe dtor Bar dtor 

   
   यानी संकलक का यह संस्करण मान से तर्क पारित करता है, और जब बुलाया जाता है, तो va_arg एक और प्रतिलिपि बनाता है। इस अंतर को देखने के लिए मज़ेदार होगा जब 6 वें से 7 वें संस्करण के सीएचसी पर स्विच किया जाता है यदि निर्माणकर्ताओं / विनाशकों के दुष्प्रभाव होते हैं।
   
   वैसे, यदि आप स्पष्ट रूप से पास होते हैं और कक्षा के संदर्भ का अनुरोध करते हैं:
   
   
   एक और गलत कोड

    void foo(int n, ...) { va_list va; va_start(va, n); std::cout << "Before va_arg" << std::endl; const auto& b = va_arg(va, Bar&); va_end(va); } int main() { Bar b; Cafe c; foo(1, std::ref(b), c); return 0; } 

   
   तब सभी संकलक एक त्रुटि फेंक देंगे। जैसा कि मानक द्वारा आवश्यक है।
   
   सामान्य तौर पर, यदि आप वास्तव में चाहते हैं, तो सूचक द्वारा तर्क पारित करना बेहतर है।
   
   
   इस तरह

    void foo(int n, ...) { va_list va; va_start(va, n); std::cout << "Before va_arg" << std::endl; const auto* b = va_arg(va, Bar*); va_end(va); } int main() { Bar b; Cafe c; foo(1, &b, &c); return 0; } 

   
   

अधिभार संकल्प और चर कार्य

 #include <iostream> void foo(...) { std::cout << "C variadic function" << std::endl; } void foo(int) { std::cout << "Ordinary function" << std::endl; } int main() { foo(1); foo(1ul); foo(); return 0; } 

 $ ./test Ordinary function Ordinary function C variadic function 

 #include <iostream> void foo(...) { std::cout << "C variadic function" << std::endl; } void foo() { std::cout << "Ordinary function without arguments" << std::endl; } int main() { foo(1); foo(); return 0; } 

 ./test.cpp:16:9: error: call of overloaded 'foo()' is ambiguous foo(); ^ ./test.cpp:3:6: note: candidate: void foo(...) void foo(...) ^~~ ./test.cpp:8:6: note: candidate: void foo() void foo() ^~~ 

जब यह चर कार्यों का उपयोग करने के लायक है

• सबसे आम और स्पष्ट मामला पिछड़ी संगतता है। यहां मैं तृतीय-पक्ष सी लाइब्रेरीज़ (जेएनआई के साथ मेरा मामला) और सी एपीआई के सी ++ कार्यान्वयन के प्रावधान दोनों का उपयोग शामिल होगा।
  
• SFINAE । यहां, यह बहुत उपयोगी है कि C ++ में एक चर फ़ंक्शन का नाम तर्क नहीं है, और यह कि जब ओवरलोड कार्यों को हल करना है, तो एक चर फ़ंक्शन को अंतिम माना जाता है (यदि कम से कम एक तर्क है)। और किसी अन्य फ़ंक्शन की तरह, एक चर फ़ंक्शन केवल घोषित किया जा सकता है, लेकिन कभी भी कॉल नहीं किया जाता है।
  
  
  उदाहरण

   template <class T> struct HasFoo { private: template <class U, class = decltype(std::declval<U>().foo())> static void detect(const U&); static int detect(...); public: static constexpr bool value = std::is_same<void, decltype(detect(std::declval<T>()))>::value; }; 

  
  हालांकि C ++ 14 में आप थोड़ा अलग तरीके से कर सकते हैं।
  
  
  एक और उदाहरण

   template <class T> struct HasFoo { private: template <class U, class = decltype(std::declval<U>().foo())> static constexpr bool detect(const U*) { return true; } template <class U> static constexpr bool detect(...) { return false; } public: static constexpr bool value = detect<T>(nullptr); }; 

  
  और इस मामले में पहले से ही यह देखना आवश्यक है कि क्या तर्क का detect(...) जा सकता है detect(...) कहा जा सकता है। मैं कुछ पंक्तियों को बदलना पसंद करूंगा और चर कार्यों के लिए एक आधुनिक विकल्प का उपयोग करूंगा, उनकी सभी कमियों से रहित।
  

वेरिएंट टेम्प्लेट या आधुनिक C ++ में मनमानी संख्याओं से कार्यों को कैसे बनाया जाए

• खाका मापदंडों पैकेज ( टेम्पलेट पैरामीटर पैक ) - जो के बजाय यह किसी भी (0 सहित) टेम्पलेट तर्क की संख्या में स्थानांतरित करना संभव है एक पैरामीटर टेम्पलेट है,;
  
• फंक्शन पैरामीटर्स का एक पैकेज ( फंक्शन पैरामीटर पैक ) - तदनुसार, यह एक फंक्शन पैरामीटर है जो फ़ंक्शन तर्कों की संख्या (0 सहित) लेता है;
  
• और पैकेज का विस्तार ( पैक विस्तार ) केवल एक चीज है जो मापदंडों के पैकेज के साथ किया जा सकता है।
  

 template <class ... Args> void foo(const std::string& format, Args ... args) { printf(format.c_str(), args...); } 

• फ़ंक्शन पैरामीटर पैकेज को दूसरे फ़ंक्शन की तर्क सूची में विस्तारित किया जा सकता है

   template <class ... Args> void bar(const std::string& format, Args ... args) { foo<Args...>(format.c_str(), args...); } 

  
  
• या आरंभीकरण सूची में

   template <class ... Args> void foo(const std::string& format, Args ... args) { const auto list = {args...}; } 

  
  
• या लैंबडा कैप्चर सूची में

   template <class ... Args> void foo(const std::string& format, Args ... args) { auto lambda = [&format, args...] () { printf(format.c_str(), args...); }; lambda(); } 

  
  
• फ़ंक्शन मापदंडों का एक और पैकेज एक कनवल्शन एक्सप्रेशन में विस्तारित किया जा सकता है

   template <class ... Args> int foo(Args ... args) { return (0 + ... + args); } 

  
  वार्तालाप C ++ 14 में दिखाई दिए और वे दाएं और बाएं एकात्मक और बाइनरी हो सकते हैं। सबसे पूर्ण विवरण, हमेशा की तरह, मानक [C ++ 17 8.1.6] में है ।
  
• दोनों प्रकार के पैरामीटर पैकेजों को आकार ... ऑपरेटर में विस्तारित किया जा सकता है

   template <class ... Args> void foo(Args ... args) { const auto size1 = sizeof...(Args); const auto size2 = sizeof...(args); } 

  
  

 template <class ... Args> void foo() { using OneTuple = std::tuple<std::tuple<Args>...>; using NestTuple = std::tuple<std::tuple<Args...>>; } 

वेरिएबल टेम्प्लेट का उपयोग करके प्रिंटफ़ का कार्यान्वयन

 void printf(const char* s) { while (*s) { if (*s == '%' && *++s != '%') throw std::runtime_error("invalid format string: missing arguments"); std::cout << *s++; } } template <typename T, typename ... Args> void printf(const char* s, T value, Args ... args) { while (*s) { if (*s == '%' && *++s != '%') { std::cout << value; return printf(++s, args...); } std::cout << *s++; } throw std::runtime_error("extra arguments provided to printf"); } 

 template <typename ... Args> void printf(const std::string& fmt, const Args& ... args) { size_t fmtIndex = 0; size_t placeHolders = 0; auto printFmt = [&fmt, &fmtIndex, &placeHolders]() { for (; fmtIndex < fmt.size(); ++fmtIndex) { if (fmt[fmtIndex] != '%') std::cout << fmt[fmtIndex]; else if (++fmtIndex < fmt.size()) { if (fmt[fmtIndex] == '%') std::cout << '%'; else { ++fmtIndex; ++placeHolders; break; } } } }; ((printFmt(), std::cout << args), ..., (printFmt())); if (placeHolders < sizeof...(args)) throw std::runtime_error("extra arguments provided to printf"); if (placeHolders > sizeof...(args)) throw std::runtime_error("invalid format string: missing arguments"); } 

अधिभार संकल्प और चर टेम्पलेट कार्य

 #include <iostream> void foo(int) { std::cout << "Ordinary function" << std::endl; } void foo() { std::cout << "Ordinary function without arguments" << std::endl; } template <class T> void foo(T) { std::cout << "Template function" << std::endl; } template <class ... Args> void foo(Args ...) { std::cout << "Template variadic function" << std::endl; } int main() { foo(1); foo(); foo(2.0); foo(1, 2); return 0; } 

 $ ./test Ordinary function Ordinary function without arguments Template function Template variadic function 

 #include <iostream> void foo(...) { std::cout << "C variadic function" << std::endl; } template <class ... Args> void foo(Args ...) { std::cout << "Template variadic function" << std::endl; } int main() { foo(1); foo(); return 0; } 

 $ ./test Template variadic function C variadic function 

चर टेम्पलेट फ़ंक्शंस की गति पर एक त्वरित नोट

संक्षिप्त सारांश और निष्कर्ष

• उन्हें या तो उनके तर्कों की संख्या या उनके प्रकारों की जानकारी नहीं है। डेवलपर को बाकी के बारे में जानकारी देने के लिए फ़ंक्शन के तर्कों का उपयोग करना चाहिए।
  
• अवैध रूप से अनाम तर्क (और अंतिम नाम) के प्रकार उठाएं। यदि आप इसके बारे में भूल जाते हैं, तो आपको अस्पष्ट व्यवहार मिलता है।
  
• वे शुद्ध सी के साथ पिछड़ी संगतता बनाए रखते हैं और इसलिए संदर्भ द्वारा तर्क पारित करने का समर्थन नहीं करते हैं।
  
• C ++ 11 से पहले, POD प्रकारों के तर्क का समर्थन नहीं किया गया था , और C ++ 11 के बाद से, गैर-तुच्छ प्रकारों के लिए समर्थन संकलक के विवेक पर छोड़ दिया गया था। यानी कोड का व्यवहार कंपाइलर और उसके संस्करण पर निर्भर करता है।
  

• उनके सभी तर्कों की संख्या और प्रकारों को जानें।
  
• सुरक्षित टाइप करें, उनके तर्कों के प्रकारों को न बदलें।
  
• वे किसी भी रूप में गुजरती तर्कों का समर्थन करते हैं - मूल्य द्वारा, सूचक द्वारा, संदर्भ द्वारा, सार्वभौमिक लिंक द्वारा।
  
• किसी भी अन्य सी ++ फ़ंक्शन की तरह, तर्कों के प्रकारों पर कोई प्रतिबंध नहीं है।
  
• ( C ), .
  

साहित्य और स्रोत

• पीजे प्लेंजर, द स्टैंडर्ड सी लाइब्रेरी
  
• ब्रायन डब्ल्यू कर्निघन और डेनिस एम। रिची, द सी प्रोग्रामिंग लैंग्वेज, प्रथम संस्करण
  
• ब्रायन डब्ल्यू कर्निघन और डेनिस एम। रिची, द सी प्रोग्रामिंग लैंग्वेज, 2 डी संस्करण
  
• मानक C11, मसौदा N1570
  
• सी ++ 98 मानक
  
• सी ++ 03 मानक
  
• सी ++ 11 मानक, मसौदा एन 3337
  
• मानक सी ++ 14, ड्राफ्ट N4296
  
• सी ++ 17 मानक, मसौदा N4659
  

पुनश्च