वैरिएडिक फ़ंक्शन

गणित और कंप्यूटर प्रोग्रामिंग में, एक वैरिएडिक फ़ंक्शन अनिश्चितकालीनता का एक फ़ंक्शन (प्रोग्रामिंग) है, अर्थात, जो तर्क (कंप्यूटर विज्ञान) की एक चर संख्या को स्वीकार करता है। विविध कार्यों के लिए समर्थन विभिन्न प्रोग्रामिंग भाषाओं में व्यापक रूप से भिन्न होता है।

वैरिएडिक शब्द एक नवविज्ञान है, जो 1936-1937 तक चला। 1970 के दशक तक इस शब्द का व्यापक रूप से उपयोग नहीं किया गया था।

अवलोकन
ऐसे कई गणितीय और तार्किक संचालन हैं जो स्वाभाविक रूप से विविध कार्यों के रूप में सामने आते हैं। उदाहरण के लिए, संख्याओं का योग या स्ट्रिंग्स या अन्य अनुक्रमों का संयोजन ऐसे ऑपरेशन हैं जिन्हें किसी भी संख्या में ऑपरेंड पर लागू माना जा सकता है (भले ही इन मामलों में औपचारिक रूप से सहयोगी संपत्ति लागू होती है)।

एक अन्य ऑपरेशन जिसे कई भाषाओं में वैरिएडिक फ़ंक्शन के रूप में कार्यान्वित किया गया है वह है आउटपुट फ़ॉर्मेटिंग। सी (प्रोग्रामिंग भाषा) फ़ंक्शन प्रिंटफ|printf और सामान्य लिस्प फ़ंक्शन प्रारूप (सामान्य लिस्प)|format ऐसे दो उदाहरण हैं. दोनों एक तर्क लेते हैं जो आउटपुट के स्वरूपण को निर्दिष्ट करता है, और किसी भी संख्या में तर्क जो स्वरूपित किए जाने वाले मान प्रदान करते हैं।

वैरिएडिक फ़ंक्शंस कुछ भाषाओं में प्रकार सुरक्षा|प्रकार-सुरक्षा समस्याओं को उजागर कर सकते हैं। उदाहरण के लिए, सी printf, यदि सावधानी से उपयोग किया जाता है, तो सुरक्षा छिद्रों के एक वर्ग को जन्म दे सकता है जिसे प्रारूप स्ट्रिंग हमलों के रूप में जाना जाता है। हमला संभव है क्योंकि वैरिएडिक फ़ंक्शंस के लिए भाषा समर्थन प्रकार-सुरक्षित नहीं है: यह फ़ंक्शन को स्टैक (अमूर्त डेटा प्रकार) #हार्डवेयर स्टैक से अधिक तर्क पॉप करने का प्रयास करने की अनुमति देता है, जिससे स्टैक दूषित हो जाता है और अप्रत्याशित परिणाम होता है व्यवहार। इसके परिणामस्वरूप, सीईआरटी समन्वय केंद्र सी में विविध कार्यों को उच्च-गंभीर सुरक्षा जोखिम मानता है। कार्यात्मक भाषाओं में वेरिएडिक्स को आवेदन करना फ़ंक्शन का पूरक माना जा सकता है, जो एक फ़ंक्शन और एक सूची/अनुक्रम/सरणी को तर्क के रूप में लेता है, और उस सूची में दिए गए तर्कों के साथ फ़ंक्शन को कॉल करता है, इस प्रकार फ़ंक्शन में तर्कों की एक चर संख्या पारित करता है। कार्यात्मक भाषा हास्केल (प्रोग्रामिंग भाषा) में, एक प्रकार के वर्ग का मान लौटाकर विविध कार्यों को कार्यान्वित किया जा सकता है T; यदि के उदाहरण T अंतिम रिटर्न मान हैं r और एक फ़ंक्शन (T t) => x -> t, यह किसी भी संख्या में अतिरिक्त तर्क की अनुमति देता है x.

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

सी में
C (प्रोग्रामिंग भाषा) में विविध कार्यों को पोर्टेबल रूप से लागू करने के लिए, मानक stdarg.h|stdarg.h हेडर फ़ाइल का उपयोग किया जाता है. पुराने varargs.h|varargs.h हेडर के पक्ष में अस्वीकृत कर दिया गया है stdarg.h. C++ में, हेडर फ़ाइल cstdarg प्रयोग किया जाता है।

यह तर्कों की मनमानी संख्या के औसत की गणना करेगा। ध्यान दें कि फ़ंक्शन तर्कों की संख्या या उनके प्रकारों को नहीं जानता है। उपरोक्त फ़ंक्शन अपेक्षा करता है कि प्रकार होंगे int, और यह कि पहले तर्क में तर्कों की संख्या पारित की जाती है (यह अक्सर उपयोग होता है लेकिन भाषा या संकलक द्वारा किसी भी तरह से लागू नहीं किया जाता है)। कुछ अन्य मामलों में, उदाहरण के लिए printf, एक प्रारूप स्ट्रिंग से तर्कों की संख्या और प्रकार का पता लगाया जाता है। दोनों ही मामलों में, यह प्रोग्रामर पर निर्भर करता है कि वह सही जानकारी प्रदान करे। (वैकल्पिक रूप से, एक प्रहरी मान जैसे NULL का उपयोग संख्या को इंगित करने के लिए किया जा सकता है।) यदि फ़ंक्शन के विश्वास से कम तर्क पारित किए जाते हैं, या तर्क के प्रकार गलत हैं, तो इससे यह मेमोरी के अमान्य क्षेत्रों में पढ़ सकता है और प्रारूप स्ट्रिंग हमले जैसी कमजोरियों को जन्म दे सकता है।.

stdarg.h एक प्रकार घोषित करता है, va_list, और चार मैक्रोज़ को परिभाषित करता है: va प्रारंभ|va_start, वा arg|va_arg, वीए कॉपी|va_copy, और वा अंत|va_end. प्रत्येक मंगलाचरण va_start और va_copy के अनुरूप मंगलाचरण से मेल खाना चाहिए va_end. परिवर्तनीय तर्कों के साथ काम करते समय, एक फ़ंक्शन आम तौर पर एक प्रकार का चर घोषित करता है va_list (ap उदाहरण में) जिसे मैक्रोज़ द्वारा हेरफेर किया जाएगा।


 * 1) va_start दो तर्क लेता है, a va_list ऑब्जेक्ट और फ़ंक्शन के अंतिम पैरामीटर का संदर्भ (एलिप्सिस से पहले वाला; मैक्रो इसका उपयोग अपने बीयरिंग प्राप्त करने के लिए करता है)। C23 (C मानक संशोधन) में, दूसरे तर्क की अब आवश्यकता नहीं होगी और विविध कार्यों को दीर्घवृत्त से पहले नामित पैरामीटर की आवश्यकता नहीं होगी। यह आरंभ करता है va_list द्वारा उपयोग के लिए वस्तु va_arg या va_copy. यदि संदर्भ गलत है तो कंपाइलर आम तौर पर एक चेतावनी जारी करेगा (उदाहरण के लिए पिछले पैरामीटर से भिन्न पैरामीटर का संदर्भ, या पूरी तरह से अलग ऑब्जेक्ट का संदर्भ), लेकिन संकलन को सामान्य रूप से पूरा होने से नहीं रोकेगा।
 * 2) va_arg दो तर्क लेता है, a va_list ऑब्जेक्ट (पहले प्रारंभ किया गया) और एक प्रकार का वर्णनकर्ता। यह अगले चर तर्क तक विस्तारित होता है, और इसमें निर्दिष्ट प्रकार होता है। का क्रमिक आह्वान va_arg प्रत्येक परिवर्तनीय तर्क को बारी-बारी से संसाधित करने की अनुमति दें। अनिर्दिष्ट व्यवहार तब होता है जब प्रकार गलत है या कोई अगला चर तर्क नहीं है।
 * 3) va_end एक तर्क लेता है, ए va_list वस्तु। यह साफ़ करने का काम करता है. उदाहरण के लिए, यदि कोई वैरिएबल तर्कों को एक से अधिक बार स्कैन करना चाहता है, तो प्रोग्रामर आपका पुनः आरंभ करेगा va_list आक्षेप द्वारा वस्तु va_end और तब va_start फिर से उस पर.
 * 4) va_copy दो तर्क लेता है, दोनों va_list वस्तुएं। यह दूसरे को (जिसे प्रारंभ किया गया होगा) पहले में क्लोन करता है। एक से अधिक उदाहरणों में परिवर्तनीय तर्कों को स्कैन करने पर वापस जाकर, इसे लागू करके हासिल किया जा सकता है va_start पहले पर va_list, फिर उपयोग करना va_copy इसे एक सेकंड में क्लोन करने के लिए va_list. परिवर्तनीय तर्कों को पहली बार स्कैन करने के बाद va_arg और पहला va_list (इसके साथ इसका निपटान va_end), प्रोग्रामर वेरिएबल तर्कों को दूसरी बार स्कैन कर सकता है va_arg और दूसरा va_list. va_end को क्लोन पर भी कॉल करने की आवश्यकता है va_list युक्त फ़ंक्शन के वापस आने से पहले।

सी#
में सी शार्प (प्रोग्रामिंग भाषा)|सी# का उपयोग करके विविध कार्यों का वर्णन करता है params कीवर्ड. हालाँकि, तर्कों के लिए एक प्रकार प्रदान किया जाना चाहिए object[] को कैच-ऑल के रूप में उपयोग किया जा सकता है। कॉलिंग साइट पर, आप या तो तर्कों को एक-एक करके सूचीबद्ध कर सकते हैं, या आवश्यक तत्व प्रकार वाले पहले से मौजूद सरणी को सौंप सकते हैं। वैरिएडिक फॉर्म का उपयोग बाद के लिए वाक्यात्मक शर्करा है।

 सिस्टम का उपयोग करना;

कक्षा कार्यक्रम {   स्थिर int Foo(int a, int b, पैरामीटर्स int[] args) {       // a और b को अनदेखा करते हुए, तर्कों में पूर्णांकों का योग लौटाएँ। इंट योग = 0; foreach (int i in args) योग + = मैं; वापसी राशि; }   स्थिर शून्य मुख्य(स्ट्रिंग[] तर्क) {       कंसोल.राइटलाइन(फू(1,2)); // 0 कंसोल.राइटलाइन(फू(1, 2, 3, 10, 20)); //33 int[] कई वैल्यूज़ = नया int[] {13, 14, 15 }; कंसोल.राइटलाइन(फू(1,2, अनेक वैल्यूज़)); //42 } } 

सी++ में
C++ में बुनियादी विविधतापूर्ण सुविधा काफी हद तक C के समान है। एकमात्र अंतर वाक्यविन्यास में है, जहां दीर्घवृत्त से पहले अल्पविराम को छोड़ा जा सकता है। C++ नामित मापदंडों के बिना विविध कार्यों की अनुमति देता है लेकिन तब से उन तर्कों तक पहुंचने का कोई तरीका प्रदान नहीं करता है  फ़ंक्शन के अंतिम निश्चित तर्क के नाम की आवश्यकता है। 
 * 1) शामिल
 * 2) शामिल

void Simple_printf(const char* fmt...) // C-style const char* fmt, ... भी मान्य है {   va_list तर्क; va_start(args, fmt); जबकि (*fmt != '\0') { यदि (*fmt == 'd') { int i = va_arg(args, int); std::cout << i << '\n'; } अन्यथा यदि (*fmt == 'c') { // इंटीग्रल प्रकार में स्वचालित रूपांतरण पर ध्यान दें int c = va_arg(args, int); std::cout << static_cast (c) << '\n'; } अन्यथा यदि (*fmt == 'f') { डबल डी = va_arg(args, डबल); std::cout << d << '\n'; }       ++ एफएमटी; }   va_end(args); }

मुख्य प्रवेश बिंदु {   Simple_printf(dcff, 3, 'ए', 1.999, 42.5); } 

विविध टेम्पलेट्स (पैरामीटर पैक) का उपयोग C++ में अंतर्निहित भाषा (उच्च-क्रम फ़ंक्शन) के साथ भी किया जा सकता है।


 * 1) शामिल

टेम्प्लेट <नाम टाइप करें... Ts> शून्य foo_print(Ts... args) {   ((std::cout << args << ''), ...); }

मुख्य प्रवेश बिंदु {   std::cout << std::boolalpha; foo_print(1, 3.14f); // 1 3.14 foo_print(Foo, 'b', true, nullptr); // फू बी सच nullptr } 

सी++ के लिए सीईआरटी कोडिंग मानक दुरुपयोग के कम जोखिम के कारण सी-स्टाइल वैरिएडिक फ़ंक्शन की तुलना में सी++ में वैरिएडिक टेम्प्लेट (पैरामीटर पैक) के उपयोग को दृढ़ता से प्राथमिकता देते हैं।

गो में
गो (प्रोग्रामिंग भाषा) में वैरिएडिक फ़ंक्शंस को किसी भी संख्या में अनुगामी तर्कों के साथ बुलाया जा सकता है। fmt.Println एक सामान्य विविध कार्य है; यह कैच-ऑल प्रकार के रूप में एक खाली इंटरफ़ेस का उपयोग करता है।

आउटपुट:

 [1 2] का योग 3 है [1 2 3] का योग 6 है [1 2 3 4] का योग 10 है 

जावा में
C# की तरह, {{code|Object}जावा (प्रोग्रामिंग भाषा) में } प्रकार कैच-ऑल के रूप में उपलब्ध है।

जावास्क्रिप्ट में
जावास्क्रिप्ट विभिन्न प्रकार के तर्कों की परवाह नहीं करता है।

तर्क ऑब्जेक्ट का उपयोग करके एक विविध फ़ंक्शन बनाना भी संभव है, हालांकि यह केवल इसके साथ बनाए गए फ़ंक्शन के साथ प्रयोग योग्य है function कीवर्ड.

लुआ (प्रोग्रामिंग भाषा) में
लुआ (प्रोग्रामिंग भाषा) फ़ंक्शंस अन्य फ़ंक्शंस में वैरार्ग को उसी तरह से पास कर सकते हैं जैसे अन्य मानों का उपयोग करते हुए return कीवर्ड. लूआ संस्करण 5.2 या उच्चतर का उपयोग करके तालिकाओं को विविध कार्यों में पारित किया जा सकता है table.unpack, या लुआ 5.1 या उससे कम unpack. vararg को एक मान के रूप में vararg के साथ एक तालिका बनाकर उपयोग किया जा सकता है।

पास्कल (प्रोग्रामिंग भाषा) में
पास्कल (प्रोग्रामिंग भाषा) में चार अंतर्निहित प्रक्रियाएं हैं जिन्हें वैरिएडिक के रूप में परिभाषित किया गया है, जो इस विशेष स्थिति के कारण, कंपाइलर के लिए आंतरिक हैं। ये हैं read, readln, write, और writeln प्रक्रियाएं. हालाँकि, प्रक्रियाओं या कार्यों के लिए डिफ़ॉल्ट तर्क की अनुमति देने वाले वैकल्पिक विनिर्देश हैं जो उन्हें विविध रूप से काम करते हैं, साथ ही बहुरूपता (कंप्यूटर विज्ञान) जो एक प्रक्रिया या फ़ंक्शन को अलग-अलग पैरामीटर रखने की अनुमति देता है। वह read[ln] और write[ln] सभी प्रक्रियाओं का प्रारूप समान है:

 पढ़ें[एलएन] [( [फ़ाइल ,] वेरिएबल [, वेरिएबल ...] )] ; लिखें[एलएन] [( [फ़ाइल][, मूल्य [, मूल्य ...] )] ; 

कहाँ


 * file एक वैकल्पिक फ़ाइल वैरिएबल है, जिसे यदि छोड़ दिया जाए तो यह डिफ़ॉल्ट हो जाता है input के लिए read और readln, या डिफ़ॉल्ट output के लिए write और writeln;
 * variable एक अदिश राशि है जैसे कि चार (वर्ण), पूर्णांक, या वास्तविक (या कुछ कंपाइलरों के लिए, कुछ रिकॉर्ड प्रकार या सरणी प्रकार जैसे स्ट्रिंग); और
 * value एक चर या स्थिरांक है।

उदाहरण:

उपरोक्त उदाहरण में, जहां तक ​​कंपाइलर का सवाल है, लाइनें 9 और 13 समान हैं, क्योंकि यदि input फ़ाइल वेरिएबल है जिसे a द्वारा पढ़ा जा रहा है read या readln कथन, फ़ाइल चर छोड़ा जा सकता है। साथ ही, कंपाइलर पंक्ति 15 और 20 को समान मानता है, क्योंकि यदि फ़ाइल वेरिएबल को लिखा जा रहा है output, इसे छोड़ा जा सकता है, जिसका अर्थ है (पंक्ति 20 पर) चूंकि प्रक्रिया में कोई तर्क पारित नहीं किया जा रहा है, इसलिए तर्कों को सूचीबद्ध करने वाले कोष्ठक को छोड़ा जा सकता है। पंक्ति 26 दर्शाती है writeln कथन में किसी भी संख्या में तर्क हो सकते हैं, और वे एक उद्धृत स्ट्रिंग, एक चर, या यहां तक ​​कि एक सूत्र परिणाम भी हो सकते हैं।

ऑब्जेक्ट पास्कल बहुरूपी प्रक्रियाओं और कार्यों का समर्थन करता है, जहां विभिन्न प्रक्रियाओं या कार्यों का एक ही नाम हो सकता है लेकिन उन्हें दिए गए तर्कों से अलग किया जा सकता है।

पास्कल डिफ़ॉल्ट तर्कों का भी समर्थन करता है, जहां तर्क का मान, यदि प्रदान नहीं किया गया है, तो एक डिफ़ॉल्ट मान दिया जाता है।

पहले उदाहरण के लिए, बहुरूपता, निम्नलिखित पर विचार करें:

उपरोक्त उदाहरण में, यदि add जैसा कि दो पूर्णांक मानों के साथ कहा जाता है, पंक्ति 1 पर घोषित फ़ंक्शन को बुलाया जाएगा; यदि तर्कों में से एक पूर्णांक है और एक वास्तविक है, तो पंक्ति 3 या 4 पर फ़ंक्शन को कॉल किया जाता है, जो इस पर निर्भर करता है कि कौन सा पूर्णांक है। यदि दोनों वास्तविक हैं, तो पंक्ति 2 पर फ़ंक्शन को कॉल किया जाता है।

डिफ़ॉल्ट पैरामीटर के लिए, निम्नलिखित पर विचार करें:

पंक्ति 6 ​​पर, (और नीचे की पंक्तियाँ) पैरामीटर = 0 कंपाइलर को बताता है, यदि कोई तर्क प्रदान नहीं किया गया है, तो तर्क को शून्य मान लें। पंक्ति 19 पर, कोई तर्क नहीं दिया गया, इसलिए फ़ंक्शन वापस आ जाता है 0. लाइन 20 पर, किसी भी तर्क के लिए एक संख्या या एक चर प्रदान किया जा सकता है, और जैसा कि लाइन 22 पर दिखाया गया है, एक स्थिरांक।

पीएचपी में
जब तक तर्क टाइप नहीं किया जाता है तब तक PHP विभिन्न प्रकार के तर्कों की परवाह नहीं करता है।

और विविध तर्क टाइप किए:

पायथन में
पायथन (प्रोग्रामिंग भाषा) विभिन्न प्रकार के तर्कों की परवाह नहीं करता है।

कीवर्ड तर्कों को शब्दकोश में संग्रहित किया जा सकता है, उदा. def bar(*args, **kwargs).

रकु में
राकू (प्रोग्रामिंग भाषा) में, विभिन्न प्रकार के फ़ंक्शन बनाने वाले पैरामीटर के प्रकार को स्लर्पी एरे पैरामीटर के रूप में जाना जाता है और उन्हें तीन समूहों में वर्गीकृत किया जाता है:

चपटा घोल
ये पैरामीटर एकल तारांकन के साथ घोषित किए गए हैं और वे तत्वों की एक या अधिक परतों को भंग करके तर्कों को समतल करते हैं जिन्हें पुनरावृत्त किया जा सकता है (यानी, Iterables)।

 उप foo($a, $b, *@args) { @args.perl कहें; }

फू(1,2) # [] फू(1,2,3) # [3] फू(1, 2, 3, हैलो ) # [3 हैलो ] फू(1, 2, 3, [4, 5], [6]); # [3, 4, 5, 6] 

बिना चपटा घोल
ये पैरामीटर दो तारांकन के साथ घोषित किए गए हैं और वे सूची के भीतर किसी भी पुनरावृत्त तर्क को समतल नहीं करते हैं, लेकिन तर्क को कमोबेश वैसे ही रखते हैं:

 सब बार($a, $b, **@args) { @args.perl कहें; }

बार(1,2); # [] बार(1, 2, 3); #[3] बार(1, 2, 3, हैलो ); # [3 नमस्ते ] बार(1, 2, 3, [4, 5], [6]); # [3, [4, 5], [6 

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

 सब ज़ज़($a, $b, +@args) { @args.perl कहें; }

ज़ज़(1, 2); # [] ज़ज़(1, 2, 3); #[3] ज़ज़(1, 2, 3, हैलो ); # [3 नमस्ते ] ज़ज़(1, 2, [4, 5]); # [4, 5], एकल तर्क सरणी भरता है ज़ज़(1, 2, 3, [4, 5]); # [3, [4, 5, **@ के रूप में व्यवहार करना ज़ज़(1, 2, 3, [4, 5], [6]); # [3, [4, 5], [6, **@ के रूप में व्यवहार करना 

रूबी में
रूबी (प्रोग्रामिंग भाषा) विभिन्न प्रकार के तर्कों की परवाह नहीं करती है।

जंग में
रस्ट (प्रोग्रामिंग भाषा) फ़ंक्शंस में विविध तर्कों का समर्थन नहीं करता है। इसके बजाय, यह मैक्रो (कंप्यूटर विज्ञान) का उपयोग करता है।

जंग ए के माध्यम से सी की विविध प्रणाली के साथ बातचीत करने में सक्षम है c_variadic सुविधा स्विच. अन्य सी इंटरफेस की तरह, सिस्टम पर विचार किया जाता है unsafe जंग लगना।

स्विफ्ट में
स्विफ्ट (प्रोग्रामिंग भाषा) विभिन्न प्रकार के तर्कों की परवाह करती है, लेकिन सभी को पकड़ती है Any प्रकार उपलब्ध है.

टी.सी.एल में
एक टीसीएल प्रक्रिया या लैम्ब्डा तब विविध होती है जब इसका अंतिम तर्क होता है args: इसमें शेष सभी तर्कों की एक सूची (संभवतः खाली) होगी। यह पैटर्न कई अन्य प्रक्रिया-जैसी विधियों में आम है।

यह भी देखें

 * जावा सिंटैक्स#Varargs
 * विविध स्थूल (सी प्रोग्रामिंग भाषा)
 * विविध टेम्पलेट

बाहरी संबंध

 * Variadic function. Rosetta Code task showing the implementation of variadic functions in over fifty programming languages.
 * Variable Argument Functions — A tutorial on Variable Argument Functions for C++
 * GNU libc manual